Aprovechando el RAG con URLs de Reddit sobre la diabetes: LLMs de código abierto para la recuperación de conocimientos mejorados

Los modelos de lenguaje de gran tamaño son increíblemente potentes y es impresionante que se hayan entrenado con un vasto corpus de datos. Sin embargo, ¿cuántos de nosotros, al embarcarnos en nuestra aventura como fundadores, tenemos el presupuesto para entrenar estos modelos internamente? Probablemente, muy pocos.

Pero un momento, ¿nos sirven estos LLM preentrenados? Claro, si son de código abierto. Por suerte, ya hay bastantes disponibles.

Entonces, ¿cómo son exactamente útiles? La mayoría de quienes trabajamos en IA conocemos las RAG o al menos hemos oído hablar de ellas. Permítanme darles una definición sencilla. La generación aumentada por recuperación es exactamente lo que parece: recupera datos de las fuentes externas que proporcionamos y los amplía con el resultado LLM.

Es sumamente útil porque aprovecha el poder generativo de los LLM a la vez que incorpora el conocimiento que proporcionamos externamente para generar resultados a partir del corpus deseado. Si se cuenta con un corpus externo limitado, podemos usar el modelo como base del conocimiento general del LLM.

Me interesa especialmente cómo comemos y creo firmemente en el concepto de "basura entra, basura sale" en lo que respecta a la comida y al cuerpo. Si nos nutrimos con alimentos naturalmente saludables, reflejamos la naturaleza: fuertes, vibrantes e imparables. Pero si consumimos alimentos artificiales y sin vida, empezamos a vernos y sentirnos igual: agotados y antinaturales. Una de las peores consecuencias del consumo excesivo de alimentos artificiales y refinados hoy en día es la diabetes.

¿Y quién comprende realmente los verdaderos problemas de vivir con diabetes? Es simple: quienes la viven en primera persona. Dado mi interés en obtener datos experienciales sobre diabetes mediante LLM, realicé este experimento con Ollama, uno de los muchos LLM de código abierto que pueden utilizarse para estas tareas.

Comparto mi cuaderno paso a paso con una explicación de cada etapa. Además, para facilitar la comprensión, incluyo un diagrama de arquitectura de alto nivel.

Paso 1: Obtener y procesar contenido de varias URL. Extraemos texto de la lista de URL de Reddit proporcionada y lo almacenamos en all_texts.

 # Import necessary libraries import requests from bs4 import BeautifulSoup from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.embeddings import OllamaEmbeddings from langchain.vectorstores import FAISS from langchain.chains import RetrievalQA from langchain.prompts import PromptTemplate from langchain.llms import Ollama # List of URLs to scrape urls = [ 'https://www.reddit.com/r/diabetes/comments/1broigp/what_are_your_biggest_frustrations_with_diabetes/', 'https://www.reddit.com/r/diabetes_t2/comments/156znkx/whats_the_most_challenging_part_about_dealing/', 'https://www.reddit.com/r/diabetes/comments/qcsgji/what_is_the_hardest_part_about_managing_diabetes/', 'https://www.reddit.com/r/diabetes_t1/comments/1hdlipr/diabetes_and_pain/', 'https://www.reddit.com/r/diabetes/comments/ww6mrj/what_does_diabetic_nerve_pain_feel_like/', 'https://www.reddit.com/r/AskReddit/comments/avl1x0/diabetics_of_reddit_what_is_your_experience_of/', 'https://www.reddit.com/r/diabetes_t2/comments/1jggxi9/my_fathers_sugar_levels_are_not_dropping/', 'https://www.reddit.com/r/diabetes_t2/comments/1jglmie/shaky_feeling/', 'https://www.reddit.com/r/diabetes_t2/comments/1jgccvo/rant_from_a_depressedeating_disordered_diabetic/' ] # Initialize text storage all_texts = [] # Step 1: Fetch and process content from multiple URLs for url in urls: response = requests.get(url) soup = BeautifulSoup(response.text, 'html.parser') # Extract text from <p> tags text = ' '.join([para.get_text() for para in soup.find_all('p')]) if text: # Store only if text is found all_texts.append(text)

Paso 2: Dividimos el texto extraído en fragmentos más manejables para un procesamiento más eficiente. También podemos reducir el uso de memoria y mejorar el rendimiento de la búsqueda.

 # Step 2: Split all content into chunks text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50) all_chunks = [] for text in all_texts: all_chunks.extend(text_splitter.split_text(text))

Paso 3: Inicializamos las incrustaciones de Ollama. Estas incrustaciones son representaciones numéricas (vectoriales) de texto sin procesar que capturan su significado semántico. Permiten que diversos modelos de aprendizaje automático procesen y comprendan el texto eficazmente. La clase OllamaEmbeddings utiliza el modelo llama2 para generar estas incrustaciones.

 # Step 3: Initialize Ollama embeddings embeddings = OllamaEmbeddings(model="llama2") # Adjust model name if needed

Paso 4: Facebook AI Similarity Search (FAISS) es una biblioteca para la búsqueda eficiente de similitudes y la agrupación de vectores de alta dimensión. La función from_texts convierte fragmentos de texto en vectores (del paso 3) y los almacena en el almacén de vectores de FAISS. FAISS ayuda a encontrar fragmentos similares a la consulta comparando distancias vectoriales (coseno, euclidiana) de forma altamente optimizada.

 # Step 4: Create a FAISS vector store using all chunks vector_store = FAISS.from_texts(all_chunks, embeddings)

Paso 5: Inicializamos Ollama LLM, que generará respuestas o procesará consultas basadas en el conocimiento almacenado en incrustaciones en el almacén de vectores FAISS del paso 4.

 # Step 5: Initialize the Ollama LLM llm = Ollama(model="llama2", temperature=0.3)

En conjunto, los pasos 3 a 5 habilitan RAG, donde LLM puede extraer conocimiento de fragmentos almacenados en el almacén de vectores y usar el contexto recuperado para responder la consulta de un usuario de la manera más relevante.

Paso 6: Aquí, definimos la función ask_question_with_fallback para consultar el conocimiento almacenado y responder a la consulta del usuario. Si no encuentra documentación similar o la puntuación de similitud es baja, recurrirá al conocimiento general del LLM subyacente (Ollama en este caso).

 # Step 6: Create the question-answering function def ask_question_with_fallback(query): # Retrieve relevant documents docs = vector_store.similarity_search(query, k=3) docs = vector_store.similarity_search(query, k=3) for doc in docs: print(f"Retrieved doc: {doc.page_content[:200]}") # If no relevant documents or low similarity, use general knowledge #if not docs or all(doc.metadata.get('score', 1.0) < 0.3 for doc in docs): # return use_general_knowledge(query) if not docs: return use_general_knowledge(query) # Format retrieved documents as context context = "\n\n".join([doc.page_content for doc in docs]) # Construct RAG prompt rag_prompt = f""" Use the following pieces of context to answer the question at the end. If you don't know the answer based on this context, respond with "NO_ANSWER_FOUND". Context: {context} Question: {query} Provide a direct and concise answer to the question based only on the context above: """ rag_answer = llm(rag_prompt) # Check for fallback trigger if "NO_ANSWER_FOUND" in rag_answer or "don't know" in rag_answer.lower() or "cannot find" in rag_answer.lower(): return use_general_knowledge(query) return { "answer": rag_answer, "source": "URL content", "source_documents": docs }

Paso 7: Esta es la función de respaldo. Si no se pudieron recuperar documentos relevantes en el paso 6, el LLM utiliza su conocimiento general para responder la consulta del usuario.

 # Step 7: Define fallback general knowledge function def use_general_knowledge(query): general_prompt = f""" Answer this question using your general knowledge: {query} Provide a direct and helpful response. If you don't know, simply say so. """ general_answer = llm(general_prompt) return { "answer": general_answer, "source": "General knowledge", "source_documents": [] }

Paso 8: Este paso muestra un ejemplo de cómo usar este mecanismo RAG. Se proporciona una consulta al modelo y LLM utiliza conocimiento externo o interno para responderla.

 #Step 8 # Example usage query = "What is the hardest part about managing diabetes?" # Replace with your actual question result = ask_question_with_fallback(query) # Display results print("Answer:") print(result["answer"]) print(f"\nSource: {result['source']}") if result["source_documents"]: print("\nSource Documents:") for i, doc in enumerate(result["source_documents"]): print(f"Source {i+1}:") print(doc.page_content[:200] + "...") # Print first 200 chars of each source print()

A continuación, se muestra el resultado del paso 8. El modelo utiliza RAG, que identifica un documento similar del almacén FAISS y responde a mi consulta.

En conclusión, aprovechar RAG con URL es un enfoque eficaz para mejorar la recuperación de información en consultas relacionadas con la diabetes. Al combinar información práctica de plataformas comunitarias como Reddit con LLM de código abierto, podemos ofrecer información personalizada y precisa; después de todo, ¿quién la entiende mejor que quienes viven con ella a diario?

Este método no solo es rentable, sino que también fomenta la colaboración, mejorando así el apoyo a las personas que controlan la diabetes. A medida que la IA continúa evolucionando, su potencial para mejorar la atención médica y el bienestar sigue siendo enorme.

Foto destacada de Suzy Hazelwood: https://www.pexels.com/photo/close-up-photo-of-sugar-cubes-in-glass-jar-2523650/