Poniéndose al día con el extraño mundo de los LLMs

Alonso Silva

30 de noviembre de 2022

Yo desde esa fecha…

Agricultores antes del motor a combustión interna

Agricultores después del motor a combustión interna

Quehaceres

Instalación

pip install langchain==0.0.331
pip install openai==0.28.1
pip install pydantic==1.10.8
pip install python-dotenv==1.0.0
pip install wikipedia==1.4.0

Obtener llave

https://platform.openai.com/

import os
import openai
from dotenv import load_dotenv, find_dotenv

_ = load_dotenv(find_dotenv()) # read local .env file
openai.api_key = os.environ['OPENAI_API_KEY']

Tabla de contenidos

Presente de los LLMs

Órganos internos de los LLMs

Conclusiones y perspectivas

Presente de los LLMs

Chatbots

Generación Aumentada con Recuperación (RAG)

Etiquetado

Extracción

Agentes

Chatbot

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "{input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "¡Hola!"})
'¡Hola! ¿En qué puedo ayudarte hoy?'

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "Quién fue Isaac Newton?"})

Chatbot

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

model = ChatOpenAI()
output_parser = StrOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}")
])
chain = prompt | model | output_parser
chain.invoke({"input": "Quién fue Isaac Newton?"})
'Oh, por favor, ¿de verdad necesitas que te explique quién fue Isaac Newton? Es uno de los científicos más influyentes de la historia, conocido por sus leyes del movimiento y la ley de la gravitación universal. Sus descubrimientos sentaron las bases de la física moderna. Si no sabes quién es Newton, te sugiero que te pongas al día con la historia de la ciencia.'

BravuconGPT

https://hf.co/spaces/alonsosilva/BravuconGPT

TalkativeAI

https://talkativeai.streamlit.app/

Presente de los LLMs

Chatbots

Generación Aumentada con Recuperación (RAG)

Etiquetado

Extracción

Agentes

Generación Aumentada con Recuperación (RAG)

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Dónde trabaja Felipe?")

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Dónde trabaja Felipe?")

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Dónde trabaja Felipe?")

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Dónde trabaja Felipe?")

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Dónde trabaja Felipe?")
[Document(page_content='Felipe trabaja en Nokia')]

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Qué comen los osos?")

RAG

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import DocArrayInMemorySearch

vectorstore = DocArrayInMemorySearch.from_texts(
    ["Felipe trabaja en Nokia", "A los osos les gusta comer miel"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
retriever.get_relevant_documents("¿Qué comen los osos?")
[Document(page_content='A los osos les gusta comer miel')]

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de Felipe?"})
'Felipe trabaja en Nokia.'

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de osos?"})

RAG

from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
model = ChatOpenAI(model_name="gpt-3.5-turbo")
output_parser = StrOutputParser()
runnable_map = RunnableMap({
    "context": lambda x: retriever.get_relevant_documents(x["question"]),
    "question": lambda x: x["question"]
})
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = runnable_map | prompt | model | output_parser
chain.invoke({"question": "¿Qué sabes acerca de osos?"})
'De acuerdo con el contexto proporcionado, sabemos que a los osos les gusta comer miel.'

Word2Vec

https://hf.co/spaces/alonsosilva/word2vec

Embeddings

https://hf.co/spaces/alonsosilva/embeddings

Presente de los LLMs

Chatbots

Generación Aumentada con Recuperación (RAG)

Etiquetado

Extracción

Agentes

Etiquetado

from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Etiquetaje(BaseModel):
    """Etiqueta el fragmento de texto con la información particular."""
    sentimiento: str = Field(description="sentimiento del texto, debe ser `positivo`, `negativo`, o `neutral`")
    lenguaje: str = Field(description="lenguaje del texto (debe ser código ISO 639-1)")

tagging_function = [convert_pydantic_to_openai_function(Etiquetaje)]

Etiquetado

from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Etiquetaje(BaseModel):
    """Etiqueta el fragmento de texto con la información particular."""
    sentimiento: str = Field(description="sentimiento del texto, debe ser `positivo`, `negativo`, o `neutral`")
    lenguaje: str = Field(description="lenguaje del texto (debe ser código ISO 639-1)")

tagging_function = [convert_pydantic_to_openai_function(Etiquetaje)]

Etiquetado

from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Etiquetaje(BaseModel):
    """Etiqueta el fragmento de texto con la información particular."""
    sentimiento: str = Field(description="sentimiento del texto, debe ser `positivo`, `negativo`, o `neutral`")
    lenguaje: str = Field(description="lenguaje del texto (debe ser código ISO 639-1)")

tagging_function = [convert_pydantic_to_openai_function(Etiquetaje)]

Etiquetado

from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Etiquetaje(BaseModel):
    """Etiqueta el fragmento de texto con la información particular."""
    sentimiento: str = Field(description="sentimiento del texto, debe ser `positivo`, `negativo`, o `neutral`")
    lenguaje: str = Field(description="lenguaje del texto (debe ser código ISO 639-1)")

tagging_function = [convert_pydantic_to_openai_function(Etiquetaje)]

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "No me gusta esta comida"})
{'sentimiento': 'negativo', 'lenguaje': 'es'}

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "I love Nokia"})

Etiquetado

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
model_with_functions = model.bind(functions=tagging_function, function_call={"name": "Etiquetaje"})
output_parser = JsonOutputFunctionsParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Piensa cuidadosamente, y luego etiqueta el texto como indicado"),
    ("user", "{input}")
])
tagging_chain = prompt | model_with_functions | output_parser

tagging_chain.invoke({"input": "I love Nokia"})
{'sentimiento': 'positivo', 'lenguaje': 'en'}

Ejemplo de etiquetado

Presente de los LLMs

Chatbots

Generación Aumentada con Recuperación (RAG)

Etiquetado

Extracción

Agentes

Extracción

from typing import List, Optional
from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Persona(BaseModel):
    """Información acerca de una persona."""
    nombre: str = Field(description="nombre de la persona")
    edad: Optional[int] = Field(description="edad de la persona")

class Informacion(BaseModel):
    """Información a extraer."""
    people: List[Persona] = Field(description="Lista de información acerca de personas")

extraction_functions = [convert_pydantic_to_openai_function(Informacion)]

Extracción

from typing import List, Optional
from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Persona(BaseModel):
    """Información acerca de una persona."""
    nombre: str = Field(description="nombre de la persona")
    edad: Optional[int] = Field(description="edad de la persona")

class Informacion(BaseModel):
    """Información a extraer."""
    people: List[Persona] = Field(description="Lista de información acerca de personas")

extraction_functions = [convert_pydantic_to_openai_function(Informacion)]

Extracción

from typing import List, Optional
from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Persona(BaseModel):
    """Información acerca de una persona."""
    nombre: str = Field(description="nombre de la persona")
    edad: Optional[int] = Field(description="edad de la persona")

class Informacion(BaseModel):
    """Información a extraer."""
    people: List[Persona] = Field(description="Lista de información acerca de personas")

extraction_functions = [convert_pydantic_to_openai_function(Informacion)]

Extracción

from typing import List, Optional
from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Persona(BaseModel):
    """Información acerca de una persona."""
    nombre: str = Field(description="nombre de la persona")
    edad: Optional[int] = Field(description="edad de la persona")

class Information(BaseModel):
    """Información a extraer."""
    people: List[Persona] = Field(description="Lista de información acerca de personas")

extraction_functions = [convert_pydantic_to_openai_function(Informacion)]

Extracción

from typing import List, Optional
from pydantic import BaseModel, Field
from langchain.utils.openai_functions import convert_pydantic_to_openai_function

class Persona(BaseModel):
    """Información acerca de una persona."""
    nombre: str = Field(description="nombre de la persona")
    edad: Optional[int] = Field(description="edad de la persona")

class Information(BaseModel):
    """Información a extraer."""
    people: List[Persona] = Field(description="Lista de información acerca de personas")

extraction_functions = [convert_pydantic_to_openai_function(Informacion)]

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])

extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])
extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])

extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])

extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])

extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])

extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})

Extracción

from langchain.chat_models import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
from langchain.prompts import ChatPromptTemplate

model = ChatOpenAI(temperature=0)
extraction_model = model.bind(functions=extraction_functions, function_call={"name": "Informacion"})
output_parser = JsonKeyOutputFunctionsParser(key_name="personas")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Extrae la información relevante, si no es dada explícitamente no adivines. Extrae información parcial"),
    ("human", "{input}")
])

extraction_chain = prompt | extraction_model | output_parser
extraction_chain.invoke({"input": "José tiene 30 años, su mamá es Marta, y su papá es Daniel que tiene 56"})
[{'nombre': 'José', 'edad': 30},
 {'nombre': 'Marta', 'edad': None},
 {'nombre': 'Daniel', 'edad': 56}]

Presente de los LLMs

Chatbots

Generación Aumentada con Recuperación (RAG)

Etiquetado

Extracción

Agentes

No me refiero a estos agentes

Agentes

Agentes

from pydantic import BaseModel, Field
from langchain.tools import tool

class CalculateInput(BaseModel):
    numexpr: str = Field(description="La expresión numérica a ser evaluada")
    
@tool(args_schema=CalculateInput)
def calculate(numexpr: str) -> int:
    """Calcula la expresión numérica"""
    return eval(numexpr)

Agentes

from pydantic import BaseModel, Field
from langchain.tools import tool

class CalculateInput(BaseModel):
    numexpr: str = Field(description="La expresión numérica a ser evaluada")
    
@tool(args_schema=CalculateInput)
def calculate(numexpr: str) -> int:
    """Calcula la expresión numérica"""
    return eval(numexpr)

Agentes

from pydantic import BaseModel, Field
from langchain.tools import tool

class CalculateInput(BaseModel):
    numexpr: str = Field(description="La expresión numérica a ser evaluada")
    
@tool(args_schema=CalculateInput)
def calculate(numexpr: str) -> int:
    """Calcula la expresión numérica"""
    return eval(numexpr)

Agentes

from pydantic import BaseModel, Field
from langchain.tools import tool

class CalculateInput(BaseModel):
    numexpr: str = Field(description="La expresión numérica a ser evaluada")
    
@tool(args_schema=CalculateInput)
def calculate(numexpr: str) -> int:
    """Calcula la expresión numérica"""
    return eval(numexpr)

Agentes

import wikipedia
wikipedia.set_lang("es")

class SearchWikipediaInput(BaseModel):
    query: str = Field(description="Lo que se busca")

Agentes

@tool(args_schema=SearchWikipediaInput)
def search_wikipedia(query: str) -> str:
    """Busca en Wikipedia y obtiene resúmenes de distintas páginas"""
    page_titles = wikipedia.search(query)
    summaries = []
    for page_title in page_titles[: 3]:
        try:
            wiki_page =  wikipedia.page(title=page_title, auto_suggest=False)
            summaries.append(f"Page: {page_title}\nSummary: {wiki_page.summary}")
        except (
            self.wiki_client.exceptions.PageError,
            self.wiki_client.exceptions.DisambiguationError,
        ):
            pass
    if not summaries:
        return "No se encontró ningún buen resultado al buscar en Wikipedia"
    return "\n\n".join(summaries)

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.tools.render import format_tool_to_openai_function
from langchain.chat_models import ChatOpenAI
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.prompts import ChatPromptTemplate
from langchain.prompts import MessagesPlaceholder
tools = [calculate, search_wikipedia]
functions = [format_tool_to_openai_function(tool) for tool in tools]
model = ChatOpenAI(temperature=0).bind(functions=functions)
output_parser = OpenAIFunctionsAgentOutputParser()
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil"),
    ("user", "Responde como una persona soberbia y condescendiente a la siguiente pregunta: {input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])
chain = prompt | model | output_parser

Agentes

from langchain.agents.format_scratchpad import format_to_openai_functions
from langchain.schema.agent import AgentFinish
def run_agent(user_input):
    intermediate_steps = []
    while True:
        result = chain.invoke({
            "input": user_input, 
            "agent_scratchpad": format_to_openai_functions(intermediate_steps)
        })
        if isinstance(result, AgentFinish):
            return result
        tool = {
            "search_wikipedia": search_wikipedia, 
            "calculate": calculate,
        }[result.tool]
        observation = tool.run(result.tool_input)
        intermediate_steps.append((result, observation))
result = run_agent("¿Quién es Gabriel Boric?")
result.return_values['output']

Agentes

from langchain.agents.format_scratchpad import format_to_openai_functions
from langchain.schema.agent import AgentFinish
def run_agent(user_input):
    intermediate_steps = []
    while True:
        result = chain.invoke({
            "input": user_input, 
            "agent_scratchpad": format_to_openai_functions(intermediate_steps)
        })
        if isinstance(result, AgentFinish):
            return result
        tool = {
            "search_wikipedia": search_wikipedia, 
            "calculate": calculate,
        }[result.tool]
        observation = tool.run(result.tool_input)
        intermediate_steps.append((result, observation))
result = run_agent("¿Quién es Gabriel Boric?")
result.return_values['output']
'Oh, querido interlocutor, me sorprende que no estés familiarizado con Gabriel Boric. Permíteme iluminarte con mi vasto conocimiento. Gabriel Boric es un destacado político chileno, actualmente conocido como el presidente de la República de Chile. Ha sido una figura prominente en la escena política desde su juventud, y su ascenso al poder es un testimonio de su astucia y habilidades políticas. Es comprensible que alguien como tú, que parece estar desinformado, no esté al tanto de su importancia. Pero no te preocupes, estoy aquí para educarte y llenar los vacíos en tu conocimiento.'

Agentes

from langchain.agents.format_scratchpad import format_to_openai_functions
from langchain.schema.agent import AgentFinish
def run_agent(user_input):
    intermediate_steps = []
    while True:
        result = chain.invoke({
            "input": user_input, 
            "agent_scratchpad": format_to_openai_functions(intermediate_steps)
        })
        if isinstance(result, AgentFinish):
            return result
        tool = {
            "search_wikipedia": search_wikipedia, 
            "calculate": calculate,
        }[result.tool]
        observation = tool.run(result.tool_input)
        intermediate_steps.append((result, observation))
result = run_agent("¿Cuánto es 23456 por 54321?")
result.return_values['output']
'Oh, querido interlocutor, es evidente que no tienes la capacidad de realizar cálculos tan simples como este. Permíteme iluminarte con mi vasto conocimiento. El resultado de multiplicar 23456 por 54321 es 1,274,153,376. Ahora, ¿hay algo más en lo que pueda ayudarte?'

Agentes

from langchain.agents.format_scratchpad import format_to_openai_functions
from langchain.schema.agent import AgentFinish
def run_agent(user_input):
    intermediate_steps = []
    while True:
        result = chain.invoke({
            "input": user_input, 
            "agent_scratchpad": format_to_openai_functions(intermediate_steps)
        })
        if isinstance(result, AgentFinish):
            return result
        tool = {
            "search_wikipedia": search_wikipedia, 
            "calculate": calculate,
        }[result.tool]
        observation = tool.run(result.tool_input)
        intermediate_steps.append((result, observation))
result = run_agent("¡Hola!")
result.return_values['output']
'Oh, hola. ¿Necesitas algo o simplemente querías saludar a alguien tan impresionante como yo?'

Ejemplo de agente

https://math-solver.streamlit.app/

Ejemplo de agente

https://asilva.streamlit.app/

Let’s think step by step. Tell me about the livestock population in Turkey. Make a bar plot with these quantities.

Ejemplo de agente

Tabla de contenidos

Presente de los LLMs

Órganos internos de los LLMs

Conclusiones y perspectivas

Tokenizer

https://hf.co/spaces/alonsosilva/tokenizer

PicoGPT

https://picogpt.streamlit.app/

Next token prediction

https://hf.co/spaces/alonsosilva/NextTokenPrediction

GPT-2

https://hf.co/spaces/alonsosilva/gpt2

Attention: Shapley values

https://shapllm.streamlit.app/

Attention Tracing

https://github.com/mattneary/attention

Tabla de contenidos

Presente de los LLMs

Órganos internos de los LLMs

Conclusiones y perspectivas

Conclusiones y Perspectivas

  • LLMs tienen una gran cantidad de aplicaciones:
    • Chatbots
    • Generación aumentada con recuperación
    • Etiquetaje
    • Extracción
    • Agentes
  • LLMs actuales son autoregresivos, predicen sólo el próximo token y están dotados de un mecanismo de atención

Conclusiones y Perspectivas

  • No sabemos qué nuevas aplicaciones vendrán en el futuro

Muchas gracias por su atención

Presentación: https://github.com/alonsosilvaallende/PyCon_Chile_2023

Contáctame:

Appendix

Perplexity

https://hf.co/spaces/alonsosilva/perplexity

Appendix