Langchain with open source integrations

16 of december of 2024

Open-source Code Integrations in Langchain

Disclaimer: This post has been translated to English using a machine translation model. Please, let me know if you find any mistakes.

Use of language models

Use of Ollama Models

As we have seen in Ollama's post here, it is a framework based on llama.cpp that allows us to use language models in a simple way and also enables the use of quantized models. So let's see how to use Qwen2.5 7B with Ollama in Langchain.

Before anything else, we have to install the Llama module from Langchain

pip install -U langchain-ollama```

Download model

First of all, download the model qwen2.5:7b from Ollama. We use the 7B version so that anyone with a GPU can use it.

	
		!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

The first option we have for using language models with Ollama in Langchain is to use the ChatOllama class.

We created the ChatOllama object with the model qwen2.5:7b.

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

Offline Inference

Now we perform inference with the model in an offline manner, that is, without using streaming. This method waits for the entire response to be available.

	
		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

Streaming Inference

If we want to do streaming, we can use the method 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

If we want to use embeddings, we can use the class OllamaEmbeddings.

Now we create the object OllamaEmbeddings with the model qwen2.5:7b.

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

Embed a single text

	
		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 of multiple texts

	
		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

If we only want to use a language model, we can use the class OllamaLLM.

Now we create the object OllamaLLM with the model qwen2.5:7b.

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

Offline Inference

Now we perform inference with the model in an offline manner, that is, without using streaming. This method waits to have the entire response

	
		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?

Streaming Inference

If we want to do streaming, we can use the method 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).

Usage of HuggingFace Models

Although Ollama is easy to use, it doesn't have as many models as those available on the HuggingFace Hub. Additionally, it's likely that it won't have the latest large model you want to use, so we'll see how to use HuggingFace models in Langchain.

Before we start, we need to install the HuggingFace module of Langchain.

pip install -U langchain-huggingface```

First we need to log in to the HuggingFace Hub. For this, we need to create an access token. Once created, we save it in a .env file with the name LANGCHAIN_TOKEN as follows:

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

To be able to read it, we install the module python-dotenv.

pip install python-dotenv```
      
      Now log into the HuggingFace Hub.

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

	
		from huggingface_hub import login
login(LANGCHAIN_TOKEN)

Chat Models

The first option we have for using language models with HuggingFace in Langchain is to use the HuggingFaceEndpoint class. This option calls the HuggingFace API to perform inference.

Now we create the object chat_model with the model 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)

Offline Inference

Now we perform inference with the model in an offline manner, that is, without using streaming. This method waits to have the entire response

	
		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.

Streaming Inference

If we want to do streaming, we can use the method stream.

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

Embeddings

Embeddings in local

If we want to create embeddings locally, we can use the class HuggingFaceEmbeddings. For this, we need to have the library sentence-transformers installed.

pip install -U sentence-transformers```
      
      We can then create embeddings locally

	
		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])

If we want to create embeddings for multiple texts, we can use the embed_documents method.

	
		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 in HuggingFace

If we want to use the HuggingFace API to create embeddings, we can use the HuggingFaceEmbeddings class.

	
		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])

If we want to create embeddings for multiple texts, we can use the method 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

We can create a pipeline of Transformers and use it in Langchain; for this, we need to install the module transformers.

pip install -U transformers```
      
      To ensure that everyone can test the example, we will use the model `Qwen/Qwen2.5-3B-Instruct`.

We have two ways, to create a pipeline via 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

We can create a pipeline using 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

Offline Inference

	
		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

Streaming Inference

	
		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

Use of Vector Databases

Usage of ChromaDB

To be able to use ChromaDB in Langchain, we first have to install langchain-chroma.

pip install -qU chromadb langchain-chroma```

Create a 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,
)

Add documents

	
		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']

Update documents

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

Delete documents

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

Search for documents

	
		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'}]

Search with Filters

	
		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'}]

Search with punctuation

	
		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'}]

Usage as 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')]

Cosine Similarity Measure

This method calculates the cosine similarity between two vectors, so instead of passing it two strings, you have to pass it two vectors.

So first we create an embedding model.

	
		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)

And now we can calculate the cosine similarity.

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

	
		array([[1.]])

Continue reading

RAG fundamentals

Forget about Ctrl+F! 🤯 With RAG, your documents will answer your questions directly. 😎 Step-by-step tutorial with Hugging Face and ChromaDB. Unleash the power of AI (and show off to your friends)! 💪

Conventional commits

😠 Are your commits written in alien language? 👽 Join the club! 😅 Learn Conventional Commits in Python and stop torturing your team with cryptic messages. git-changelog and commitizen will be your new best friends. 🤝

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

Have you ever talked to an LLM and they answered you something that sounds like they've been drinking machine coffee all night long 😂 That's what we call a hallucination in the LLM world! But don't worry, because it's not that your language model is crazy (although it can sometimes seem that way 🤪). The truth is that LLMs can be a bit... creative when it comes to generating text. But thanks to DoLa, a method that uses contrast layers to improve the feasibility of LLMs, we can keep our language models from turning into science fiction writers 😂. In this post, I'll explain how DoLa works and show you a code example so you can better understand how to make your LLMs more reliable and less prone to making up stories. Let's save our LLMs from insanity and make them more useful! 🚀

Last posts -->

Have you seen these projects?

Subtify

GPU monitor

Alfred

View all projects -->

Do you want to apply AI in your project? Contact me!

Do you want to improve with these tips?

DataLoader with pin_memory and num_workers

Increase DataLoader performance with pin_memory and num_workers

py-smi

Python library to get GPU data like `nvidia-smi`

Memory Calculator

Space to calculate the memory needed to run a model

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.

Flow edit

FLUX.1-RealismLora

token_hmr

View all containers -->

Do you want to apply AI in your project? Contact me!

Do you want to train your model with these datasets?

short-jokes-dataset

Dataset with jokes in English

opus100

Dataset with translations from English to Spanish

netflix_titles

Dataset with Netflix movies and series

View more datasets -->

Open-source Code Integrations in Langchain

Use of language models

Use of Ollama Models

Download model

Chat Models

Offline Inference

Streaming Inference

Embeddings

Embed a single text

Embed of multiple texts

LLMs

Offline Inference

Streaming Inference

Usage of HuggingFace Models

Login in the HuggingFace Hub

Chat Models

Offline Inference

Streaming Inference

Embeddings

Embeddings in local

Embeddings in HuggingFace

Pipeline

Offline Inference

Streaming Inference

Use of Vector Databases

Usage of ChromaDB

Create a vector store

Add documents

Update documents

Delete documents

Search for documents

Search with Filters

Search with punctuation

Usage as retriever

Cosine Similarity Measure

Continue reading

RAG fundamentals

Conventional commits

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

Have you seen these projects?

Do you want to apply AI in your project? Contact me!

Do you want to improve with these tips?

DataLoader with pin_memory and num_workers

py-smi

Memory Calculator

Use this locally

Do you want to apply AI in your project? Contact me!

Do you want to train your model with these datasets?

short-jokes-dataset

opus100

netflix_titles