Sistema RAG y TxtAi Parte 1: Transformando la Generación de Lenguaje con Inteligencia

AI Inteligencia Artificial

Para esta primera parte de nuestra serie de artículos, vamos a basar nuestra exploración en este tutorial para implementar un proceso RAG. Pero, ¿qué es un RAG? RAG, o "Generación Aumentada por Recuperación" (por sus siglas en inglés, "Retrieval-Augmented Generation"), es una técnica avanzada en inteligencia artificial, específicamente en el campo del procesamiento de lenguaje natural (NLP), que implica enriquecer el proceso de generación de texto incorporando una fase de recuperación de información. Este método híbrido combina el poder de los modelos de lenguaje basados en el aprendizaje profundo con la eficiencia de los sistemas de recuperación de información para producir respuestas más precisas y contextualmente relevantes.

A través de este artículo, exploraremos cómo los RAGs transforman el enfoque tradicional de la generación de lenguaje integrando elementos dinámicos de búsqueda de información. Examinaremos los componentes clave de esta tecnología, incluyendo cómo el modelo identifica y extrae información relevante de una vasta base de datos o corpus de texto antes de iniciar el proceso de generación de respuesta. Esto permite que el modelo se apoye no solo en su aprendizaje interno, sino también en datos externos específicos, lo cual es particularmente beneficioso para preguntas que requieren conocimientos actualizados o especializados.

Además, discutiremos los retos y oportunidades asociados con la implementación de RAGs, destacando su potencial en diversos campos de aplicación, desde la asistencia virtual hasta los sistemas de recomendación personalizados. Finalmente, ilustraremos cómo configurar un sistema RAG utilizando tecnologías y herramientas de vanguardia, proporcionando una guía paso a paso basada en el tutorial de la documentación oficial de la herramienta Txtai. Ya seas un desarrollador experimentado en PHP y ciencia de datos o simplemente tengas curiosidad por descubrir los últimos avances en IA, este artículo tiene como objetivo proporcionar una comprensión profunda de la tecnología RAG y su impacto en el futuro del procesamiento de lenguaje natural.

Componentes Clave de un Sistema RAG

Los RAGs, por su naturaleza híbrida, integran dos componentes esenciales: el sistema de recuperación de información (Information Retrieval, IR) y el modelo de generación de lenguaje (Language Generation Model).

Sistema de Recuperación de Información: La primera etapa de un RAG es buscar y recuperar información relevante en respuesta a una consulta. Esta fase utiliza técnicas de búsqueda avanzadas para escanear rápidamente grandes conjuntos de datos, seleccionando extractos de texto que tienen más probabilidades de ser relevantes para la pregunta planteada.

Modelo de Generación de Lenguaje: Una vez que se recupera la información relevante, se alimenta en un modelo de generación de lenguaje. Este modelo, a menudo basado en arquitecturas de redes neuronales como Transformers, utiliza esta información para construir una respuesta coherente y contextualmente apropiada.

Retos y Oportunidades

Los RAGs plantean varios retos técnicos y prácticos. Por ejemplo, la precisión en la recuperación de información es crítica; una recuperación inexacta puede conducir a respuestas erróneas. Además, equilibrar la velocidad de procesamiento y la precisión es una consideración importante, especialmente para aplicaciones en tiempo real.

Sin embargo, las oportunidades presentadas por los RAGs son considerables. En el soporte al cliente, por ejemplo, los RAGs pueden ofrecer respuestas más precisas y personalizadas que los sistemas tradicionales de generación de lenguaje. En la investigación científica, pueden ayudar en la formulación de respuestas basadas en las últimas publicaciones y descubrimientos.

Implementación Práctica de un RAG

Varios pasos son necesarios para implementar un RAG:

Selección de Tecnología: Modelos transformadores como BERT o GPT se pueden utilizar para el modelo de generación, mientras que sistemas como Elasticsearch se pueden emplear para la recuperación de información. Aquí, usaremos MistralAI y el sistema interno de txtai. Luego veremos cómo integrar los índices directamente en una base de datos de PostgreSQL.

Preparación de Datos: Preparar un corpus de datos grande y diverso para la fase de recuperación. Este corpus debe ser representativo de los tipos de consultas esperadas. Para hacer esto, recuperaremos las páginas de contenido de este mismo blog.

Entrenamiento y Ajuste fino:

Entrena tu modelo de generación de lenguaje utilizando tanto el corpus de datos como la información recuperada. Puede ser necesario un ajuste fino para adaptar el modelo a casos de uso específicos.

Integración y Pruebas: Integra el sistema RAG en tu aplicación o servicio y realiza pruebas exhaustivas para evaluar su rendimiento y exactitud.

Conclusión

La "Generación Aumentada por Recuperación" es un avance emocionante en IA, abriendo nuevas vías para aplicaciones de procesamiento de lenguaje natural más sofisticadas y precisas. Aunque presenta desafíos, su potencial en varios dominios lo hace invaluable para empresas y desarrolladores que buscan aprovechar las últimas innovaciones en IA. Siguiendo los pasos y principios descritos en este artículo, los desarrolladores de PHP y expertos en ciencia de datos pueden comenzar a explorar el fascinante mundo de los RAGs para mejorar las capacidades de procesamiento de lenguaje natural de sus aplicaciones.

Nota del autor: No nos engañemos. El comienzo de este artículo fue escrito con la ayuda de inteligencia artificial. Debe admitirse que hizo un buen trabajo. Parece claro que una inteligencia artificial fue entrenada con sus propios conceptos. Esto hizo que el ejercicio de escritura fuera muy lúdico. Mi rol fue simplemente "mostrar" el camino interactivamente para obtener la información más clara posible. Ahora que hemos tenido un pequeño interludio teórico, podemos avanzar más fácilmente a la parte práctica.

En primer lugar, la tecnología elegida para este primer artículo es TxtAi. ¿Por qué? Bueno, porque está hecho para eso. Y una vez que entiendes cómo funciona, te das cuenta de que representa un ahorro de tiempo significativo. Considerando que habrá datos que preparar, una infraestructura que configurar y otros aspectos técnicos, si podemos ahorrar tiempo en desarrollo, siempre será tiempo ganado para el cliente final. Verás que todo no se hace con solo tres clics. Necesitas datos, y eso es finalmente donde va a llevar más tiempo.

Pasemos al código. Suponemos que ya has completado la etapa de instalación de Llama.cpp. Tienes una cuenta en Huggingface con un token y tu entorno Python ya está funcional. Comenzamos instalando nuestras pequeñas dependencias:

pipenv shell
pipenv install txtai[pipeline] autoawq install nltk['punkt']
pipenv install  install git+https://github.com/abetlen/llama-cpp-python.git
pip install hf-transfer

Necesitaremos un modelo, y hemos elegido TheBloke/Mistral-7B-OpenOrca-GGUF. Verás que el Llm de MistralAi es muy impresionante cuando se trata de escribir contenido. Dependiendo de tu hardware, usa una versión más ligera del modelo: https://huggingface.co/TheBloke/Mistral-7B-OpenOrca-GGUF/tree/main

huggingface-cli download TheBloke/Mistral-7B-OpenOrca-GGUF mistral-7b-openorca.Q8_0.gguf --local-dir /Data/Projets/Llm/Models/MistralAi-OpenOrqa/mistral-7b-openorca.Q8_0.gguf --cache-dir /Data/Projets/Llm/Models/huggingface_cache/

export HF_HUB_ENABLE_HF_TRANSFER=1 &&  huggingface-cli download TheBloke/Mistral-7B-OpenOrca-GGUF mistral-7b-openorca.Q2_K.gguf --local-dir /Data/Projets/Llm/Models/MistralAi-OpenOrqa/mistral-7b-openorca.Q2_K.gguf --cache-dir /Data/Projets/Llm/Models/huggingface_cache/

La ventaja de este repositorio es que el archivo en formato gguf ya está preparado para nosotros, por lo que podemos usarlo directamente con llama.cpp y TxtAi. Por lo tanto, no se necesita una GPU. Una vez más, la idea es demostrar cómo funciona y contemplar el uso de equipos destinados para este propósito.

Necesitaremos material para realizar nuestras extracciones de datos. Gracias a neuml por proporcionarnos archivos de muestra. Descargue documentos desde esta dirección, o use uno de los suyos adaptando el siguiente código.

from llama_cpp import Llama
from txtai.pipeline import Textractor
import nltk
# Création de notre connection à Llama.cpp avec ces parrametres par defauts.
llm = Llama(
    model_path="/Data/Projets/Llm/Models/MistralAi-OpenOrqa/mistral-7b-openorca.Q8_0.gguf/mistral-7b-openorca.Q8_0.gguf", n_ctx=2048)
# On récupere le texte de notre fichier docx.
textractor = Textractor()
text = textractor("datas/tuto1/document.docx")


# execution de notre appel au modèle.
def execute(question, context):
    # on crée un prompt de démarrage
    prompt = f"""<|im_start|>system You are a friendly assistant. You answer questions from users.<|im_end|> 
    <|im_start|>user Answer the following question using only the context below. Only include information 
    specifically discussed or general AI and LLMs related subject. 
  question: {question}
  context: {context} <|im_end|>
  <|im_start|>assistant
  """

    tokens = nltk.word_tokenize(text)
    print(len(tokens))
    return llm(prompt,
               temperature=0.1,
               max_tokens=10000,
               top_p=0.2,
               top_k=10,
               repeat_penalty=1.2)

# on lance notre methode avec une question mais aussi un contexte tiré de notre fichier docx.
result = execute("Write a long article about TxtAi explaining how it works. You can show code example. Explain how it could solve problem in small and larger company. Make the accurate answer you can do. Make an intro and a conclusion. This could be a general speech in a conference or a learning lesson at Partitech University. Make your answer in french", text)
print(result['choices'][0]['text'])
print(result['choices'][0]['text'])
print(result['usage'])

Aquí está el resultado.

 Titre : TxtAi, la base de données d'embeddings pour les recherches sémantiques et l'orchestration des LLMs (Langage de Modèle Linguistique)

Dans cet article, nous allons expliquer comment TxtAi fonctionne en tant que base de données d'embeddings complète pour la recherche sémantique, l'orchestration des Langages de Modèles Linguistiques (LLMs) et les workflows linguistiques. Nous allons également présenter un exemple de code et montrer comment TxtAi peut résoudre des problèmes dans des entreprises de taille différente, que ce soit une petite ou grande entreprise.

TxtAi est une base de données d'embeddings conçue pour faciliter la recherche sémantique et l'orchestration des LLMs. Elle offre plusieurs fonctionnalités importantes, telles que :
1. Recherche vectorielle avec SQL, stockage objet, modélisation du sujet ;
2. Créer des embeddings pour le texte, les documents, la audio et l'image;
3. Pipelines alimentés par des LLMs qui exécutent des prompts de LLM;
4. Workflows permettant de joindre plusieurs pipelines ensemble et d'aggreguer des logiques métier ;
5. Construire avec Python ou YAML, avec des bindings API disponibles pour JavaScript, Java, Rust et Go.

Pour illustrer comment TxtAi fonctionne, voici un exemple de code en Python :


***python
from txtai import TextSearch, DocumentEmbeddings, ImageEmbeddings, Pipeline, Workflow

# Création d'un pipeline avec une LLM
llm_pipeline = Pipeline(model="gpt-3")

# Créer des embeddings pour le texte et l'image
text_embeddings = DocumentEmbeddings("documents.txt", model="all-MiniLM-L6-v2")
image_embeddings = ImageEmbeddings("images/*.jpg", model="BLIP")

# Créer une recherche vectorielle avec SQL et stockage objet
text_search = TextSearch(sql_query="SELECT * FROM documents WHERE similarity > 0.8", storage="object-store")

# Construire un workflow pour joindre les pipelines ensemble
workflow = Workflow([llm_pipeline, text_search, text_embeddings, image_embeddings])

# Exécutez le workflow et affichez les résultats
results = workflow.run()
print(results)
*** 
Ce code montre comment créer un pipeline avec une LLM, générer des embeddings pour du texte et des images, puis construire un workflow qui utilise ces pipelines pour effectuer une recherche vectorielle sur la base de données.

En ce qui concerne l'impact dans les entreprises, TxtAi peut aider à résoudre divers problèmes en améliorant la recherche sémantique et en facilitant le travail des LLMs. Pour une petite entreprise, cela signifie que les employés peuvent accélérer leurs processus de recherche grâce à l'utilisation d'embeddings pour indexer rapidement leur contenu. Dans un contexte plus grand, TxtAi peut aider à améliorer la performance des systèmes de recommandation et à simplifier le développement de workflows linguistiques complexes.

En conclusion, TxtAi est une base d'embeddings complète qui facilite la recherche sémantique et l'orchestration des LLMs pour les entreprises de toutes tailles. Grâce à ses fonctionnalités avancées en matière de vectorisation, de modélisation du sujet et de workflows linguistiques, TxtAi peut améliorer considérablement la productivité et l'efficacité des organisations dans divers domaines.

Nota: la salida está directamente en formato Markdown. Cambié el marcador de código, de lo contrario no sería muy legible.

Pasemos a explicaciones adicionales sobre los parámetros utilizados en nuestra llamada:

Primero, el prompt. ¿Cómo definimos el prompt que enviamos al modelo? No hay magia aquí. Necesitarás ir directamente a la documentación del modelo. Aquí, en HuggingFace: https://huggingface.co/TheBloke/Mistral-7B-OpenOrca-GGUF

Como puedes ver, el prompt esperado es claro: requiere zonas <|im_start|>system <|im_start|>user y una zona <|im_start|> que deja espacio para que el modelo te responda. El truco aquí es definir un contexto en el prompt. Es importante entender que el espacio dado al prompt debe estar predefinido.

n_ctx=2048 = El número de tokens asignados al contexto. Se especifica en la doc en huggingface. ¿Cómo definir el número de tokens? El cálculo del número de tokens depende del método de tokenización utilizado. La tokenización es el proceso de dividir un texto en tokens. Aquí hay algunos pasos generales para calcular el número de tokens:

import nltk
nltk.download('punkt')  # Assurez-vous d'avoir le package 'punkt' téléchargé pour la tokenisation
text = "Votre texte ici."
tokens = nltk.word_tokenize(text)
number_of_tokens = len(tokens)

En nuestro ejemplo, el número de tokens de nuestro mensaje calculado es 264. El número de tokens devueltos en la respuesta es 3182. En realidad, el modelo nos devuelve la siguiente información:

{'prompt_tokens': 552, 'completion_tokens': 938, 'total_tokens': 1490}

Es por lo tanto un poco más complicado predecir el número de tokens por adelantado.

temperature=0.1

La temperatura controla el grado de aleatoriedad en la elección de palabras o frases. Afecta a las probabilidades asociadas con cada posible elección durante la generación de texto.

  • A una temperatura baja (cercana a 0), el modelo tiende a elegir las palabras más probables, lo que lleva a textos más predecibles y coherentes. Sin embargo, esto también puede hacer que los textos generados sean menos variados y a veces repetitivos.
  • A una temperatura alta, el modelo asume mayores riesgos eligiendo palabras menos probables. Esto puede llevar a textos más creativos, originales o sorprendentes, pero también a veces menos coherentes o relevantes. En un modelo de generación de texto, la temperatura actúa como un regulador entre la coherencia y la creatividad. Un ajuste cuidadoso de la temperatura puede influir enormemente en la calidad y el estilo del texto generado.

max_tokens=10000

El parámetro max_tokens se utiliza en modelos de procesamiento de lenguaje natural (PLN), como MistralAI y otros modelos basados en redes neuronales. Juega un papel crucial en la definición de la longitud del resultado generado por el modelo. Aquí hay algunos detalles clave:

  • max_tokens especifica el número máximo de tokens (palabras, puntuación, símbolos, etc.) que el modelo puede generar o procesar en un solo momento. Un "token" es la unidad más pequeña de procesamiento en PLN.
  • Al generar texto, max_tokens limita la longitud del texto producido. Si el modelo alcanza este límite durante la generación, deja de producir más texto.
  • En tareas de comprensión o análisis de texto, este parámetro puede limitar la cantidad de texto analizado a la vez.
  • Limitar el número de tokens es importante para gestionar el uso de recursos informáticos. Cuanto mayor es el valor de max_tokens, más memoria y potencia de cómputo se requieren para generar o procesar el texto. Esto es particularmente relevante en modelos de PLN grandes, que pueden consumir muchos recursos.
  • Para Generaciones Cortas: Un valor bajo de max_tokens puede utilizarse para respuestas cortas, como en chatbots o sistemas de respuesta a preguntas.
  • Para Textos Más Largos: Se necesita un valor más alto para tareas como generar artículos, narrativas u otras formas de contenido más largo. La elección del valor adecuado para max_tokens depende de la aplicación específica y de las capacidades del sistema en el que se ejecuta el modelo.

A menudo es necesario encontrar un equilibrio entre la calidad y longitud del texto generado, y las restricciones de rendimiento. En resumen, max_tokens es un parámetro esencial que ayuda a controlar la longitud del texto generado por un modelo de PLN mientras gestiona los recursos informáticos necesarios. Su ajuste adecuado es crucial para obtener resultados óptimos de acuerdo a las necesidades específicas de la aplicación.

top_p=0.2

El parámetro top_p, también conocido como "muestreo del núcleo", es una configuración crucial en modelos de generación de texto como MistralAI. Se utiliza para controlar la diversidad y creatividad de los textos generados. Aquí hay una explicación detallada: Cuando el modelo está generando texto, asigna una probabilidad a cada palabra potencial como la siguiente palabra. top_p funciona para filtrar estas palabras basándose en sus probabilidades acumulativas. Prácticamente, esto significa que el modelo solo considera un subconjunto de posibles palabras cuyas probabilidades acumulativas alcanzan el umbral del top_p. Control de la Diversidad del Texto:

  • Con un top_p bajo, el modelo se restringe a un número menor de opciones altamente probables, lo que lleva a textos más predecibles y menos diversificados.
  • Con un top_p alto, el modelo considera un mayor número de opciones posibles, aumentando así la diversidad y creatividad del texto generado, pero a expensas de la coherencia.
  • A diferencia de la temperatura, que ajusta las probabilidades de todas las opciones posibles, top_p simplemente limita el grupo de palabras consideradas para la generación basándose en sus probabilidades acumulativas.

top_p ofrece una alternativa al muestreo basado en el parámetro top_k, donde solo se consideran las k palabras más probables, independientemente de sus probabilidades absolutas.

  • Para un texto más estándar: Usa un top_p más bajo si deseas textos que sean más coherentes y alineados con los datos de entrenamiento.
  • Para un texto más creativo: Un top_p más alto es adecuado para tareas que requieren creatividad u originalidad, como la escritura creativa o la generación de conceptos únicos.

El valor de top_p es típicamente un número real entre 0 y 1. La elección del valor adecuado para top_p depende del tipo de texto que quieres generar y del equilibrio deseado entre creatividad y coherencia. En resumen, top_p es un parámetro importante para controlar la diversidad y creatividad en la generación de texto. Ajustarlo permite encontrar el balance correcto entre la producción de textos originales y el mantenimiento de cierta consistencia con el estilo y contenido de los datos de entrenamiento.

top_k=10

El parámetro top_k es otro ajuste significativo. Juega un papel vital en la determinación de las elecciones de palabras del modelo durante la generación de texto.En la generación de texto, el modelo evalúa la probabilidad de muchas palabras potenciales como la próxima palabra. top_k restringe esta selección a las k palabras más probables.

Por ejemplo, si top_k está configurado en 10, el modelo solo considerará las 10 palabras más probables para continuar la oración en cada paso de generación.

  • Un top_k bajo (como 5 o 10) hace que el texto generado sea más predecible y coherente, ya que se limita a las opciones más probables.
  • Un top_k alto aumenta la diversidad de las palabras generadas, ya que permite al modelo elegir entre una gama más amplia de posibilidades, lo que puede llevar a textos más creativos o sorprendentes.
  • A diferencia de top_p, que selecciona palabras basadas en un umbral de probabilidad acumulativa, top_k se enfoca únicamente en el número fijo de opciones más probables.
  • top_k se usa a menudo junto con la temperatura para refinar aún más la salida generada.
  • Para textos más estandarizados: un top_k más bajo se usa a menudo para tareas que requieren consistencia y precisión, como responder preguntas.
  • Para textos más innovadores: un top_k más alto puede usarse para estimular la creatividad, útil en escritura creativa o generación de ideas.
  • El valor de top_k es generalmente un entero. La elección de este valor depende del equilibrio deseado entre la creatividad y la consistencia en el texto generado.

En resumen, top_k es un parámetro que influye directamente en la variedad y originalidad del texto generado por un modelo de PNL. Debe ajustarse de acuerdo con los objetivos específicos de la tarea de generación de texto, teniendo en cuenta el equilibrio entre la diversidad del contenido y la fidelidad al estilo y la estructura de los datos de entrenamiento.

repeat_penalty=1.2

El repeat_penalty es un parámetro utilizado para minimizar repeticiones en el texto generado. Es un aspecto importante para mejorar la calidad y variedad del texto producido.

  • Este parámetro tiene como objetivo penalizar la repetición de palabras o frases que ya han aparecido en el texto generado. En otras palabras, disminuye la probabilidad de volver a seleccionar palabras o frases que se han utilizado recientemente.
  • Cuando el modelo genera texto, asigna puntuaciones (probabilidades) a posibles palabras para usar a continuación. Si una palabra ya se ha utilizado, el repeat_penalty reduce la puntuación de esa palabra, haciéndola menos probable que se elija nuevamente.
  • Cuanto más alto sea el repeat_penalty, más fuerte será la penalización por repetición de palabras.
  • Con un repeat_penalty bajo o nulo, el modelo puede generar textos con repeticiones frecuentes, lo que puede hacer que el texto sea monótono o menos natural.
  • Con un alto repeat_penalty, el modelo tiende a evitar repeticiones, lo que puede contribuir a la variedad y riqueza del texto. Sin embargo, una penalización demasiado alta también puede obligar al modelo a usar palabras menos apropiadas, afectando potencialmente la coherencia del texto.
  • Para textos más fluidos: Un repeat_penalty moderado es útil para evitar repeticiones mientras se mantiene la consistencia y el flujo natural del texto.
  • Para textos altamente variados: Un repeat_penalty más alto se puede usar para estimular la diversidad en el texto, especialmente en contextos creativos.

El valor exacto del repeat_penalty dependerá de las especificidades del modelo y del tipo de texto que desees generar. A menudo requiere experimentar con diferentes valores para encontrar el equilibrio ideal.

Para obtener más información, aquí hay un extracto de la documentación de llama_cpp_python. Puede ser útil para una mejor comprensión de algunos parámetros.

https://llama-cpp-python.readthedocs.io/es/latest/api-reference/- ruta_del_modelo (str) - Ruta al modelo.

  • Explicación: Indica dónde se encuentra el archivo del modelo en tu computadora.

  • n_capas_gpu (int, predeterminado: 0) - Número de capas para transferir a la GPU (-ngl). Si es -1, se transfieren todas las capas.

    • Explicación: Determina cuántas capas del modelo deben ejecutarse en la GPU. Útil para administrar la carga de trabajo entre la CPU y la GPU.

  • gpu_principal (int, predeterminado: 0) - La GPU utilizada para cálculos temporales y tensores pequeños.

    • Explicación: Selecciona qué GPU (si hay varias disponibles) se utiliza para las operaciones principales.

  • división_tensor (Opcional[List[float]], predeterminado: Ninguno) - Cómo dividir los tensores entre las GPUs. Si es Ninguno, el modelo no se divide.

    • Explicación: Permite la distribución de los datos del modelo entre múltiples GPUs, si están disponibles.

  • solo_vocabulario (bool, predeterminado: Falso) - Cargar solo el vocabulario, no los pesos del modelo.

    • Explicación: Útil si solo necesitas el vocabulario incorporado del modelo, sin las partes entrenadas.

  • usar_mmap (bool, predeterminado: Verdadero) - Usar mmap si es posible.

    • Explicación: mmap permite una gestión más eficiente de la memoria al cargar archivos grandes.

  • usar_mlock (bool, predeterminado: Falso) - Obliga al sistema a mantener el modelo en RAM.

    • Explicación: Asegura que el modelo permanezca en la memoria activa para un acceso más rápido.

  • semilla (int, predeterminado: LLAMA_DEFAULT_SEED) - Semilla para el generador de números aleatorios, -1 para aleatorio.

    • Explicación: Determina la secuencia de números aleatorios utilizada, importante para la reproducibilidad de los resultados.

  • n_ctx (int, predeterminado: 512) - Contexto textual, 0 = el propio del modelo.

    • Explicación: Define el tamaño del contexto (número de tokens) que el modelo tiene en cuenta para sus predicciones.

  • n_lote (int, predeterminado: 512) - Tamaño máximo de procesamiento por lote para las indicaciones.

    • Explicación: Determina cuántas indicaciones pueden procesarse al mismo tiempo.

  • n_hilos (Opcional[int], predeterminado: Ninguno) - Número de hilos para usar en la generación.

    • Explicación: Permite configurar el multihilo para acelerar la generación.

  • n_hilos_lote (Opcional[int], predeterminado: Ninguno) - Número de hilos para usar en el procesamiento por lote.

    • Explicación: Similar a n_hilos, pero específico para el procesamiento por lote.

  • tipo_escalamiento_rope (Opcional[int], predeterminado: LLAMA_ROPE_SCALING_UNSPECIFIED) - Tipo de escalamiento RoPE, según la enumeración llama_rope_scaling_type. Ref: pull request #2054 de llama.cpp

    • Explicación: Parámetro avanzado relacionado con el escalamiento de ciertos cálculos en el modelo.

  • base_frecuencia_rope (float, predeterminado: 0.0) - Base de frecuencia RoPE, 0 = la propia del modelo.

    • Explicación: Establece un valor base para el cálculo de frecuencia en RoPE, un parámetro avanzado del modelo.

  • escala_frecuencia_rope (float, predeterminado: 0.0) - Factor de escala de frecuencia RoPE, 0 = la propia del modelo.

    • Explicación: Ajusta la escala de la frecuencia utilizada en RoPE.

  • factor_extrapolación_yarn_ext (float, predeterminado: -1.0) - Factor de extrapolación de mezcla YaRN, negativo = el propio del modelo.

    • Explicación: Parámetro avanzado que influye en la forma en que YaRN, una parte del modelo, mezcla datos.

  • factor_atención_yarn_attn (float, predeterminado: 1.0) - Factor de escala de magnitud de atención YaRN.

    • Explicación: Ajusta la escala de algunos cálculos en YaRN.

  • beta_rápida_yarn_beta_fast (float, predeterminado: 32.0) - Dimensión baja de corrección de YaRN.

    • Explicación: Parámetro técnico relacionado con la corrección rápida en YaRN.- yarn_beta_lento (float, predeterminado: 1.0) – Dimensión de corrección alta de YaRN.

    • Explicación: Parámetro técnico para la corrección lenta en YaRN.

  • yarn_orig_ctx (int, predeterminado: 0) – Tamaño del contexto original de YaRN.

    • Explicación: Determina el tamaño del contexto original para ciertos cálculos en YaRN.

  • f16_kv (bool, predeterminado: True) – Utilizar fp16 para la caché KV, de lo contrario fp32.

    • Explicación: Determina el formato de datos en la caché de clave/valor, influenciando el rendimiento y uso de memoria.

  • logits_all (bool, predeterminado: False) – Devuelve logits para todos los tokens, no solo para el último. Debe ser True para que la completación devuelva logprobs.

    • Explicación: Si es True, el modelo proporcionará logits (puntajes antes de la función de activación) para cada token generado.

  • embedding (bool, predeterminado: False) – Solo modo de incrustación.

    • Explicación: Si es True, el modelo opera en modo de incrustación, utilizado para obtener representaciones vectoriales de los datos.

  • ultimo_n_tokens_tamaño (int, predeterminado: 64) – Número máximo de tokens a mantener en el búfer ultimo_n_tokens.

    • Explicación: Define el tamaño del búfer para los últimos tokens generados.

  • lora_base (Optionalstrstrstr, predeterminado: None) – Ruta opcional al modelo base, útil si estás utilizando un modelo base cuantizado y quieres aplicar LoRA a un modelo f16.

    • Explicación: Permite aplicar ajustes de LoRA a un modelo base específico.

  • lora_ruta (Optionalstrstrstr, predeterminado: None) – Ruta a un archivo LoRA para aplicar al modelo.

    • Explicación: Especifica un archivo LoRA para modificar el modelo.

  • numa (bool, predeterminado: False) – Habilitar soporte NUMA. (NOTA: El valor inicial de este parámetro se utiliza para el resto del programa, ya que este valor se establece en llama_backend_init)

    • Explicación: Habilita o deshabilita el soporte para NUMA, un método de optimización de gestión de memoria en sistemas con múltiples CPU.

  • formato_chat (str, predeterminado: 'llama-2') – Cadena especificando el formato de chat a utilizar al llamar a create_chat_completion.

    • Explicación: Determina el formato de salida para las sesiones de chat generadas.

  • manejador_chat (OptionalLlamaChatCompletionHandlerLlamaChatCompletionHandlerLlamaChatCompletionHandler, predeterminado: None) – Manejador de chat opcional a utilizar al llamar a create_chat_completion.

    • Explicación: Permite la personalización del procesamiento de las sesiones de chat.

  • verboso (bool, predeterminado: True) – Mostrar salida detallada en stderr.

    • Explicación: Si es True, el modelo proporcionará información detallada sobre su funcionamiento durante la ejecución.

Aquí está la introducción a RAG. Aún no hemos llegado al corazón del asunto, pero esta primera parte nos ha permitido destacar el concepto y mostrar cómo funcionan las cosas. Nos vemos en la parte 2 donde comenzaremos a introducir datos en la base de datos. Veremos cómo TxtAi gestiona por sí solo hacer consultas para recuperar contenido y proporcionarnos una respuesta coherente adecuada para el usuario.