Langchain con integraciones de código abierto

16 de diciembre del 2024

Integraciones de código abierto en Langchain

Uso de modelos de lenguaje

Uso de modelos de Ollama

Como ya hemos visto en el post de Ollama, es un framework sobre llama.cpp que nos permite usar modelos de lenguaje de manera sencilla y que también nos permite usar modelos cuantizados.

Así que vamos a ver cómo usar Qwen2.5 7B con Ollama en Langchain.

Antes de nada, tenemos que instalar el módulo de Llama de Langchain

pip install -U langchain-ollama

Descargar modelo

Lo primero de todo es descargar el modelo qwen2.5:7b de Ollama. Usamos el de 7B para que cualquiera con una GPU lo pueda usar.

	
		!ollama pull qwen2.5:7b

	
		pulling manifest ⠙ pulling manifest ⠹ pulling manifest ⠸ pulling manifest ⠸ pulling manifest ⠴ pulling manifest ⠦ pulling manifest ⠧ pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏    0 B/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏    0 B/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏    0 B/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏    0 B/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏ 9.7 MB/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏  12 MB/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏  17 MB/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   0% ▕                ▏  21 MB/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   1% ▕                ▏  31 MB/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   1% ▕                ▏  42 MB/4.7 GB                  pulling manifest 
pulling 2bada8a74506...   1% ▕                ▏  51 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   1% ▕                ▏  57 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   1% ▕                ▏  65 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   1% ▕                ▏  70 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   2% ▕                ▏  79 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   2% ▕                ▏  88 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   2% ▕                ▏  93 MB/4.7 GB   47 MB/s   1m37spulling manifest 
pulling 2bada8a74506...   2% ▕                ▏ 103 MB/4.7 GB   47 MB/s   1m36spulling manifest 
pulling 2bada8a74506...   2% ▕                ▏ 112 MB/4.7 GB   47 MB/s   1m36spulling manifest 
pulling 2bada8a74506...   3% ▕                ▏ 117 MB/4.7 GB   47 MB/s   1m36spulling manifest 
pulling 2bada8a74506...   3% ▕                ▏ 126 MB/4.7 GB   63 MB/s   1m11spulling manifest 
pulling 2bada8a74506...   3% ▕                ▏ 135 MB/4.7 GB   63 MB/s   1m11spulling manifest 
pulling 2bada8a74506...   3% ▕                ▏ 141 MB/4.7 GB   63 MB/s   1m11spulling manifest 
pulling 2bada8a74506...   3% ▕                ▏ 150 MB/4.7 GB   63 MB/s   1m11spulling manifest 
...
pulling eb4402837c78... 100% ▕████████████████▏ 1.5 KB                         
pulling 832dd9e00a68... 100% ▕████████████████▏  11 KB                         
pulling 2f15b3218f05... 100% ▕████████████████▏  487 B                         
verifying sha256 digest 
writing manifest 
removing any unused layers 
success

Chat models

La primera opción que tenemos para usar modelos de lenguaje con Ollama en Langchain es usar la clase ChatOllama.

Creamos el objeto ChatOllama con el modelo qwen2.5:7b.

	
		from langchain_ollama import ChatOllama
 
chat_model = ChatOllama(
    model = "qwen2.5:7b",
    temperature = 0.8,
    num_predict = 256,
)

Inferencia offline

Ahora hacemos inferencia con el modelo de manera offline, es decir, sin usar streaming. Este método espera a tener toda la respuesta

	
		messages = [
    ("system", "Eres un asistente de IA que responde preguntas sobre IA."),
    ("human", "¿Qué son los LLMs?"),
]
response = chat_model.invoke(messages)
print(response.content)

	
		LLMs es el acrónimo de Large Language Models (Modelos de Lenguaje Grandes). Estos son sistemas de inteligencia artificial basados en modelos de aprendizaje automático profundo que están diseñados para comprender y generar texto humano. Algunas características clave de los LLMs incluyen:
1. **Tamaño**: Generalmente se refiere a modelos con billones de parámetros, lo cual les permite aprender de grandes cantidades de datos.
2. **Capacidad de Generación de Texto**: Pueden generar texto coherente y relevante basado en entradas iniciales o prompts proporcionados por el usuario.
3. **Entendimiento del Lenguaje Natural**: Poseen un entendimiento profundo de la gramática, semántica y contexto del lenguaje humano.
4. **Aplicaciones Versátiles**: Se utilizan en una amplia gama de tareas como asistentes virtuales, traducción automática, resumen de texto, escritura creativa, etc.
5. **Entrenamiento Supervisado**: A menudo se entrenan utilizando conjuntos de datos extensos y variados para mejorar su capacidad de comprensión e

Inferencia por streaming

Si queremos hacer streaming, podemos usar el método stream.

	
		for chunk in chat_model.stream(messages):
    print(chunk.content, end="", flush=True)

	
		LLMs es el acrónimo de Large Language Models, lo cual se refiere a modelos de inteligencia artificial de lenguaje de gran escala. Estos son sistemas entrenados con técnicas de aprendizaje supervisado y no supervisado que pueden generar texto humano似的，准确回答如下：
LLMs es el acrónimo de Large Language Models, lo cual se refiere a modelos de inteligencia artificial de lenguaje de gran escala. Estos son sistemas que se entrenan con grandes conjuntos de datos de texto para aprender patrones y relaciones lingüísticas. Algunas características clave de los LLMs incluyen:
1. **Tamaño**: Generalmente se basan en arquitecturas de redes neuronales profunda como Transformers, lo que les permite manejar cantidades extremadamente grandes de parámetros.
2. **Entrenamiento**: Se entrena con datos de texto muy variados para capturar una amplia gama de conocimientos y habilidades lingüísticas.
3. **Generación de texto**: Pueden generar textos coherentes y relevantes basándose en el contexto proporcionado, lo que les permite realizar tareas como la escritura creativa,

Embeddings

Si queremos usar embeddings, podemos usar la clase OllamaEmbeddings.

Ahora creamos el objeto OllamaEmbeddings con el modelo qwen2.5:7b.

	
		from langchain_ollama import OllamaEmbeddings
 
embeddings_model = OllamaEmbeddings(
    model = "qwen2.5:7b"
)

Embed un solo texto

	
		input_text = "¿Qué son los LLMs?"
embedding = embeddings_model.embed_query(input_text)
len(embedding), type(embedding), embedding[0:3]

	
		(3584, list, [0.00045780753, -0.010200562, 0.0059901197])

Embed de varios textos

	
		input_texts = ["¿Qué son los LLMs?", "¿Qué son los embeddings?"]
embeddings = embeddings_model.embed_documents(input_texts)
len(embeddings[0]), type(embeddings[0]), embeddings[0][0:3], len(embeddings[1]), type(embeddings[1]), embeddings[1][0:3]

	
		(3584,
 list,
 [0.00045780753, -0.010200562, 0.0059901197],
 3584,
 list,
 [0.0007678218, -0.01124029, 0.008565228])

LLMs

Si solo queremos usar un modelo de lenguaje, podemos usar la clase OllamaLLM.

Ahora creamos el objeto OllamaLLM con el modelo qwen2.5:7b.

	
		from langchain_ollama import OllamaLLM
 
llm_model = OllamaLLM(
    model = "qwen2.5:7b"
)

Inferencia offline

Ahora hacemos inferencia con el modelo de manera offline, es decir, sin usar streaming. Este método espera a tener toda la respuesta

	
		message = "¿Qué son los LLMs?"
response = llm_model.invoke(message)
print(response)

	
		Los LLMs es una abreviatura común en español que se refiere a "Lenguajes de Marcado de Libre Mando". Sin embargo, en el contexto del procesamiento del lenguaje natural y la inteligencia artificial, es probable que estés buscando información sobre otro término.
En inglés, el término LLMs (Large Language Models) se refiere a modelos de lenguaje de gran tamaño. Estos son sistemas de IA que están entrenados en una amplia gama de datos de texto para comprender y generar texto humano-like. Algunas características clave de los LLMs incluyen:
1. Tamaño: Generalmente se refiere a modelos con millones o incluso billones de parámetros.
2. Generación de texto: Pueden generar texto en respuesta a una entrada dada, lo que les hace útiles para tareas como escritura automática, conversaciones de chat, etc.
3. Entrenamiento en datos variados: Son entrenados con grandes conjuntos de datos de internet o corpora literales y académicos.
4. Aplicaciones: Se utilizan en una variedad de aplicaciones, incluyendo asistentes virtuales, traducción automática, análisis de sentimientos, resumen de texto, etc.
Un ejemplo famoso de LLMs es la familia de modelos GPT (Generative Pre-trained Transformer) desarrollados por OpenAI. Otros ejemplos incluyen los modelos de PaLM y Qwen de Anthropic, entre otros.
¿Te gustaría saber más sobre algún aspecto en particular de estos modelos?

Inferencia por streaming

Si queremos hacer streaming, podemos usar el método stream.

	
		for chunk in llm_model.stream(message):
    print(chunk, end="", flush=True)

	
		Los LLMs es una abreviatura que se refiere a los Modelos de Lenguaje de Grande Escala (Large Language Models en inglés). Estos son modelos de inteligencia artificial desarrollados para entender y generar texto humano. Algunas características clave de los LLMs incluyen:
1. **Capacidad de Generación de Texto**: Pueden generar texto coherente, original e informativo en varios estilos y formatos.
2. **Entendimiento del Contexto**: Tienen una comprensión profunda del contexto y la gramática para producir respuestas apropiadas a las entradas proporcionadas.
3. **Multiplicidad de Usos**: Se pueden aplicar a diversas tareas, como escritura creativa, asistencia en atención al cliente, creación de contenido, traducción automática, etc.
4. **Aprendizaje Supervisado**: Son entrenados con grandes cantidades de texto para aprender patrones y conocimientos del lenguaje humano.
5. **Limitaciones Eticas y Jurídicas**: Existen preocupaciones sobre el uso ético y legal de estos modelos, incluyendo el potencial de generar contenido inapropiado o engañoso.
Algunos ejemplos populares de LLMs incluyen los creados por empresas como Anthropic (Clara), Google (Switch Transformer), Microsoft (Cobalt) y, aunque ya no actualmente soportado, OpenAI (GPT-3).

Uso de modelos de HuggingFace

Aunque Ollama es muy sencillo de usar, no tiene tantos modelos como hay en el Hub de HuggingFace. Además, es probable que no tenga el último gran modelo que quieras usar, por lo que vamos a ver cómo usar modelos de HuggingFace en Langchain.

Antes de nada tenemos que instalar el módulo de HuggingFace de Langchain

pip install -U langchain-huggingface

Primero tenemos que logearnos en el Hub de HuggingFace. Para ello necesitamos crear un token de acceso. Una vez creado, lo guardamos en un archivo .env con el nombre LANGCHAIN_TOKEN de la siguiente manera:

echo "LANGCHAIN_TOKEN=hf_..." > .env

Para poder leerlo, instalamos el módulo python-dotenv.

pip install python-dotenv

Ahora logearnos en el Hub de HuggingFace.

	
		import os
import dotenv
 
dotenv.load_dotenv()
 
LANGCHAIN_TOKEN = os.getenv("LANGCHAIN_TOKEN")

	
		from huggingface_hub import login
login(LANGCHAIN_TOKEN)

Chat models

La primera opción que tenemos para usar modelos de lenguaje con HuggingFace en Langchain es usar la clase HuggingFaceEndpoint. Esta opción llama a la API de HuggingFace para hacer inferencia.

Ahora creamos el objeto chat_model con el modelo Qwen2.5-72B-Instruct.

	
		from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
 
llm = HuggingFaceEndpoint(
    repo_id="Qwen/Qwen2.5-72B-Instruct",
    task="text-generation",
    max_new_tokens=512,
    do_sample=False,
    repetition_penalty=1.03,
)
 
chat = ChatHuggingFace(llm=llm, verbose=True)

Inferencia offline

Ahora hacemos inferencia con el modelo de manera offline, es decir, sin usar streaming. Este método espera a tener toda la respuesta

	
		messages = [
    ("system", "Eres un asistente de IA que responde preguntas sobre IA."),
    ("human", "¿Qué son los LLMs?"),
]
response = chat.invoke(messages)
print(response.content)

Los LLMs, o Large Language Models (Modelos de Lenguaje Grande en español), son sistemas de inteligencia artificial diseñados para procesar y generar texto basado en lenguaje natural. Estos modelos son capaces de comprender, analizar y producir texto humano de manera sofisticada, lo que los hace útiles en una amplia variedad de aplicaciones, como la traducción de idiomas, el análisis de sentimientos, la generación de respuestas a preguntas, la escritura creativa, la asistencia en tareas, entre otras.
### Características principales de los LLMs:
1. **Escalabilidad**: Los LLMs suelen tener millones o incluso billones de parámetros, lo que les permite capturar la complejidad del lenguaje humano con un alto nivel de detalle.
2. **Entrenamiento supervisado y no supervisado**: Pueden ser entrenados con grandes cantidades de datos de texto, tanto de forma supervisada (con etiquetas) como no supervisada (sin etiquetas).
3. **Transfer learning**: Una vez entrenados, estos modelos pueden ser finetuneados (ajustados) para tareas específicas con un conjunto de datos más pequeño, lo que los hace muy versátiles.
4. **Generación de texto**: Son capaces de generar texto coherente y contextualmente relevante, lo que los hace ideales para tareas como la escritura creativa, la redacción de informes, y la generación de respuestas en chatbots.
5. **Comprensión del contexto**: Pueden entender el contexto y las relaciones entre palabras y frases, lo que les permite manejar diálogos y discursos complejos.
6. **Interacción humana**: Son diseñados para interactuar de manera fluida y natural con seres humanos, lo que los hace útiles en aplicaciones conversacionales.
### Ejemplos de LLMs:
- **GPT-3 (Generative Pre-trained Transformer 3)**: Desarrollado por OpenAI, es uno de losmodelos más conocidos y potentes.
- **BERT (Bidirectional Encoder Representations from Transformers)**: Diseñado por Google, es conocido por su capacidad de comprensión del contexto.
- **T5 (Text-to-Text Transfer Transformer)**: También de Google, se destaca por su flexibilidad y versatilidad.
Los LLMs representan un avance significativo en el campo de la inteligencia artificial, especialmente en el procesamiento del lenguaje natural, y continúan evoluinto rápidamente.

Inferencia por streaming

Si queremos hacer streaming, podemos usar el método stream.

	
		for chunk in chat.stream(messages):
    print(chunk.content, end="", flush=True)

Embeddings

Embeddings en local

Si queremos crear embeddings en local, podemos usar la clase HuggingFaceEmbeddings. Para ello necesitamos tener instalada la librería sentence-transformers.

pip install -U sentence-transformers

Luego ya podemos crear embeddings en local

	
		from langchain_huggingface import HuggingFaceEmbeddings
import torch
model_name = "sentence-transformers/all-mpnet-base-v2"
device = "cuda" if torch.cuda.is_available() else "cpu"
model_kwargs = {"device": device}
encode_kwargs = {"normalize_embeddings": True}
embeddings_model = HuggingFaceEmbeddings(
    model_name=model_name,
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
input_text = "¿Qué son los LLMs?"
embedding = embeddings_model.embed_query(input_text)
len(embedding), type(embedding), embedding[0:3]

	
		(768,
 list,
 [-0.03638569265604019, -0.003062659176066518, 0.005454241763800383])

Si queremos crear embeddings de varios textos, podemos usar el método embed_documents.

	
		input_texts = ["¿Qué son los LLMs?", "¿Qué son los embeddings?"]
embeddings = embeddings_model.embed_documents(input_texts)
len(embeddings[0]), type(embeddings[0]), embeddings[0][0:3], len(embeddings[1]), type(embeddings[1]), embeddings[1][0:3]

	
		(768,
 list,
 [-0.0363856740295887, -0.0030626414809376, 0.005454237572848797],
 768,
 list,
 [-0.014533628709614277, 0.01950662210583687, -0.01753164641559124])

Embeddings en HuggingFace

Si queremos usar la API de HuggingFace para crear embeddings, podemos usar la clase HuggingFaceEmbeddings.

	
		from langchain_huggingface import HuggingFaceEndpointEmbeddings
model = "sentence-transformers/all-mpnet-base-v2"
embeddings_model = HuggingFaceEndpointEmbeddings(
    model=model,
    task="feature-extraction",
)
input_text = "¿Qué son los LLMs?"
embedding = embeddings_model.embed_query(input_text)
len(embedding), type(embedding), embedding[0:3]

	
		(768,
 list,
 [-0.03638569638133049, -0.0030626363586634398, 0.005454216152429581])

Si se quiere crear embeddings de varios textos, podemos usar el método embed_documents.

	
		input_texts = ["¿Qué son los LLMs?", "¿Qué son los embeddings?"]
embeddings = embeddings_model.embed_documents(input_texts)
len(embeddings[0]), type(embeddings[0]), embeddings[0][0:3], len(embeddings[1]), type(embeddings[1]), embeddings[1][0:3]

	
		(768,
 list,
 [-0.03638570010662079, -0.003062596544623375, 0.005454217083752155],
 768,
 list,
 [-0.014533626846969128, 0.019506637006998062, -0.01753171905875206])

Pipeline

Podemos crear un pipeline de Transformers y usarlo en Langchain, para ello necesitamos instalar el módulo transformers.

pip install -U transformers

Para asegurarnos de que todo el mundo pueda probar el ejemplo, vamos a usar el modelo Qwen/Qwen2.5-3B-Instruct.

Tenemos dos maneras, crear un pipeline mediante Langchain

from langchain_huggingface import HuggingFacePipeline
      
      model = "Qwen/Qwen2.5-3B-Instruct"
      langchain_pipeline = HuggingFacePipeline.from_model_id(
          model_id=model,
          task="text-generation",
          pipeline_kwargs={"max_new_tokens": 512},
      )

Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]

Device set to use cuda:0

O podemos crear un pipeline mediante Transformers.

from langchain_huggingface import HuggingFacePipeline
      from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
      
      model = "Qwen/Qwen2.5-3B-Instruct"
      tokenizer = AutoTokenizer.from_pretrained(model)
      model = AutoModelForCausalLM.from_pretrained(model)
      pipe = pipeline(
          "text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512
      )
      transformers_pipeline = HuggingFacePipeline(pipeline=pipe)

Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]

Device set to use cuda:0

Inferencia offline

	
		langchain_response = langchain_pipeline.invoke("¿Qué son los LLMs?")
print(langchain_response)

¿Qué son los LLMs? - El Blog de Ciberseguridad
Publicado por: CiberSeguridad 18/03/2022
En el mundo de la tecnología y la inteligencia artificial, las nuevas tecnologías que surgen a menudo se presentan como un paso hacia adelante en la mejora de nuestras vidas. Sin embargo, a veces estas innovaciones pueden resultar en desafíos significativos, especialmente cuando se trata de la seguridad cibernética.
En este artículo, exploraremos los LLMs, o modelos lingüísticos grandes (Large Language Models), una nueva clase de inteligencia artificial que está revolucionando el campo de la comunicación y la creación de contenido. Aunque estos modelos son muy prometedores, también tienen implicaciones significativas para la seguridad cibernética. En esta entrada, te explicamos qué son los LLMs y cómo afectan a la seguridad digital.
¿Qué son los LLMs?
Los modelos lingüísticos grandes son algoritmos de aprendizaje automático que han sido entrenados con grandes conjuntos de texto, generalmente en formato de texto natural. Estos modelos pueden procesar y generar texto de manera similar a una persona, lo que los hace extremadamente útiles para tareas como la traducción, la autocompletado de texto y la generación de contenido creativo.
Los LLMs se basan en técnicas de aprendizaje profundo, que son una forma avanzada de algoritmo de aprendizaje automático. Este tipo de algoritmo utiliza redes neuronales para aprender patrones y relaciones en datos grandes, permitiendo a los modelos predecir resultados o tomar decisiones basadas en esa información.
Estos modelos son capaces de aprender y generar texto en un amplio rango de temas, desde descripciones de libros hasta diálogos interactivos, lo que los hace excelentes para tareas de generación de contenido. También pueden ser utilizados para tareas más específicas, como la traducción de idiomas o la resolución de problemas de lógica.
¿Cómo afectan a la seguridad cibernética?
Los LLMs representan una gran oportunidad para mejorar la eficiencia y la precisión de muchas tareas de texto, pero también traen consigo desafíos significativos en términos de seguridad. Algunas de las preocupaciones más comunes incluyen:
Privacidad: Los LLM

transformers_response = transformers_pipeline("¿Qué son los LLMs?")
      print(transformers_response)

/tmp/ipykernel_318295/4120882068.py:1: LangChainDeprecationWarning: The method `BaseLLM.__call__` was deprecated in langchain-core 0.1.7 and will be removed in 1.0. Use :meth:`~invoke` instead.
        transformers_response = transformers_pipeline("¿Qué son los LLMs?")

¿Qué son los LLMs? ¿Cómo funcionan y qué pueden hacer?

Los LLMs (Large Language Models) son modelos de inteligencia artificial que han sido entrenados con enormes cantidades de texto. Estos modelos pueden procesar y generar texto en una variedad de lenguajes, desde el inglés hasta idiomas menos comunes. Los LLMs están diseñados para entender y generar texto con un nivel de precisión similar al humano.

Funcionamiento:
1. Entrenamiento: Los LLMs se entrenan utilizando grandes conjuntos de datos de texto, como libros electrónicos, artículos de noticias, etc.
2. Análisis: Después del entrenamiento, los LLMs analizan patrones en el texto y aprenden a asociar palabras y frases con otros textos similares.
3. Generación de texto: Cuando se le pide al modelo que genere texto, analiza los patrones que ha aprendido y genera texto basado en esos patrones.

Pueden hacer:
1. Traducción: Convertir texto de un idioma a otro.
2. Resumen de texto: Summarizar largos documentos en versiones más cortas.
3. Creación de contenido: Generar artículos, correos electrónicos, historias, etc.
4. Resolución de problemas: Ayudar a resolver problemas o proporcionar soluciones basadas en el texto.
5. Chatbots: Usar para crear asistentes virtuales que puedan responder preguntas y ayudar con tareas.
6. Crea contenido: Escribe contenido creativo como poesía, relatos, etc.
7. Ajuste de lenguaje: Corrige errores gramaticales y mejora la escritura.

Es importante tener en cuenta que aunque estos modelos son muy poderosos, todavía tienen limitaciones y pueden generar contenido incorrecto o inapropiado. Además, la privacidad y la ética son aspectos importantes a considerar al usar estos modelos.

En resumen, los LLMs son herramientas poderosas que pueden ser utilizadas en una variedad de aplicaciones, pero también requieren cuidado y consideración al utilizarlos. Es recomendable siempre verificar el contenido generado por estos modelos y estar atentos a sus posibles limitaciones.

Además, es importante destacar que los LLMs no son sustitutos perfectos para el pensamiento crítico humano. Aunque pueden generar texto de

Inferencia por streaming

	
		for chunk in langchain_pipeline.stream("¿Qué son los LLMs?"):
    print(chunk, end="", flush=True)

- Cursos de Inteligencia Artificial en línea
Los LLMs, o Lenguajes de Lenguaje de Modelos, son modelos de aprendizaje automático que han sido entrenados para producir texto similar al de un humano. Estos modelos pueden ser utilizados para una variedad de tareas, como la generación de texto, el chatbot, el análisis de sentimientos, etc.
En resumen, los LLMs son modelos de aprendizaje automático que han sido entrenados para producir texto similar al de un humano. Estos modelos pueden ser utilizados para una variedad de tareas, como la generación de texto, el chatbot, el análisis de sentimientos, etc. Los LLMs son un tipo de modelo de inteligencia artificial y se utilizan en una amplia gama de aplicaciones, desde la creación de contenido hasta el asesoramiento.
Los LLMs son modelos de aprendizaje automático que han sido entrenados para producir texto similar al de un humano. Estos modelos pueden ser utilizados para una variedad de tareas, como la generación de texto, el chatbot, el análisis de sentimientos, etc. Los LLMs son un tipo de modelo de inteligencia artificial y se utilizan en una amplia gama de aplicaciones, desde la creación de contenido hasta el asesoramiento. Los LLMs están basados en redes neuronales y se entrenan con grandes conjuntos de datos de texto para aprender a generar texto similar al de un humano.
Los LLMs están disponibles en diferentes plataformas, incluyendo Google's PaLM, Anthropic's Claude, Microsoft's Bing, e incluso tu propio teléfono inteligente puede tener uno. Los LLMs pueden ser utilizados para una variedad de tareas, incluyendo la generación de texto, el chatbot, el análisis de sentimientos, etc. Los LLMs son un tipo de modelo de inteligencia artificial y se utilizan en una amplia gama de aplicaciones, desde la creación de contenido hasta el asesoramiento. Los LLMs están basados en redes neuronales y se entrenan con grandes conjuntos de datos de texto para aprender a generar texto similar al de un humano. Los LLMs están disponibles en diferentes plataformas, incluyendo Google's PaLM, Anthropic's Claude, Microsoft's Bing, e incluso tu propio teléfono inteligente puede tener uno

	
		for chunk in transformers_pipeline.stream("¿Qué son los LLMs?"):
    print(chunk, end="", flush=True)

| El Blog de la Inteligencia Artificial
Home » Noticias » ¿Qué son los LLMs?
LLM es la sigla en inglés para Large Language Models, que traducido al castellano sería "Grandes Modelos de Lenguaje". Son modelos de inteligencia artificial (IA) que permiten a las máquinas entender y generar texto.
Los LLMs se basan en el aprendizaje profundo, una técnica de IA que utiliza redes neuronales para modelar relaciones entre variables. Estos modelos son capaces de aprender patrones en grandes conjuntos de datos, lo que les permite predecir o generar texto similar al que se les ha proporcionado.
Las principales características de los LLMs incluyen:
Capacidad de procesamiento de lenguaje natural: Los LLMs pueden entender y generar texto, lo que les permite interactuar con los usuarios de manera fluida y natural.
Capacidad de aprendizaje continuo: Los LLMs pueden aprender y mejorar con cada interacción, lo que les permite ofrecer respuestas más precisas y relevantes a medida que ganan experiencia.
Capacidad de generación de texto: Los LLMs pueden generar texto similar al que se les ha proporcionado, lo que les permite crear contenido de calidad sin necesidad de intervención humana manual.
Ventajas de los LLMs:
Mayor eficiencia: Los LLMs pueden procesar grandes cantidades de información de manera rápida y precisa, lo que les permite ahorrar tiempo y recursos en comparación con los métodos humanos.
Mejora de la precisión: Los LLMs pueden aprender y ajustarse a los patrones del lenguaje, lo que les permite ofrecer respuestas más precisas y relevantes a los usuarios.
Aumento de la productividad: Los LLMs pueden automatizar tareas repetitivas y monótonas, liberando tiempo y recursos para que los humanos puedan centrarse en tareas más estratégicas y creativas.
Entendimiento del lenguaje humano: Los LLMs pueden entender y generar texto en varios idiomas, lo que les permite interactuar con un amplio espectro de usuarios.
Evaluación de la inteligencia artificial
Los LLMs están siendo utilizados en una variedad de aplicaciones, desde asistentes virtuales hasta análisis de texto y traducción automática. También están siendo evaluados por su capacidad para generar contenido de

Uso de bases de datos vectoriales

Uso de ChromaDB

Para poder usar ChromaDB en Langchain, primero tenemos que instalar langchain-chroma.

pip install -qU chromadb langchain-chroma

Crear un vector store

	
		from langchain_chroma import Chroma
from langchain_huggingface import HuggingFaceEmbeddings
import torch
 
model_name = "sentence-transformers/all-mpnet-base-v2"
device = "cuda" if torch.cuda.is_available() else "cpu"
model_kwargs = {"device": device}
encode_kwargs = {"normalize_embeddings": True}
 
embedding_model = HuggingFaceEmbeddings(
    model_name=model_name,
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
 
vector_store = Chroma(
    collection_name="chroma_db",
    embedding_function=embedding_model,
)

Añadir documentos

	
		from langchain_core.documents import Document
document_1 = Document(page_content="This is a Mojo docs", metadata={"source": "Mojo source"})
document_2 = Document(page_content="This is Rust docs", metadata={"source": "Rust source"})
document_3 = Document(page_content="i will be deleted :(")
documents = [document_1, document_2, document_3]
ids = ["1", "2", "3"]
vector_store.add_documents(documents=documents, ids=ids)

	
		['1', '2', '3']

Actualizar documentos

	
		updated_document = Document(
    page_content="This is Python docs",
    metadata={"source": "Python source"}
)
 
vector_store.update_documents(ids=["1"],documents=[updated_document])

Borrar documentos

	
		vector_store.delete(ids=["3"])

Búsqueda de documentos

	
		results = vector_store.similarity_search(query="python",k=1)
for doc in results:
    print(f"* {doc.page_content} [{doc.metadata}]")

	
		* This is Python docs [{'source': 'Python source'}]

Búsqueda con filtros

	
		results = vector_store.similarity_search(query="python",k=1,filter={"source": "Python source"})
for doc in results:
    print(f"* {doc.page_content} [{doc.metadata}]")

	
		* This is Python docs [{'source': 'Python source'}]

Búsqueda con puntuación

	
		results = vector_store.similarity_search_with_score(query="python",k=1)
for doc, score in results:
    print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")

	
		* [SIM=0.809454] This is Python docs [{'source': 'Python source'}]

Uso como retriever

	
		retriever = vector_store.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 1, "fetch_k": 2, "lambda_mult": 0.5},
)
retriever.invoke("python")

	
		[Document(metadata={'source': 'Python source'}, page_content='This is Python docs')]

Medida de similitud por coseno

Este método calcula la similitud por coseno entre dos vectores, por lo que en vez de pasarle dos strings, hay que pasarle dos vectores.

Así que primero creamos un modelo de embeddings.

	
		from langchain_huggingface import HuggingFaceEmbeddings
import numpy as np
import torch
 
model_name = "sentence-transformers/all-mpnet-base-v2"
device = "cuda" if torch.cuda.is_available() else "cpu"
model_kwargs = {"device": device}
encode_kwargs = {"normalize_embeddings": True}
 
embeddings_model = HuggingFaceEmbeddings(
    model_name=model_name,
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)
 
document1 = "Python"
document2 = "python"
 
embedding1 = embeddings_model.embed_query(document1)
embedding2 = embeddings_model.embed_query(document2)
 
embedding1_numpy = np.array(embedding1)
embedding2_numpy = np.array(embedding2)
 
embedding1_torch = torch.tensor(embedding1_numpy).unsqueeze(0)
embedding2_torch = torch.tensor(embedding2_numpy).unsqueeze(0)

Y ahora podemos calcular la similitud por coseno.

	
		from langchain_chroma.vectorstores import cosine_similarity
similarity = cosine_similarity(embedding1_torch, embedding2_torch)
similarity

	
		array([[1.]])

Seguir leyendo

Fundamentos de RAG

¡Olvídate de Ctrl+F! 🤯 Con RAG, tus documentos responderán a tus preguntas directamente. 😎 Tutorial paso a paso con Hugging Face y ChromaDB. ¡Libera el poder de la IA (y presume con tus amigos)! 💪

Conventional commits

😠 ¿Tus commits parecen escritos en lenguaje alienígena? 👽 ¡Únete al club! 😅 Aprende Conventional Commits en Python y deja de torturar a tu equipo con mensajes crípticos. git-changelog y commitizen serán tus nuevos mejores amigos. 🤝

DoLa – Decoding by Contrasting Layers Improves Factuality in Large Language Models

¿Alguna vez has hablado con un LLM y te ha respondido algo que suena como si hubiera estado bebiendo café de máquina durante toda la noche? 😂 ¡Eso es lo que llamamos una alucinación en el mundo de los LLMs! Pero no te preocupes, porque no es que tu modelo de lenguaje esté loco (aunque a veces puede parecerlo 🤪). La verdad es que los LLMs pueden ser un poco... creativos cuando se trata de generar texto. Pero gracias a DoLa, un método que utiliza capas de contraste para mejorar la factibilidad de los LLMs, podemos evitar que nuestros modelos de lenguaje se conviertan en escritores de ciencia ficción 😂. En este post, te explicaré cómo funciona DoLa y te mostraré un ejemplo de código para que puedas entender mejor cómo hacer que tus LLMs sean más fiables y menos propensos a inventar historias. ¡Vamos a salvar a nuestros LLMs de la locura y hacer que sean más útiles! 🚀

Últimos posts -->

¿Has visto estos proyectos?

Subtify

GPU monitor

Alfred

Ver todos los proyectos -->

¿Quieres aplicar la IA en tu proyecto? Contactame!

¿Quieres mejorar con estos tips?

DataLoader con pin_memory y num_workers

Aumentar el rendimiento de DataLoader con pin_memory y num_workers

py-smi

Librería de Python para obtener datos de la GPU igual que `nvidia-smi`

Memory Calculator

Espacio para calcular la memoria necesaria para ejecutar un modelo

Últimos tips -->

Usa esto en local

Los espacios de Hugging Face nos permite ejecutar modelos con demos muy sencillas, pero ¿qué pasa si la demo se rompe? O si el usuario la elimina? Por ello he creado contenedores docker con algunos espacios interesantes, para poder usarlos de manera local, pase lo que pase. De hecho, es posible que si pinchas en alún botón de ver proyecto te lleve a un espacio que no funciona.

Flow edit

FLUX.1-RealismLora

token_hmr

Ver todos los contenedores -->

¿Quieres aplicar la IA en tu proyecto? Contactame!

¿Quieres entrenar tu modelo con estos datasets?

short-jokes-dataset

Dataset de chistes en inglés

opus100

Dataset con traducciones de inglés a español

netflix_titles

Dataset con películas y series de Netflix

Ver más datasets -->

Integraciones de código abierto en Langchain

Uso de modelos de lenguaje

Uso de modelos de Ollama

Descargar modelo

Chat models

Inferencia offline

Inferencia por streaming

Embeddings

Embed un solo texto

Embed de varios textos

LLMs

Inferencia offline

Inferencia por streaming

Uso de modelos de HuggingFace

Login en el Hub de HuggingFace

Chat models

Inferencia offline

Inferencia por streaming

Embeddings

Embeddings en local

Embeddings en HuggingFace

Pipeline

Inferencia offline

Inferencia por streaming

Uso de bases de datos vectoriales

Uso de ChromaDB

Crear un vector store

Añadir documentos

Actualizar documentos

Borrar documentos

Búsqueda de documentos

Búsqueda con filtros

Búsqueda con puntuación

Uso como retriever

Medida de similitud por coseno

Seguir leyendo

Fundamentos de RAG

Conventional commits

DoLa – Decoding by Contrasting Layers Improves Factuality in Large Language Models

¿Has visto estos proyectos?

¿Quieres aplicar la IA en tu proyecto? Contactame!

¿Quieres mejorar con estos tips?

DataLoader con pin_memory y num_workers

py-smi

Memory Calculator

Usa esto en local

¿Quieres aplicar la IA en tu proyecto? Contactame!

¿Quieres entrenar tu modelo con estos datasets?

short-jokes-dataset

opus100

netflix_titles