Presente de los LLMs
Órganos internos de los LLMs
Conclusiones y perspectivas
Chatbots
Generación Aumentada con Recuperación (RAG)
Etiquetado
Extracción
Agentes
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!"})
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!"})
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!"})
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!"})
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!"})
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!"})
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?'
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?"})
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.'
https://hf.co/spaces/alonsosilva/BravuconGPT
https://talkativeai.streamlit.app/
Chatbots
Generación Aumentada con Recuperación (RAG)
Etiquetado
Extracción
Agentes
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?")
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?")
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?")
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?")
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')]
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?")
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')]
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?"})
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?"})
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?"})
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?"})
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?"})
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?"})
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?"})
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.'
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?"})
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.'
https://hf.co/spaces/alonsosilva/word2vec
https://hf.co/spaces/alonsosilva/embeddings
Chatbots
Generación Aumentada con Recuperación (RAG)
Etiquetado
Extracción
Agentes
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)]
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)]
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)]
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)]
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"})
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"})
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"})
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"})
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"})
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"})
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'}
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"})
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'}
Chatbots
Generación Aumentada con Recuperación (RAG)
Etiquetado
Extracción
Agentes
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)]
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)]
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)]
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)]
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)]
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"})
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"})
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"})
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"})
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"})
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"})
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}]
Chatbots
Generación Aumentada con Recuperación (RAG)
Etiquetado
Extracción
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)
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)
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)
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)
@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)
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
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
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
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
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
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
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
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']
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.'
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?'
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?'
https://math-solver.streamlit.app/
Let’s think step by step. Tell me about the livestock population in Turkey. Make a bar plot with these quantities.
Presente de los LLMs
Órganos internos de los LLMs
Conclusiones y perspectivas
https://hf.co/spaces/alonsosilva/tokenizer
https://picogpt.streamlit.app/
https://hf.co/spaces/alonsosilva/NextTokenPrediction
https://hf.co/spaces/alonsosilva/gpt2
https://shapllm.streamlit.app/
https://github.com/mattneary/attention
Presente de los LLMs
Órganos internos de los LLMs
Conclusiones y perspectivas
Presentación: https://github.com/alonsosilvaallende/PyCon_Chile_2023
Contáctame:
https://hf.co/spaces/alonsosilva/perplexity