Delete app.py

app.py

@@ -1,232 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Practica9.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/github/AP2324/practica-9-anhidalg/blob/main/Practica9.ipynb
-
-# Práctica 9
-
-Ahora es tu turno de crear un sistema de question-answering.  
-
-## Ejercicio obligatorio (5 puntos)
-
-El ejercicio que tenéis que realizar obligatoriamente consiste en elegir uno o varios documentos y crear un sistema de question-answering basado en RAG como el que hemos visto en la práctica. Deberás completar los ejercicios planteados en el informe de prácticas, ten en cuenta que en los ejercicios planteados puedes tener que realizar algún cambio en el código proporcionado.
-
-## Ejercicios adicionales
-
-Debes crear un nuevo notebook para cada uno de los ejercicios que realices, completar los ejercicios planteados en el informe y guardarlo en este repositorio de GitHub.
-
-1. Crea un espacio de HuggingFace para utilizar el sistema que has construido. Deberás usar la componente [chat de Gradio](https://www.gradio.app/docs/chatbot).  (1 punto)
-2. A partir de tus documentos construye un dataset de preguntas y respuestas, y evalúa tu sistema contra dicho dataset. Para ello puedes basarte en el siguiente [tutorial](https://huggingface.co/learn/cookbook/rag_evaluation) (2 puntos).
-3. Compara distintos modelos con el dataset que has definido en el apartado anterior (1 punto).
-4. Construye un sistema de question-answering que en lugar de utilizar un documento pdf como entrada, utilice un vídeo de YouTube, para ello deberás transcribirlo primero (1 punto).
-"""
-
-
-
-"""Al finalizar, recuerda guardar los cambios en GitHub utilizando la opción Archivo -> Guardar una copia en GitHub."""
-
-
-
-from torch import cuda, bfloat16
-import torch
-import transformers
-from transformers import AutoTokenizer
-from time import time
-#import chromadb
-#from chromadb.config import Settings
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.chains import RetrievalQA
-from langchain.vectorstores import Chroma
-from langchain.document_loaders import PyPDFLoader
-import requests
-
-"""**Iniciamos el modelo y el tokenizador**
-
-Definimos el identificador del modelo
-"""
-
-model_id = 'mistralai/Mistral-7B-Instruct-v0.1'
-
-"""Indicamos que el device va a ser la GPU si está disponible"""
-
-device = f'cuda:{cuda.current_device()}' if cuda.is_available() else 'cpu'
-
-"""Fijamos la configuración para cuantizar el modelo y poder cargarlo en GPU."""
-
-bnb_config = transformers.BitsAndBytesConfig(
-    load_in_4bit=True,
-    bnb_4bit_quant_type='nf4',
-    bnb_4bit_use_double_quant=True,
-    bnb_4bit_compute_dtype=bfloat16
-)
-
-"""A continuación cargamos el modelo, para ello primero hay que cargar su configuración, y luego el modelo. Esta tarea puede llevar algo más de 2 minutos debido a que se debe descargar el modelo y luego cargarlo."""
-
-model_config = transformers.AutoConfig.from_pretrained(
-    model_id,
-    max_new_tokens=200
-)
-
-model = transformers.AutoModelForCausalLM.from_pretrained(
-    model_id,
-    trust_remote_code=True,
-    config=model_config,
-    quantization_config=bnb_config,
-    device_map='auto',
-)
-
-"""Cargamos a continuación el tokenizer que se utilizará para procesar los textos."""
-
-tokenizer = AutoTokenizer.from_pretrained(model_id)
-
-"""Ya tenemos todas las componentes para definir un pipeline que responda preguntas usando el modelo que acabamos de cargar, para ello definimos un pipeline y a continuación definimos una función que nos permite utilizar dicho pipeline."""
-
-query_pipeline = transformers.pipeline(
-        "text-generation",
-        model=model,
-        tokenizer=tokenizer,
-        torch_dtype=torch.float16,
-        device_map="auto", max_new_tokens=200)
-
-"""Para usar el pipeline como estamos usando un modelo estilo chat, vamos a utilizar las chat templates de HuggingFace. Notar que cuando llamamos a la pipeline estamos fijando distintos parámetros que son:
-
-1. temperature: valor usado para modular las probabilidades de los siguientes
-tokens.
-2. do_sample: booleano que indica si realiza sampling sobre el siguiente token a generar o si se usa una estrategia avariciosa.
-3. top_k: el número de tokens del vocabulario con probabilidad más alta que se mantienen para hacer top-k-filtering.
-4. top_p: real tal que el menor conjunto de los tokens más probables cuyas probabilidades suman hasta el valor top_p se mantienen para la generación.
-"""
-
-def test_model(tokenizer, pipeline, prompt_to_test):
-    """
-    Perform a query
-    print the result
-    Args:
-        tokenizer: the tokenizer
-        pipeline: the pipeline
-        prompt_to_test: the prompt
-    Returns
-        None
-    """
-    # adapted from https://huggingface.co/blog/llama2#using-transformers
-    time_1 = time()
-    # Usamos la chat template.
-    messages = [{"role": "user", "content": prompt_to_test}]
-    prompt = pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-
-    sequences = pipeline(
-        prompt,
-        do_sample=True,
-        temperature=0.7, top_k=50, top_p=0.95,
-        num_return_sequences=1,
-        eos_token_id=tokenizer.eos_token_id)
-    time_2 = time()
-    print(f"Test inference: {round(time_2-time_1, 3)} sec.")
-    for seq in sequences:
-        res = seq['generated_text']
-        print(f"Result: {res[res.rfind('[/INST]')+8:]}")
-
-"""Ahora podemos utilizar esta pipeline para hacer preguntas sobre diabetes, pero en general sobre cualquier tema."""
-
-test_model(tokenizer,
-           query_pipeline,
-           "Por favor, indícame cuál es el teorema del cálculo ")
-
-test_model(tokenizer,
-           query_pipeline,
-           "Dame la regla de Barrow")
-
-"""**RAG**
-
-En este caso para generar nuestras respuestas vamos a utilizar una guía sobre derivadas e integrales. Descargamos a continuación dicha guía
-"""
-
-URL = "http://www.ugr.es/~rpaya/documentos/CalculoII/2011-12/TFC.pdf"
-response = requests.get(URL)
-open("TFC.pdf", "wb").write(response.content)
-
-loader = PyPDFLoader("TFC.pdf")
-documents = loader.load()
-
-"""A continuación vamos a partir el documento en trozos (chunks) usando una partición basada en caracteres recursiva."""
-
-text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=20)
-all_splits = text_splitter.split_documents(documents)
-
-"""**Creando los embeddings y almacenándolos**
-
-El siguiente paso es crear los embeddings usando la librería Sentence Transformer y los embeddings de HuggingFace. Esta librería dispone una gran variedad de modelos de embedding, al estar trabajando con un documento en castellano vamos a utilizar un modelo multilingue.
-"""
-
-model_name = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
-model_kwargs = {"device": "cuda"}
-
-embeddings = HuggingFaceEmbeddings(model_name=model_name, model_kwargs=model_kwargs)
-
-"""El siguiente paso consiste en inicializar la base de datos con los documentos partidos, y usando los embeddings definidos previamente. Elegimos también persistir la información localmente en un directorio llamado chroma_db."""
-
-vectordb = Chroma.from_documents(documents=all_splits, embedding=embeddings, persist_directory="chroma_db")
-
-"""**Retrieval-Augmented Generation**
-
-Ya tenemos todas las componentes para definir una función que ante una query busque los trozos de documentos más similares a la misma y genere una respuesta en base a ellos. Para ello el proceso que seguimos es el siguiente:
-
-1. Buscamos aquellos trozos de los documentos que son más similares a nuestra query.
-2. Para cada uno de los trozos encontrados extraemos el contenido de los mismos y su similitud con la query.
-3. Si hay documentos lo suficientemente cercanos, llamamos al modelo para generar una respuesta en base a ello, en caso contrario generamos una respuesta por defecto.
-"""
-
-import gradio as gr
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer, AutoConfig
-
-
-# Definir la función interna para testear RAG
-def _test_rag(query, query_pipeline):
-    docs = vectordb.similarity_search_with_score(query)
-    context = []
-    for doc, score in docs:
-        if score < 7:
-            doc_details = doc.to_json()['kwargs']
-            context.append(doc_details['page_content'])
-    if len(context) != 0:
-        messages = [{"role": "user", "content": "Basándote en la siguiente información:\n" + "\n".join(context) + "\nPor favor, hazme una pregunta en español:"}]
-        prompt = query_pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        outputs = query_pipeline(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
-        answer = outputs[0]["generated_text"]
-        return answer[answer.rfind("[/INST]") + 8:], docs
-    else:
-        return "No tengo información para responder a esta pregunta", docs
-
-# Definir la función externa para usar con Gradio
-def test_rag(query):
-    return _test_rag(query, query_pipeline)
-
-# Crear la interfaz de Gradio
-iface = gr.Interface(fn=test_rag,
-                     inputs="text",
-                     outputs="text",
-                     title="Sistema RAG de Hugging Face",
-                     description="Este modelo utiliza RAG de Hugging Face para responder preguntas basadas en contexto.")
-
-# Lanzar la interfaz de Gradio
-if __name__ == "__main__":
-    iface.launch()
-
-"""A continuación mostramos unos cuantos ejemplos de su uso."""
-
-query = "¿Qué es Regla de Barrow?"
-answer,docs=test_rag(query_pipeline, query)
-answer
-
-query = "¿Qué ES EL CAMBIO DE VARIABLE?"
-answer,docs=test_rag(query_pipeline, query)
-answer
-
-query = "Cual es la INTEGRACIÓN POR PARTES?"
-answer,docs=test_rag(query_pipeline, query)
-answer
-