Crea el código para maximizar la similitud semántica en el siguiente código con el…
- User
Crea el código para maximizar la similitud semántica en el siguiente código con el Framework Ray Tune. El código fuente es el siguiente: "# -- coding: utf-8 -- import os
"""Partition, and chunk your file so that the logical structure of the document is preserved for better RAG results."""
import fitz # PyMuPDF
Abre el documento PDF
archivo_pdf = "Full.pdf" doc = fitz.open(archivo_pdf)
Lista para contener ‘elements’ con texto y metadatos
elements = []
Iterar a través de las páginas para extracción de texto
for pagina in doc: # Extraer texto de la página texto_pagina = pagina.get_text()
# Extraer metadatos (esto será igual para todas las páginas, así que podrías hacerlo una vez fuera del bucle) metadata = doc.metadata # Añadir texto y metadatos a ‘elements’ elements.append({"text": texto_pagina, "metadata": metadata})"""Create LangChain documents from document chunks and their metadata, and ingest those documents into the FAISS vectorstore.
Set up the retriever. """
from langchain_core.documents import Document from langchain.vectorstores import FAISS from langchain.embeddings import HuggingFaceEmbeddings
documents = [] for element in elements: # Si tu ‘element’ es un objeto con métodos, asegúrate de cambiar los accesos a atributos/propiedades adecuadamente metadata = element['metadata'] if 'metadata' in element else {} documents.append(Document(page_content=element['text'], metadata=metadata))
db = FAISS.from_documents(documents, HuggingFaceEmbeddings(model_name="BAAI/bge-base-en-v1.5")) retriever = db.as_retriever(search_type="similarity", search_kwargs={"k": 4})
"""To run this tutorial in the free Colab GPU, we'll need to quantize the model:"""
import torch from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
model_name = "meta-llama/Meta-Llama-3-8B-Instruct"
bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16 )
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config) tokenizer = AutoTokenizer.from_pretrained(model_name)
from langchain.llms import HuggingFacePipeline from langchain.prompts import PromptTemplate from transformers import pipeline from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough
terminators = [ tokenizer.eos_token_id, tokenizer.convert_tokens_to_ids("<|eot_id|>") ]
text_generation_pipeline = pipeline( model=model, tokenizer=tokenizer, task="text-generation", temperature=0.2, do_sample=True, repetition_penalty=1.1, return_full_text=False, max_new_tokens=200, eos_token_id=terminators, )
llm = HuggingFacePipeline(pipeline=text_generation_pipeline)
prompt_template = """ <|start_header_id|>user<|end_header_id|> You are an assistant for answering questions about IPM. You are given the extracted parts of a long document and a question. Provide a conversational answer. If you don't know the answer, just say "I do not know." Don't make up an answer. Question: {question} Context: {context}<|eot_id|><|start_header_id|>assistant<|end_header_id|> """
prompt = PromptTemplate( input_variables=["context", "question"], template=prompt_template, )
llm_chain = prompt | llm | StrOutputParser() rag_chain = {"context": retriever, "question": RunnablePassthrough()} | llm_chain
"""## Integrado"""
import json import gc
Cargar el archivo JSON
with open('Full.json', 'r') as file: data = json.load(file)
from sentence_transformers import SentenceTransformer, util
Initialize your sentence transformer model for semantic similarity calculation
model = SentenceTransformer('all-MiniLM-L6-v2')
Obtener las respuestas del JSON
responses = list(data["responses"].values()) queries = list(data["queries"].values())
Calcular la similitud del coseno
similarity_scores = []
print(queries) for query in queries: gc.collect() answers = rag_chain.invoke(query) print(answers) gc.collect()
Encode both the given answer and the expected answer to get their embeddings
given_answer_embedding = model.encode(answers, convert_to_tensor=True) expected_answer_embedding = model.encode(responses[queries.index(query)], convert_to_tensor=True)
Calculate cosine similarity
similarity = util.cos_sim(given_answer_embedding, expected_answer_embedding) "
- Assistant
Para maximizar la similitud semántica utilizando Ray Tune en el código proporcionado, primero debemos integrar el proceso de optimización de hiperparámetros que Ray Tune ofrece. Podemos hacer esto definiendo un espacio de búsqueda para los parámetros que queremos optimizar, como pueden ser los relacionados con la generación de texto (por ejemplo,
temperature,repetition_penalty,max_new_tokens) y cualquier otro parámetro relevante para mejorar la calidad y la similitud semántica de las respuestas generadas.Primero, debes asegurarte de que Ray y Ray Tune estén instalados en tu entorno. Si no lo están, puedes instalarlos con pip:
pip install "ray[tune]"Luego, necesitamos adaptar el código para que utilice una función de entrenamiento que sea compatible con Ray Tune. Esta función debe recibir una configuración de parámetros (
config) de Ray Tune y utilizar estos parámetros en el proceso de generación de respuestas y cálculo de similitud semántica.Aquí hay un ejemplo básico de cómo podrías configurar y ejecutar la optimización con Ray Tune. Toma en cuenta que este es solo un punto de partida y es posible que necesites adaptar la
tune_functiony los espacios de parámetros (search_space) según tus necesidades específicas y los límites prácticos de los parámetros:from ray import tune from ray.tune import CLIReporter from ray.tune.schedulers import ASHAScheduler def tune_function(config): # Aquí, podrías inicializar y configurar el text generation pipeline con los parámetros de 'config' # Por simplicidad, asumiremos que modificamos solamente 'temperature' y 'max_new_tokens' text_generation_pipeline = pipeline( model=model, tokenizer=tokenizer, task="text-generation", temperature=config["temperature"], do_sample=True, repetition_penalty=config["repetition_penalty"], return_full_text=False, max_new_tokens=config["max_new_tokens"], eos_token_id=terminators, ) # El resto del código se mantiene igual, pero asegúrate de que se use el pipeline actualizado # ... # Lugar donde se invoca el pipeline de generación de texto y cálculo de similitud # Por simplicidad, vamos a asumir un valor simulado para "similarity" como resultado # En tu código deberás calcular realmente la similitud basado en las operaciones descritas previamente. # Suponiendo que similarity es lo que queremos optimizar tune.report(mean_similarity=similarity.mean().item()) # Imaginativo; ajusta esto a cómo realmente calculas la similitud # Definir el espacio de búsqueda para los hiperparámetros search_space = { "temperature": tune.uniform(0.1, 1.0), "repetition_penalty": tune.uniform(1.0, 2.0), "max_new_tokens": tune.choice([50, 100, 200]), } # Configurar el scheduler y el reporter scheduler = ASHAScheduler( metric="mean_similarity", mode="max", max_t=100, grace_period=10, reduction_factor=2 ) reporter = CLIReporter( metric_columns=["mean_similarity", "training_iteration"] ) # Ejecutar la optimización analysis = tune.run( tune_function, resources_per_trial={"cpu": 1}, config=search_space, num_samples=10, scheduler=scheduler, progress_reporter=reporter ) # Encuentra y muestra los mejores parámetros best_config = analysis.get_best_config(metric="mean_similarity", mode="max") print("Mejor configuración: ", best_config)Por favor, ten en cuenta que este código es solo un punto de partida. Necesitarás adaptar la función
tune_functionpara que realmente ejecute tu pipeline de procesamiento de texto, genere respuestas utilizando los parámetros de configuración proporcionados por Ray Tune y luego calcule la similitud semántica de manera efectiva entre las respuestas generadas y las esperadas. - User
Crea el código para maximizar la similitud semántica con el Framework Ray Tune. Optimiza los hiperametros 'chunk_size, earch_type="similarity" y search_kwargs={"k": 4}. El código fuente es el siguiente: “# -- coding: utf-8 -- import os
”““Partition, and chunk your file so that the logical structure of the document is preserved for better RAG results.””“ import fitz # PyMuPDF
Abre el documento PDF
archivo_pdf = "Full.pdf" doc = fitz.open(archivo_pdf)
Lista para contener ‘elements’ con texto y metadatos
elements = []
Define el tamaño del trozo de texto
chunk_size = 100 # Ajusta este valor a tus necesidades
Iterar a través de las páginas para extracción de texto
for pagina in doc: # Extraer texto de la página texto_completo = pagina.get_text()
# Dividir el texto en trozos del tamaño definido for i in range(0, len(texto_completo), chunk_size): texto_pagina = texto_completo[i:i+chunk_size] # Extraer metadatos (esto será igual para todas las páginas, así que podrías hacerlo una vez fuera del bucle) metadata = doc.metadata # Añadir texto y metadatos a ‘elements’ elements.append({"text": texto_pagina, "metadata": metadata})”““Create LangChain documents from document chunks and their metadata, and ingest those documents into the FAISS vectorstore.
Set up the retriever. ””“
from langchain_core.documents import Document from langchain.vectorstores import FAISS from langchain.embeddings import HuggingFaceEmbeddings
documents = [] for element in elements:
Si tu ‘element’ es un objeto con métodos, asegúrate de cambiar los accesos a atributos/propiedades adecuadamente
metadata = element[‘metadata’] if ‘metadata’ in element else {} documents.append(Document(page_content=element[‘text’], metadata=metadata))
db = FAISS.from_documents(documents, HuggingFaceEmbeddings(model_name=“BAAI/bge-base-en-v1.5”)) retriever = db.as_retriever(search_type=“similarity”, search_kwargs={“k”: 4})
”““To run this tutorial in the free Colab GPU, we’ll need to quantize the model:””“
import torch from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
model_name = “meta-llama/Meta-Llama-3-8B-Instruct”
bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type=“nf4”, bnb_4bit_compute_dtype=torch.bfloat16 )
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config) tokenizer = AutoTokenizer.from_pretrained(model_name)
from langchain.llms import HuggingFacePipeline from langchain.prompts import PromptTemplate from transformers import pipeline from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough
terminators = [ tokenizer.eos_token_id, tokenizer.convert_tokens_to_ids(”<|eot_id|>“) ]
text_generation_pipeline = pipeline( model=model, tokenizer=tokenizer, task=“text-generation”, temperature=0.2, do_sample=True, repetition_penalty=1.1, return_full_text=False, max_new_tokens=200, eos_token_id=terminators, )
llm = HuggingFacePipeline(pipeline=text_generation_pipeline)
prompt_template = “”” <|start_header_id|>user<|end_header_id|> You are an assistant for answering questions about IPM. You are given the extracted parts of a long document and a question. Provide a conversational answer. If you don’t know the answer, just say “I do not know.” Don’t make up an answer. Question: {question} Context: {context}<|eot_id|><|start_header_id|>assistant<|end_header_id|> “”“
prompt = PromptTemplate( input_variables=[“context”, “question”], template=prompt_template, )
llm_chain = prompt | llm | StrOutputParser() rag_chain = {“context”: retriever, “question”: RunnablePassthrough()} | llm_chain
”“”## Integrado"“”
import json import gc
Cargar el archivo JSON
with open(‘Full.json’, ‘r’) as file: data = json.load(file)
from sentence_transformers import SentenceTransformer, util
Initialize your sentence transformer model for semantic similarity calculation
model = SentenceTransformer(‘all-MiniLM-L6-v2’)
Obtener las respuestas del JSON
responses = list(data[“responses”].values()) queries = list(data[“queries”].values())
Calcular la similitud del coseno
similarity_scores = []
print(queries) for query in queries: gc.collect() answers = rag_chain.invoke(query) print(answers) gc.collect()
Encode both the given answer and the expected answer to get their embeddings
given_answer_embedding = model.encode(answers, convert_to_tensor=True) expected_answer_embedding = model.encode(responses[queries.index(query)], convert_to_tensor=True)
Calculate cosine similarity
similarity = util.cos_sim(given_answer_embedding, expected_answer_embedding) "
- Assistant
Para maximizar la similitud semántica con el framework Ray Tune y optimizar los hiperparámetros
chunk_size,search_type="similarity"ysearch_kwargs={"k": 4}, necesitaremos ajustar y extender el código para integrar la optimización de estos hiperparámetros en el proceso. A continuación, te muestro un enfoque para hacer esto:Primero, asegúrate de tener Ray y Ray Tune instalados en tu entorno:
pip install "ray[tune]"Seguidamente, vamos a modificar y encapsular partes del código original en una función que integraremos con Ray Tune para optimizar los hiperparámetros mencionados:
import os import fitz # PyMuPDF import json import gc from ray import tune from langchain_core.documents import Document from langchain.vectorstores import FAISS from langchain.embeddings import HuggingFaceEmbeddings from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline from sentence_transformers import SentenceTransformer, util from langchain.llms import HuggingFacePipeline from langchain.prompts import PromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough def optimization_function(config): # Abre el documento PDF archivo_pdf = "Full.pdf" doc = fitz.open(archivo_pdf) elements = [] chunk_size = config["chunk_size"] # Iterar a través de las páginas para extracción de texto for pagina in doc: texto_completo = pagina.get_text() # Dividir el texto en trozos del tamaño definido for i in range(0, len(texto_completo), chunk_size): texto_pagina = texto_completo[i:i+chunk_size] metadata = doc.metadata elements.append({"text": texto_pagina, "metadata": metadata}) documents = [Document(page_content=e['text'], metadata=e['metadata']) for e in elements] db = FAISS.from_documents(documents, HuggingFaceEmbeddings(model_name="BAAI/bge-base-en-v1.5")) retriever = db.as_retriever(search_type="similarity", search_kwargs={"k": config["search_k"]}) # Preparación del pipeline de generación de texto - Acá se puede ajustar modelo, tokenizer, etc. model_name = "meta-llama/Meta-Llama-3-8B-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name) text_generation_pipeline = pipeline( model=model, tokenizer=tokenizer, task="text-generation", ) llm = HuggingFacePipeline(pipeline=text_generation_pipeline) # Esta parte debe configurarse según el prompt template que estés utilizando prompt_template = "<tu plantilla aquí>" prompt = PromptTemplate( input_variables=["context", "question"], template=prompt_template, ) llm_chain = prompt | llm | StrOutputParser() rag_chain = {"context": retriever, "question": RunnablePassthrough()} | llm_chain # Simulación: carga tu archivo JSON y prepara los datos with open('Full.json', 'r') as file: data = json.load(file) model = SentenceTransformer('all-MiniLM-L6-v2') responses = list(data["responses"].values()) queries = list(data["queries"].values()) similarity_scores = [] for query in queries: gc.collect() answers = rag_chain.invoke(query) gc.collect() given_answer_embedding = model.encode(answers, convert_to_tensor=True) expected_answer_embedding = model.encode(responses[queries.index(query)], convert_to_tensor=True) similarity = util.cos_sim(given_answer_embedding, expected_answer_embedding) similarity_scores.append(similarity.item()) average_similarity = sum(similarity_scores) / len(similarity_scores) tune.report(mean_similarity=average_similarity) # Define el espacio de búsqueda search_space = { "chunk_size": tune.choice([50, 100, 200]), "search_k": tune.choice([2, 4, 6]) } # Lanza la optimización analysis = tune.run( optimization_function, config=search_space, resources_per_trial={"cpu": 1, "gpu": 1}, # Ajusta según tu entorno num_samples=10 ) print("Mejor configuración: ", analysis.best_config)Este código establece una función de optimización,
optimization_function, que utiliza los valores dechunk_sizeysearch_kproporcionados por Ray Tune para probar diferentes configuraciones y encontrar aquellas que maximizan la similitud semántica media entre las respuestas generadas y las esperadas.Nota: Este ejemplo asume que tienes el entorno adecuado y los archivos necesarios (como 'Full.pdf' y 'Full.json') listos y configurados apropiadamente, y que también has adaptado secciones específicas a tus necesidades, como el prompt template y la carga/configuración de tus modelos. Asegúrate de revisar y ajustar las rutas de archivos y configuraciones del modelo según sea necesario.