Sfruttare RAG con URL Reddit sul diabete: LLM open source per un recupero avanzato delle conoscenze

I Large Language Model sono incredibilmente potenti ed è impressionante che siano stati addestrati su un vasto corpora di dati. Tuttavia, quanti di noi, mentre intraprendiamo il nostro viaggio da Fondatori, hanno il budget per addestrare questi modelli internamente? Probabilmente, molto pochi.

Ma aspetta, questi LLM pre-addestrati ci sono utili? Certo, se sono open source. Fortunatamente, ora ne sono disponibili parecchi.

Quindi, in che modo sono utili esattamente? La maggior parte di noi nel campo dell'intelligenza artificiale è a conoscenza dei RAG o ne ha almeno sentito parlare. Lasciatemi fornire una semplice definizione in una riga. La generazione aumentata dal recupero è esattamente ciò che sembra: recupera i dati dalle fonti esterne che forniamo e li aumenta nell'output LLM.

È estremamente utile perché sfrutta il potere generativo degli LLM, incorporando al contempo la conoscenza che forniamo esternamente per generare output dal corpus desiderato. Se si dispone di un corpus esterno limitato, possiamo lasciare che il modello ricada sulla conoscenza generale dell'LLM.

Sono particolarmente interessato a come mangiamo e credo profondamente nel concetto di "garbage in, garbage out" quando si tratta di cibo e corpi. Se ci nutriamo di cibi naturalmente sani, riflettiamo la natura: forte, vibrante e inarrestabile. Ma se consumiamo cibi artificiali e senza vita, iniziamo ad apparire e a sentirci uguali: svuotati e innaturali. Una delle peggiori conseguenze dell'eccessivo consumo di cibo artificiale e raffinato oggi è il diabete.

E chi comprende davvero i veri punti dolenti della vita con il diabete? È semplice: le persone che lo sperimentano in prima persona. Dato il mio interesse nel reperire dati esperienziali sul diabete tramite LLM, ho condotto questo esperimento con Ollama, uno dei tanti LLM open source che possono essere utilizzati per tali attività.

Condivido il mio notebook passo dopo passo con una spiegazione per ogni fase. Inoltre, per facilitare la comprensione, sto includendo un diagramma di architettura di alto livello.

Fase 1: Recupera ed elabora il contenuto da più URL. Estraiamo il testo dall'elenco fornito di URL Reddit e lo memorizziamo in 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)

Fase 2: dividiamo il testo estratto in blocchi più gestibili per un'elaborazione efficiente del testo. Possiamo anche ridurre l'utilizzo della memoria e migliorare le prestazioni di ricerca.

 # 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))

Fase 3: Inizializziamo gli embedding di Ollama. Gli embedding sono rappresentazioni numeriche (vettoriali) di testo grezzo che catturano il significato semantico del testo. Gli embedding consentono a vari modelli ML di elaborare e comprendere il testo in modo efficace. La classe OllamaEmbedding sfrutta il modello llama2 per generare questi embedding.

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

Fase 4: Facebook AI Similarity Search (FAISS) è una libreria per la ricerca efficiente di similarità e il clustering di vettori ad alta dimensione. La funzione from_texts converte blocchi di testo in vettori (dalla fase 3) e li memorizza nell'archivio vettori FAISS. FAISS ti aiuta a trovare blocchi simili alla tua query confrontando le distanze vettoriali (coseno, euclideo) in modo altamente ottimizzato.

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

Fase 5: Inizializziamo Ollama LLM, che genererà risposte o elaborerà query basate sulle conoscenze archiviate negli embedding nell'archivio vettoriale FAISS dal passaggio 4.

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

Insieme, i passaggi da 3 a 5 abilitano RAG, dove l'LLM può estrarre informazioni da blocchi memorizzati nell'archivio vettoriale e utilizzare il contesto recuperato per rispondere alla query di un utente nel modo più pertinente.

Fase 6: Qui definiamo la funzione ask_question_with_fallback per interrogare la conoscenza archiviata per rispondere alla query di un utente. Ma se non riesce a trovare documenti simili o il punteggio di similarità è basso, tornerà alla conoscenza generale dell'LLM sottostante (Ollama qui).

 # 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 }

Fase 7: Questa è la funzione di fallback. Se non è stato possibile recuperare alcun documento rilevante nella fase 6, l'LLM utilizza la sua conoscenza generale per rispondere alla query dell'utente.

 # 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": [] }

Fase 8: Questa fase mostra un esempio di come usare questo meccanismo RAG. Fornisci una query al modello e LLM usa conoscenze esterne o interne per rispondere alla tua query.

 #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()

Il mio output dal passaggio 8 è riportato di seguito. Il modello utilizza RAG, che identifica un documento simile dall'archivio FAISS e risponde alla mia query.

In conclusione, sfruttare RAG con URL è un approccio potente per un recupero di conoscenze migliorato nelle query relative al diabete. Combinando approfondimenti del mondo reale da piattaforme della comunità come Reddit su LLM open source, possiamo offrire informazioni personalizzate e accurate: dopotutto, chi le capisce meglio di chi ci convive ogni giorno?

Questo metodo non è solo conveniente, ma favorisce anche la collaborazione, migliorando in ultima analisi il supporto per gli individui che gestiscono il diabete. Mentre l'intelligenza artificiale continua a evolversi, il suo potenziale per migliorare l'assistenza sanitaria e il benessere rimane vasto.

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