Los asistentes de investigación conversacionales con impulso de trapo abordan las limitaciones de los modelos de idiomas tradicionales al combinarlos con los sistemas de recuperación de información. El sistema investigación bases de conocimiento específicas, recupera información relevante y la presenta conversación con citas adecuadas. Este enfoque reduce las alucinaciones, maneja el conocimiento específico del dominio y las respuestas basadas en el texto recuperado. En este tutorial, demostraremos la construcción de tal asistente utilizando el maniquí de código hendido Tinyllama-1.1b-chat-V1.0 de abrazar la cara, Faiss de Meta y el entorno Langchain para contestar preguntas sobre documentos científicos.
Primero, instalemos las bibliotecas necesarias:
!pip install langchain-community langchain pypdf sentence-transformers faiss-cpu transformers accelerate einopsAhora, importemos las bibliotecas requeridas:
import os
import torch
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain.chains import ConversationalRetrievalChain
from langchain_community.llms import HuggingFacePipeline
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import pandas as pd
from IPython.display import display, MarkdownMontaremos la mecanismo para meter el papel en un paso más:
from google.colab import drive
drive.mount('/content/drive')
print("Google Drive mounted")Para nuestra colchoneta de conocimiento, utilizaremos documentos PDF de artículos científicos. Creemos una función para cargar y procesar estos documentos:
def load_documents(pdf_folder_path):
documents = ()
if not pdf_folder_path:
print("Downloading a sample paper...")
!wget -q https://arxiv.org/pdf/1706.03762.pdf -O attention.pdf
pdf_docs = ("attention.pdf")
else:
pdf_docs = (os.path.join(pdf_folder_path, f) for f in os.listdir(pdf_folder_path)
if f.endswith('.pdf'))
print(f"Found {len(pdf_docs)} PDF documents")
for pdf_path in pdf_docs:
try:
loader = PyPDFLoader(pdf_path)
documents.extend(loader.load())
print(f"Loaded: {pdf_path}")
except Exception as e:
print(f"Error loading {pdf_path}: {e}")
return documents
documents = load_documents("")A continuación, necesitamos dividir estos documentos en trozos más pequeños para una recuperación efectivo:
def split_documents(documents):
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
length_function=len,
)
chunks = text_splitter.split_documents(documents)
print(f"Split {len(documents)} documents into {len(chunks)} chunks")
return chunks
chunks = split_documents(documents)
Usaremos transformadores de oraciones para crear integridades vectoriales para nuestros fragmentos de documentos:
def create_vector_store(chunks):
print("Loading embedding model...")
embedding_model = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2",
model_kwargs={'device': 'cuda' if torch.cuda.is_available() else 'cpu'}
)
print("Creating vector store...")
vector_store = FAISS.from_documents(chunks, embedding_model)
print("Vector store created successfully!")
return vector_store
vector_store = create_vector_store(chunks)
Ahora, cargamos un maniquí de jerga de código hendido para ocasionar respuestas. Usaremos Tinyllama, que es lo suficientemente pequeño como para valer en Colab pero aún lo suficientemente potente para nuestra tarea:
def load_language_model():
print("Loading language model...")
model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
try:
import subprocess
print("Installing/updating bitsandbytes...")
subprocess.check_call(("pip", "install", "-U", "bitsandbytes"))
print("Successfully installed/updated bitsandbytes")
except:
print("Could not update bitsandbytes, will proceed without 8-bit quantization")
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
import torch
tokenizer = AutoTokenizer.from_pretrained(model_id)
if torch.cuda.is_available():
try:
quantization_config = BitsAndBytesConfig(
load_in_8bit=True,
llm_int8_threshold=6.0,
llm_int8_has_fp16_weight=False
)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="coche",
quantization_config=quantization_config
)
print("Model loaded with 8-bit quantization")
except Exception as e:
print(f"Error with quantization: {e}")
print("Falling back to standard model loading without quantization")
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="coche"
)
else:
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.float32,
device_map="coche"
)
pipe = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
max_length=2048,
temperature=0.2,
top_p=0.95,
repetition_penalty=1.2,
return_full_text=False
)
from langchain_community.llms import HuggingFacePipeline
llm = HuggingFacePipeline(pipeline=pipe)
print("Language model loaded successfully!")
return llm
llm = load_language_model()
Ahora, construamos nuestro asistente combinando la tienda Vector y el maniquí de idioma:
def format_research_assistant_output(query, response, sources):
output = f"n{'=' * 50}n"
output += f"USER QUERY: {query}n"
output += f"{'-' * 50}nn"
output += f"ASSISTANT RESPONSE:n{response}nn"
output += f"{'-' * 50}n"
output += f"SOURCES REFERENCED:nn"
for i, doc in enumerate(sources):
output += f"Source #{i+1}:n"
content_preview = doc.page_content(:200) + "..." if len(doc.page_content) > 200 else doc.page_content
wrapped_content = textwrap.fill(content_preview, width=80)
output += f"{wrapped_content}nn"
output += f"{'=' * 50}n"
return output
import textwrap
research_assistant = create_research_assistant(vector_store, llm)
test_queries = (
"What is the key idea behind the Transformer model?",
"Explain self-attention mechanism in simple terms.",
"Who are the authors of the paper?",
"What are the main advantages of using attention mechanisms?"
)
for query in test_queries:
response, sources = research_assistant(query, return_sources=True)
formatted_output = format_research_assistant_output(query, response, sources)
print(formatted_output)En este tutorial, construimos un asistente de investigación conversacional utilizando una engendramiento acuática de recuperación con modelos de código hendido. TRAPO Alivio los modelos de idiomas integrando la recuperación de documentos, reduciendo la deslumbramiento y garantizando la precisión específica del dominio. La mentor camina a través de la configuración del medio condición, procesando documentos científicos, creando integridades vectoriales utilizando transformadores de faiss y oraciones e integrar un maniquí de jerga de código hendido como Tinyllama. El asistente recupera los fragmentos de documentos relevantes y genera respuestas con citas. Esta implementación permite a los usuarios consultar una colchoneta de conocimiento, lo que hace que la investigación con AI sea más confiable y efectivo para contestar preguntas específicas del dominio.
Aquí está el Cuaderno de colab. Por otra parte, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRespolvorear. No olvides unirte a nuestro 85k+ ml de subreddit.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como patrón e ingeniero fantasioso, ASIF se compromete a exprimir el potencial de la inteligencia industrial para el adecuadamente social. Su esfuerzo más nuevo es el tiro de una plataforma de medios de inteligencia industrial, MarktechPost, que se destaca por su cobertura profunda de noticiero de enseñanza mecánico y de enseñanza profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el divulgado.