¿No sería bueno si simplemente pudiéramos cargar algunos PDF, documentos y URL en algún lugar y luego tener un chatbot que pueda responder cualquier pregunta sobre la información allí contenida? Suena impresionante, ¿verdad? Entonces, terminemos con esto, ¿por qué esperar?
Este es el código de Python que usaremos para lograr esto.
from flask import Flask, render_template, request
from flask import Markup
from gpt_index import SimpleDirectoryReader, GPTListIndex, GPTSimpleVectorIndex, LLMPredictor, PromptHelper
from langchain.chat_models import ChatOpenAI
import os
import requests
from bs4 import BeautifulSoup
import re
app = Flask(__name__)os.environ["OPENAI_API_KEY"] = 'Your Open AI key'
def sanitize_file_name(file_name):
# Remove any special characters from the file name
sanitized_name = re.sub(r"[^a-zA-Z0-9_-]", "_", file_name)
return sanitized_name
También te puede interesar
10 indicaciones de peregrinaje que expanden la mente para encender su creatividad | de Héctor B. Morales | junio de 2023def clean_html_tags(text):
# Remove HTML tags using regular expressions
clean_text = re.sub(r"<.*?>", "", text)
return clean_text
def scrape_url(url, directory_path):
try:
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")
cleaned_text = clean_html_tags(soup.get_text())
sanitized_url = sanitize_file_name(url)
filename = os.path.join(directory_path, f"{sanitized_url}.txt")
with open(filename, "w", encoding="utf-8") as text_file:
text_file.write(cleaned_text)
return filename
except Exception as e:
print(f"Failed to scrape URL: {url}")
print(e)
return None
def process_urls(directory_path):
urls_done = []
with open(os.path.join(directory_path, "urls.txt"), "r",encoding='utf-8') as file:
urls = file.readlines()
También te puede interesarDesbloqueando las profundidades: 10 intrigantes indicaciones a mitad de camino para experimentar | de Héctor B. Morales | junio de 2023for url in urls:
url = url.strip()
if not url.endswith("-done"):
text_file = scrape_url(url, directory_path)
if text_file:
urls_done.append(f"{url}-done")
with open(os.path.join(directory_path, "urls.txt"), "a") as file:
for url_done in urls_done:
file.write(url_done + "\n")
def construct_index(directory_path):
max_input_size = 4096
num_outputs = 1024
max_chunk_overlap = 20
chunk_size_limit = 600
prompt_helper = PromptHelper(max_input_size, num_outputs, max_chunk_overlap, chunk_size_limit=chunk_size_limit)
También te puede interesarAmplíe sus horizontes: 10 alucinantes indicaciones a mitad de camino para inspirar | de Héctor B. Morales | junio de 2023llm_predictor = LLMPredictor(llm=ChatOpenAI(temperature=0.2, model_name="gpt-3.5-turbo", max_tokens=num_outputs))
process_urls(directory_path)
documents = SimpleDirectoryReader(directory_path).load_data()
index = GPTSimpleVectorIndex(documents, llm_predictor=llm_predictor, prompt_helper=prompt_helper)
También te puede interesar10 increíbles indicaciones a mitad de camino para despertar su imaginación | de Héctor B. Morales | junio de 2023index.save_to_disk('index.json')
return index
@app.route('/')
def welcome():
return render_template('welcome.html')
@app.route('/chat', methods=['GET', 'POST'])
def chat():
if request.method == 'POST':
input_text = request.form['input_text']
response = chatbot(input_text)
return render_template('chat.html', input_text=input_text, response=response)
return render_template('chat.html')
def chatbot(input_text):
index = GPTSimpleVectorIndex.load_from_disk('index.json')
response = index.query(input_text, response_mode="compact")
response_text = response.response.replace("\n", "<br>")
return Markup(response_text)
if __name__ == '__main__':
index = construct_index("docs")
app.run(host='0.0.0.0')
Ahora, profundicemos un poco más en lo que está sucediendo aquí. Este código crea un índice a partir de los archivos presentes en el documentos carpeta. Recuerde que la carpeta está en el mismo directorio que el código.
1.Indización: el chatbot utiliza el GPTSimpleVectorIndex clase de la gpt_index biblioteca para indexar los documentos de texto procesados. Este índice organiza y almacena la información necesaria para una búsqueda y recuperación eficientes de respuestas relevantes.
2. Incrustaciones y vectores: las incrustaciones son representaciones numéricas de texto que capturan el significado semántico de palabras y frases. En este chatbot, las incorporaciones se generan utilizando un modelo de lenguaje, como GPT-3.5 Turbo de OpenAI. Estas incrustaciones son vectores de alta dimensión que codifican la información contextual del texto.
3. OpenAI: OpenAI proporciona modelos de lenguaje como GPT-3.5 Turbo, que se entrenan previamente en una gran cantidad de datos de texto. Estos modelos pueden generar respuestas similares a las humanas basadas en indicaciones de entrada. En el chatbot, el LLMPredictor clase de la gpt_index biblioteca utiliza los modelos de lenguaje de OpenAI para generar respuestas.
4. Langchain: Langchain es una biblioteca que amplía la funcionalidad de los modelos de lenguaje y simplifica su uso. Proporciona varias clases de utilidad y funciones para trabajar con modelos de lenguaje de manera más eficiente. En este chatbot, el ChatOpenAI clase de la langchain.chat_models El módulo se utiliza como modelo de lenguaje para la generación de respuestas.
5. PromptHelper: El PromptHelper clase de la gpt_index biblioteca ayuda a fragmentar textos de entrada largos en segmentos más pequeños. Tiene en cuenta el tamaño de entrada máximo y la cantidad de salidas permitidas por el modelo de lenguaje y divide el texto de entrada en consecuencia. Esto ayuda a generar respuestas coherentes sin exceder los límites del modelo.
En resumen, el proceso de indexación implica representar los documentos de texto procesados como incrustaciones o vectores utilizando un modelo de lenguaje como GPT-3.5 Turbo de OpenAI. Estas incrustaciones se organizan y almacenan en el GPTSimpleVectorIndex, que permite consultas eficientes basadas en la entrada del usuario. La generación de respuestas aprovecha el modelo de lenguaje y la biblioteca Langchain para generar respuestas similares a las humanas utilizando la información indexada.
Ahora que tenemos eso cubierto, podemos cargar archivos PDF, Docx y txt en el documentos carpeta y ejecute este código. Recuerde, los archivos txt deben tener el formato adecuado, solo deben contener texto válido.
He ejecutado esto con alrededor de 20 a 30 archivos, incluidos archivos PDF, docX y txt. Siéntase libre de jugar con la cantidad de archivos que desea agregar.
Puede agregar cualquier URL de la que desee extraer información en un archivo llamado urls.txt y coloque ese archivo en el documentos carpeta.
No olvide que necesita una clave de Open-AI, así que regístrese y obtenga una. Esto costará dinero. Solo si es como 2–4 $ para el tipo de uso de demostración.
Una vez que se crea el índice, se guarda en el disco y se usa hasta que se realicen cambios en el documentos carpeta. Por lo tanto, ejecutar la aplicación una y otra vez no resultará en el consumo de tokens en OpenAI. Eso solo sucederá la primera vez que procese los archivos en el documentos carpeta.
He puesto esto dentro de una aplicación de matraz para poder tener una página web, en lugar de la terminal, es un front-end muy básico que puedes personalizar como quieras.
Puede obtener los archivos html, css y los requisitos.txt para esto, aquí. ¡Déjame saber como va!
Actualización 23/06/2023: – Entonces, tuve la oportunidad de usar GPT4All Local LLM. Debo mencionar que el rendimiento/precisión de este modelo es mucho mejor que un LLM local
