Langchain com integrações de código aberto

16 de dezembro de 2024

Integrações de código aberto no Langchain

Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.

Uso de modelos de linguagem

Uso de modelos de Ollama

Como já vimos no post do Ollama, é um framework sobre llama.cpp que nos permite usar modelos de linguagem de maneira simples e também nos permite usar modelos quantizados. Vamos a ver como usar Qwen2.5 7B com Ollama no Langchain.

Antes de tudo, temos que instalar o módulo do Llama da Langchain

pip install -U langchain-ollama```

Baixar modelo

O primeiro passo é baixar o modelo qwen2.5:7b do Ollama. Usamos o de 7B para que qualquer pessoa com uma GPU possa utilizá-lo.

	
		!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

Modelos de chat

A primeira opção que temos para usar modelos de linguagem com Ollama em Langchain é usar a classe ChatOllama.

Criamos o objeto ChatOllama coo o modelo qwen2.5:7b.

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

Inferência offline

Agora fazemos inferência com o modelo de maneira offline, ou seja, sem usar streaming. Este método aguarda ter todo a resposta

	
		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

Inferência em tempo real

Se quisermos fazer streamig, podemos usar o 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,

Inserções

Se quisermos usar embeddings, podemos usar a classe OllamaEmbeddings.

Agora criamos o objeto OllamaEmbeddings cun modelo qwen2.5:7b.

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

Insira um único 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 vários 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])

LLNs

Se pode usar apenas un modelo de linguaxe utilizando a classe OllamaLLM.

Agora criamos o objeto OllamaLLM com o modelo qwen2.5:7b.

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

Inferência offline

Agora fazemos inferência com o modelo de maneira offline, ou seja, sem usar streaming. Este método espera ter todo a resposta

	
		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?

Inferência em streaming

Se quisermos fazer streaming, podemos usar o 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 do HuggingFace

Embora o Ollama seja muito fácil de usar, não tem tantos modelos quanto os existentes no Hub do HuggingFace. Além disso, é provável que não tenha o último grande modelo que você deseja usar, então vamos ver como usar modelos do HuggingFace no Langchain.

Antes de tudo, precisamos instalar o módulo do HuggingFace do Langchain

```markdown
      pip install -U langchain-huggingface

Primeiro precisamos nos logarmos no Hub do HuggingFace. Para isso, precisamos criar um token de acesso. Uma vez criado, o guardamos em um arquivo .env com o nome LANGCHAIN_TOKEN da seguinte maneira:

```echo "LANGCHAIN_TOKEN=hf_..." > .env```
      (Note que os enlaces e imagens não foram traduzidos.)```

Para poder ler o arquivo, instalamos o módulo python-dotenv.

```bash
      pip install python-dotenv

Agora nos logarmos no Hub do HuggingFace.

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

	
		from huggingface_hub import login
login(LANGCHAIN_TOKEN)

Modelos de chat

A primeira opção que temos para utilizar modelos de linguagem com o HuggingFace no Langchain é usar a classe HuggingFaceEndpoint. Esta opção chama a API do HuggingFace para fazer inferência.

Agora criamos o objeto chat_model com o 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)

Inferência offline

Agora fazemos inferência com o modelo de maneira offline, ou seja, sem usar streaming. Este método espera ter todo a resposta

	
		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.

Inferência em streaming

Se quisermos fazer streamings, podemos usar o método stream.

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

Embeddings

Embeddings em local

Se quisermos criar embeddings em local, podemos usar a classe HuggingFaceEmbeddings. Para isso precisamos ter instalada a biblioteca sentence-transformers.

pip install -U sentence-transformers```
      
      Podemos criar embeddings locais já agora

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

Se quisermos criar embeddings de vários textos, podemos usar o 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 em HuggingFace

Se quisermos usar a API do HuggingFace para crear embeddings, podemos usar a classe 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])

Se pode criar embeddings de varios textos usando o 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 criar um pipeline de Transformers e usá-lo em Langchain, para isso precisamos instalar o módulo transformers.

pip install -U transformers```
      
      Para garantizar que todos possam testar o exemplo, vamos a usar o modelo `Qwen/Qwen2.5-3B-Instruct`.

Temos duas maneiras, criar um pipeline mediante o 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

Podemos criar um pipeline através de 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

Inferência 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

Inferência em tempo real

	
		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 bancos de dados vetoriais

Uso do ChromaDB

Para poder usar o ChromaDB no o Langchain, primeiro temos que instalar langchain-chroma.

```pip install -qU chromadb langchain-chroma```
      Nota: Os comandos de terminal no se traducen.```

Criar um vetor 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,
)

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

Atualizar documentos

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

Apagar documentos

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

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

Busca com filtra

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

Busca com ponto

	
		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 recuperador

	
		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 similaridade por cosseno

Este método calcula a similaridade pelo cosseno entre dois vetores, portanto, em vez de passar duas strings, é necessário passar dois vetores.

Assim, primeiro criamos um 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)

E agora podemos calcular a similaridade pelo cosseno.

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

	
		array([[1.]])

Continuar lendo

Fundamentos de RAG

Esqueça o Ctrl+F! 🤯 Com RAG, seus documentos responderão às suas perguntas diretamente. 😎 Tutorial passo a passo com Hugging Face e ChromaDB. Liberte o poder da IA (e impressione seus amigos)! 💪

Conventional commits

😠 Seus commits parecem escritos em uma língua alienígena? 👽 Junte-se ao clube! 😅 Aprenda Conventional Commits em Python e pare de tortura sua equipe com mensagens enigmáticas. git-changelog e commitizen serão seus novos melhores amigos. 🤝

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

Você já conversou com um LLM e ele lhe respondeu algo que parece ter bebido café de máquina a noite toda? 😂 Isso é o que chamamos de alucinação no mundo dos LLMs! Mas não se preocupe, pois não é que seu modelo de linguagem esteja louco (embora às vezes possa parecer isso 🤪). A verdade é que os LLMs podem ser um pouco... criativos quando se trata de gerar texto. Mas graças ao DoLa, um método que usa camadas de contraste para melhorar a viabilidade dos LLMs, podemos evitar que nossos modelos de linguagem se transformem em escritores de ficção científica 😂. Nesta publicação, explicarei como o DoLa funciona e mostrarei um exemplo de código para que você possa entender melhor como tornar seus LLMs mais confiáveis e menos propensos a inventar histórias. Vamos salvar nossos LLMs da loucura e torná-los mais úteis! 🚀

Últimos posts -->

Você viu esses projetos?

Subtify

GPU monitor

Alfred

Ver todos os projetos -->

Quer aplicar IA no seu projeto? Entre em contato!

Quer melhorar com essas dicas?

DataLoader com pin_memory e num_workers

Aumentar o desempenho de DataLoader com pin_memory e num_workers

py-smi

Biblioteca Python para obter dados da GPU como `nvidia-smi`

Memory Calculator

Espaço para calcular a memória necessária para executar um modelo

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.

Flow edit

FLUX.1-RealismLora

token_hmr

Ver todos os contêineres -->

Quer aplicar IA no seu projeto? Entre em contato!

Você quer treinar seu modelo com esses datasets?

short-jokes-dataset

Dataset com piadas em inglês

opus100

Dataset com traduções de inglês para espanhol

netflix_titles

Dataset com filmes e séries da Netflix

Ver mais datasets -->

Integrações de código aberto no Langchain

Uso de modelos de linguagem

Uso de modelos de Ollama

Baixar modelo

Modelos de chat

Inferência offline

Inferência em tempo real

Inserções

Insira um único texto

Embed de vários textos

LLNs

Inferência offline

Inferência em streaming

Uso de modelos do HuggingFace

Login no o Hub do HuggingFace

Modelos de chat

Inferência offline

Inferência em streaming

Embeddings

Embeddings em local

Embeddings em HuggingFace

Pipeline

Inferência offline

Inferência em tempo real

Uso de bancos de dados vetoriais

Uso do ChromaDB

Criar um vetor store

Adicionar documentos

Atualizar documentos

Apagar documentos

Busca documentos

Busca com filtra

Busca com ponto

Uso como recuperador

Medida de similaridade por cosseno

Continuar lendo

Fundamentos de RAG

Conventional commits

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

Você viu esses projetos?

Quer aplicar IA no seu projeto? Entre em contato!

Quer melhorar com essas dicas?

DataLoader com pin_memory e num_workers

py-smi

Memory Calculator

Use isso localmente

Quer aplicar IA no seu projeto? Entre em contato!

Você quer treinar seu modelo com esses datasets?

short-jokes-dataset

opus100

netflix_titles