Construyendo su bot de preguntas y respuestas de IA para páginas web utilizando modelos AI de código abierto

En el panorama digital rico en información actual, navegar contenido web extenso puede ser abrumador. Ya sea que esté investigando para un proyecto, estudiando material complejo o intente extraer información específica de largos artículos, el proceso puede llevar mucho tiempo e ineficiente. Aquí es donde un bot de respuesta (preguntas y respuestas) con AI se vuelve invaluable.

Este tutorial lo guiará a través de la creación de un sistema práctico de preguntas y respuestas de AI que pueda analizar el contenido de la página web y responder preguntas específicas. En lugar de confiar en los costosos servicios de API, utilizaremos modelos de código abierto desde abrazos para crear una solución que es:

• Completamente gratis de usar
• Se ejecuta en Google Colab (no se requiere una configuración local)
• Personalizable a sus necesidades específicas
• Construido sobre tecnología de PNL de vanguardia

Al final de este tutorial, tendrá un sistema de preguntas y respuestas web funcionales que puede ayudarlo a extraer información del contenido en línea de manera más eficiente.

Lo que construiremos

Crearemos un sistema que:

1. Toma una URL como entrada
2. Extrae y procesa el contenido de la página web
3. Acepta preguntas de lenguaje natural sobre el contenido
4. Proporciona respuestas precisas y contextuales basadas en la página web

Requisitos previos

• Una cuenta de Google para acceder a Google Colab
• Comprensión básica de Python
• No aprendizaje automático Conocimiento requerido

Paso 1: Configuración del entorno

Primero, creemos un nuevo cuaderno de Google Colab. Ir a Google Colab y crear un nuevo cuaderno.

Comencemos por instalar las bibliotecas necesarias:

# Instalar paquetes requeridos

!pip install transformers torch beautifulsoup4 requests

Esto instala:

• Transformers: Abrazando la biblioteca de Face para modelos de PNL de última generación
• Antorcha: Pytorch aprendizaje profundo estructura
• BeautifulSoup4: para analizar HTML y extraer contenido web
• Solicitudes: para realizar solicitudes HTTP en páginas web

Paso 2: Importar bibliotecas y configurar funciones básicas

Ahora importemos todas las bibliotecas necesarias y definamos algunas funciones de ayuda:

import torch
from transformers import AutoModelForQuestionAnswering, AutoTokenizer
import requests
from bs4 import BeautifulSoup
import re
import textwrap

# Verifique si hay GPU disponible

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {device}")

# Función para extraer texto de una página web

def extract_text_from_url(url):
   try:
       headers = {
           'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
       }
       response = requests.get(url, headers=headers)
       response.raise_for_status()  
       soup = BeautifulSoup(response.text, 'html.parser')


       for script_or_style in soup(['script', 'style', 'header', 'footer', 'nav']):
           script_or_style.decompose()


       text = soup.get_text()


       lines = (line.strip() for line in text.splitlines())
       chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
       text="n".join(chunk for chunk in chunks if chunk)


       text = re.sub(r's+', ' ', text).strip()


       return text


   except Exception as e:
       print(f"Error extracting text from URL: {e}")
       return None

Este código:

1. Importa todas las bibliotecas necesarias
2. Establezca nuestro dispositivo (GPU si está disponible, de lo contrario CPU)
3. Crea una función para extraer contenido de texto legible de una URL de la página web

Paso 3: Cargue el modelo de preguntas sobre la pregunta

Ahora cargamos un modelo de pregunta de pregunta prevenida de la cara abrazada:

# Cargar modelo y tokenizador previamente capacitado

model_name = "deepset/roberta-base-squad2"


print(f"Loading model: {model_name}")
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForQuestionAnswering.from_pretrained(model_name).to(device)
print("Model loaded successfully!")

Estamos usando DeepSet/Roberta-Base-Squad2que es:

• Basado en Roberta Architecture (un enfoque de Bert optimizado robusto)
• Autorado en el escuadrón 2.0 (conjunto de datos de respuesta a la pregunta de Stanford)
• Un buen equilibrio entre precisión y velocidad para nuestra tarea

Paso 4: Implementar la función de respuesta de pregunta

Ahora, implementemos la funcionalidad central: la capacidad de responder preguntas basadas en el contenido de la página web extraída:

def answer_question(question, context, max_length=512):
   max_chunk_size = max_length - len(tokenizer.encode(question)) - 5  
   all_answers = []


   for i in range(0, len(context), max_chunk_size):
       chunk = context[i:i + max_chunk_size]


       inputs = tokenizer(
           question,
           chunk,
           add_special_tokens=True,
           return_tensors="pt",
           max_length=max_length,
           truncation=True
       ).to(device)


       with torch.no_grad():
           outputs = model(**inputs)


       answer_start = torch.argmax(outputs.start_logits)
       answer_end = torch.argmax(outputs.end_logits)


       start_score = outputs.start_logits[0][answer_start].item()
       end_score = outputs.end_logits[0][answer_end].item()
       score = start_score + end_score


       input_ids = inputs.input_ids.tolist()[0]
       tokens = tokenizer.convert_ids_to_tokens(input_ids)


       answer = tokenizer.convert_tokens_to_string(tokens[answer_start:answer_end+1])


       answer = answer.replace("[CLS]", "").replace("[SEP]", "").strip()


       if answer and len(answer) > 2:  
           all_answers.append((answer, score))


   if all_answers:
       all_answers.sort(key=lambda x: x[1], reverse=True)
       return all_answers[0][0]
   else:
       return "I couldn't find an answer in the provided content."

Esta función:

1. Toma una pregunta y el contenido de la página web como entrada
2. Maneja contenido largo procesándolo en trozos
3. Utiliza el modelo para predecir el tramo de respuesta (posiciones de inicio y finalización)
4. Procesa múltiples fragmentos y devuelve la respuesta con el puntaje de confianza más alto

Paso 5: Pruebas y ejemplos

Probemos nuestro sistema con algunos ejemplos. Aquí está el código completo:

url = "https://en.wikipedia.org/wiki/Artificial_intelligence"
webpage_text = extract_text_from_url(url)


print("Sample of extracted text:")
print(webpage_text[:500] + "...")


questions = [
   "When was the term artificial intelligence first used?",
   "What are the main goals of AI research?",
   "What ethical concerns are associated with AI?"
]


for question in questions:
   print(f"nQuestion: {question}")
   answer = answer_question(question, webpage_text)
   print(f"Answer: {answer}")

Esto demostrará cómo funciona el sistema con ejemplos reales.

Limitaciones y mejoras futuras

Nuestra implementación actual tiene algunas limitaciones:

1. Puede luchar con páginas web muy largas debido a las limitaciones de la longitud del contexto
2. El modelo puede no entender preguntas complejas o ambiguas.
3. Funciona mejor con contenido fáctico en lugar de opiniones o material subjetivo

Las mejoras futuras podrían incluir:

• Implementación de una búsqueda semántica para manejar mejor los documentos largos
• Agregar capacidades de resumen de documentos
• Soporte de varios idiomas
• Implementación de la memoria de preguntas y respuestas anteriores
• Ajuste del modelo en dominios específicos (por ejemplo, médico, legal, técnico)

Conclusión

Ahora ha creado con éxito su sistema de preguntas y respuestas con Proporias de IA para páginas web utilizando modelos de código abierto. Esta herramienta puede ayudarte:

• Extraer información específica de largos artículos
• Investigar de manera más eficiente
• Obtenga respuestas rápidas de documentos complejos

Al utilizar los poderosos modelos de Hugging Face y la flexibilidad de Google Colab, ha creado una aplicación práctica que demuestra las capacidades de la PNL moderna. Siéntase libre de personalizar y extender este proyecto para satisfacer sus necesidades específicas.

Recursos útiles

Aquí está el Cuaderno de colab. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 85k+ ml de subreddit.

🔥 [Register Now] Conferencia virtual de Minicon sobre código abierto AI: Registro gratuito + Certificado de Asistencia + Evento corto de 3 horas (12 de abril, 9 a.m. a 12 p.m. PST) + Hands on Workshop [Sponsored]

Asjad es consultor interno en MarktechPost. Está persiguiendo B.Tech en Ingeniería Mecánica en el Instituto de Tecnología Indio, Kharagpur. Asjad es un entusiasta de aprendizaje automático y aprendizaje profundo que siempre está investigando las aplicaciones del aprendizaje automático en la atención médica.