Add src

src/app.py

@@ -0,0 +1,59 @@
+"""
+Este script realiza las siguientes tareas:
+1. Carga archivos desde un directorio especificado utilizando la clase `Loader` del módulo `preprocess`.
+2. Procesa los archivos mediante limpieza de texto y división en fragmentos.
+3. Genera representaciones vectoriales de los textos utilizando `sentence-transformers`.
+4. Almacena los vectores en una base de datos Chroma para su posterior recuperación.
+5. Inicializa un modelo y ejecuta una interfaz para interactuar con los datos procesados.
+
+Módulos utilizados:
+- `preprocess`: Contiene la clase `Loader` para la carga y preprocesamiento de documentos.
+- `vdb`: Se asume que gestiona la base de datos vectorial.
+- `model_load`: Módulo para cargar el modelo de machine learning.
+- `st`: Se asume que proporciona la interfaz de usuario.
+
+Estructura del código:
+1. Define el directorio de los archivos a procesar.
+2. Carga los archivos y los procesa si el número de archivos es menor a 2.
+3. Si hay múltiples archivos, los procesa en un bucle y concatena los fragmentos.
+4. Genera embeddings utilizando `sentence-transformers/all-MiniLM-L12-v2`.
+5. Almacena los embeddings en ChromaDB y configura un recuperador basado en similitud.
+6. Carga el modelo de machine learning.
+7. Inicia la interfaz de usuario.
+
+"""
+
+from preprocess import Loader
+import vdb
+import model_load
+import st
+
+if __name__=="__main__":
+    # Definición de directorio
+    archivo = r"directorio"
+    
+    # Carga de archivos y procesamiento de texto
+    if len(archivo) < 2:
+        Load = Loader(archivo)
+        documentos = Load.load_docs()
+        textos_limpios = [Load.limpiar_texto(doc) for doc in documentos.page_content]
+        textos = Load.splitter(texto=textos_limpios, chunk_size=500, chunk_overlap=50)
+    else:
+        textos = []
+        for i in range(len(archivo)):
+            Load = Loader(archivo)
+            documentos = Load.load_docs()
+            textos_limpios = [Load.limpiar_texto(doc) for doc in documentos.page_content]
+            chunks = Load.splitter(texto=textos_limpios, chunk_size=500, chunk_overlap=50)
+            textos.extend(chunks)
+    
+    # Generación de embeddings y almacenamiento en base de datos ChromaDB
+    embeddings = EmbeddingGen("sentence-transformers/all-MiniLM-L12-v2")
+    db = Chroma("QAMath", embedding_function=embeddings)
+    vectorstore = db.from_documents(chunks, embeddings)
+    retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 3})
+    
+    # Carga del modelo y ejecución de la interfaz
+    load_model()
+    interfaz()
+

src/model_load.py

@@ -0,0 +1,61 @@
+from langchain.chains import RetrievalQAWithSourcesChain
+from langchain.llms import HuggingFacePipeline
+from transformers import AutoTokenizer, pipeline, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+from langchain.prompts import PromptTemplate
+from langchain.llms import HuggingFaceHub
+from langchain.chains import LLMChain
+
+def load_model():
+    model_name="tiiuae/Falcon3-10B-Instruct"
+
+    # Cargar tokenizer y modelo de Hugging Face
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForCausalLM.from_pretrained(model_name,
+                                                 torch_dtype=torch.float16,
+                                                 device_map="auto",
+                                                 quantization_config=BitsAndBytesConfig(load_in_8bit=True))
+    
+    # Crear pipeline de generación de texto
+    text_generation_pipeline = pipeline(
+    "text-generation",
+    model=model,
+    tokenizer=tokenizer,
+    max_new_tokens=128,
+    repetition_penalty=1.2,
+    device_map="auto"
+    )
+    # Crear el LLM compatible con LangChain
+    llm = HuggingFacePipeline(pipeline=text_generation_pipeline)
+
+    # Crear la plantilla de prompt que tomará el texto y la pregunta
+    prompt_template = """
+    Dado el siguiente texto extraído de varios documentos y una pregunta, crea una respuesta utilizando la información proporcionada. Si la pregunta sale por fuera de la información proporcionada responde con "No tengo información al respecto" y corta la respuesta.
+
+    **Documentos relevantes:**
+    {documento}
+
+    **Pregunta:**
+    {pregunta}
+
+    **Respuesta:**
+    """
+
+    # Crear el prompt con las variables necesarias
+    prompt = PromptTemplate(input_variables=["documento", "pregunta"], template=prompt_template)
+
+    # Crear una cadena de LLMChain que combine el retriever y el prompt
+    qa_chain = LLMChain(llm=llm, prompt=prompt)
+
+def ask(pregunta: str,retriever):
+
+    #Busqueda de documentos mediante el retriever
+    documentos=retriever.get_relevant_documents(pregunta)
+
+    #Generacion de la respuesta
+    respuesta = qa_chain.invoke({
+    "documentos": "\n".join([doc.page_content for doc in docs_relevantes]),
+    "pregunta": pregunta
+    })
+
+    return respuesta["text"].split("**Respuesta:**\n")[1]

src/preprocess.py

@@ -0,0 +1,76 @@
+from langchain_community.document_loaders import PyMuPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import re
+
+class Loader:
+    """Clase encargada de la carga desde PDFs, 
+    admite PDFs con texto seleccionable unicamente. Realiza
+    carga y devuelve lista de chunks de texto.
+    """
+    def __init__(self, path: str):
+        self.path = path
+
+    def load_docs(self,pag:slice=None):
+        """Carga el PDF y devuelve lista de chunks de texto.
+        """
+        loader=PyMuPDFLoader(self.path)
+        docs=loader.load()
+        if pag:
+            docs=docs[pag]
+        return [doc.page_content for doc in docs]
+    @staticmethod
+
+    def limpiar_texto(self,texto: str) -> str:
+        """
+        Limpia el texto eliminando caracteres basura y normalizando espacios y saltos de línea.
+        Esta función está diseñada para preprocesar libros u otros documentos largos,
+        facilitando su uso en aplicaciones de Retrieval Augmented Generation (RAG).
+
+        Args:
+            texto (str): El texto original a limpiar.
+
+        Returns:
+            str: El texto limpio.
+        """
+        # 1. Eliminar saltos de línea, tabulaciones y otros caracteres de control
+        texto = re.sub(r'[\r\n\t]+', ' ', texto)
+        
+        # 2. Eliminar caracteres no imprimibles (códigos de control)
+        texto = re.sub(r'[\x00-\x1F\x7F]', '', texto)
+        
+        # 3. Sustituir múltiples espacios por uno solo
+        texto = re.sub(r'\s+', ' ', texto)
+        
+        # 4. Eliminar caracteres que no sean letras, dígitos o signos de puntuación comunes
+        # Se conservan letras con acentos y caracteres propios del español.
+        texto = re.sub(r'[^\w\s.,;:¡!¿?\-áéíóúÁÉÍÓÚñÑ]', '', texto)
+        
+        # 5. Eliminar espacios al inicio y al final
+        texto = texto.strip()
+        
+        return texto
+    
+    @staticmethod
+
+    def splitter(self,texto,chunk_size,chunk_overlap):
+        """
+        Divide el texto en chunks
+
+        Args:
+            chunk_size (int): Largo del chunk.
+            chunk_overlap (int): Sobreposicion de chunks
+            texto (list): lista de textos a procesar
+
+        Returns:
+            list: Los textos limpios.
+        """
+        splitter=RecursiveCharacterTextSplitter(
+                chunk_size=chunk_size,
+                chunk_overlap=chunk_overlap,
+                length_function=len,
+                separators=["\n\n","\n"," ",""]
+            )
+        chunks=splitter.create_documents(texto)
+
+        return chunks
+

src/st.py

@@ -0,0 +1,105 @@
+import streamlit as st
+
+def interfaz():
+
+    # Configuración de la página
+    st.set_page_config(
+        page_title="MathQA - Asistente de Matemáticas",
+        page_icon="🧮",
+        layout="centered",
+        initial_sidebar_state="expanded"
+    )
+
+    # Paleta de colores neutra
+    primary_color = "#010001"
+    secondary_color = "#E7E6E7"
+    background_color = "#FBFBFA"
+
+    # Estilos CSS
+    st.markdown(
+        f"""
+        <style>
+        .stApp {{ background-color: {background_color}; }}
+        .stTextInput>div>div>input {{
+            color: {primary_color};
+            background-color: {secondary_color};
+            border-radius: 8px;
+        }}
+        .stButton>button {{
+            color: {primary_color};
+            background-color: {secondary_color};
+            border-radius: 8px;
+            transition: all 0.3s;
+        }}
+        .history-box {{
+            border-left: 4px solid {secondary_color};
+            padding: 1rem;
+            margin: 1rem 0;
+            background-color: {secondary_color
+            };
+            border-radius: 8px;
+        }}
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+    # Inicializar historial
+    if 'history' not in st.session_state:
+        st.session_state.history = []
+
+    # Variable auxiliar para gestionar el input
+    if 'temp_input' not in st.session_state:
+        st.session_state.temp_input = ""
+
+    # Título de la aplicación
+    st.title("🧮 MathQA - Asistente de Matemáticas")
+    st.markdown("")
+
+    # Widget de entrada con variable auxiliar
+    user_input = st.text_input(
+        "Escribe tu pregunta matemática aquí:",
+        value=st.session_state.temp_input,
+        key="user_input",
+        placeholder="Ej: ¿Que es una integral?"
+    )
+
+    # Botón de acción
+    col1, col2, col3 = st.columns([5, 4, 4])  # Columnas vacías a los lados para centrar
+    with col2:
+        if st.button("Resolver pregunta"):
+            if user_input:  # Accedemos al valor ingresado
+                # Simular respuesta
+                mock_answer = ask(user_input,retriever)
+                
+                # Agregar al historial
+                st.session_state.history.insert(0, (user_input, mock_answer))
+                
+                # Limpiar la variable auxiliar
+                st.session_state.temp_input = ""
+                
+                # Forzar actualización
+                st.rerun()
+
+    # Mostrar historial
+    if st.session_state.history:
+        st.markdown("---")
+        st.subheader("Historial de Consultas")
+        
+        for idx, (pregunta, respuesta) in enumerate(st.session_state.history):
+            with st.container():
+                st.markdown(
+                    f"""
+                    <div class="history-box">
+                        <strong>Pregunta {len(st.session_state.history)-idx}:</strong>
+                        <p>{pregunta}</p>
+                        <strong>Respuesta:</strong>
+                        <p>{respuesta}</p>
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+    # Pie de página
+    st.markdown("---")
+    st.markdown("🔍 ¿Necesitas ayuda con álgebra, cálculo o geometría? ¡Estoy aquí para ayudarte!")

src/vdb.py

@@ -0,0 +1,16 @@
+from sentence_transformers import SentenceTransformer
+from langchain.schema import Document
+
+
+
+class EmbeddingGen:
+
+    def __init__(self, model_name: str):
+        self.model = SentenceTransformer(model_name)
+    
+    def embed_documents(self, chunks):
+        return [self.model.encode(chunk) for chunk in chunks]
+    
+    def embed_query(self, text):
+        return self.model.encode(text)
+