Ollama em LangChain - Integração com Python

breve

Este documento descreve como usar o Ollama O Ollama é uma ferramenta de implantação de código aberto para grandes modelos de linguagem, enquanto o LangChain é uma estrutura para a criação de aplicativos baseados em modelos de linguagem. Ao combinar os dois, podemos implementar e usar rapidamente modelos avançados de IA em um ambiente local.

Observação: este documento contém trechos do código principal e explicações detalhadas. O código completo pode ser encontrado na seçãoEste notebook JupyterEncontrado em.

1. configurações ambientais

Configuração do ambiente Conda

Primeiro, precisamos usar o ambiente Conda no Jupyter. Execute o seguinte comando na linha de comando:

conda create -n handlm python=3.10 -y
conda activate handlm
pip install jupyter
python -m ipykernel install --user --name=handlm

Após a execução, reinicie o Jupyter e selecione o Kernel para esse ambiente, conforme mostrado:

⚠️ Nota

Atenção: Também é possível usar o ambiente global diretamente sem o ambiente virtual conda.

Instalação de dependências

Antes de começarmos, precisamos instalar os seguintes pacotes:

• langchain-ollama: para integrar o modelo Ollama à estrutura LangChain
• langchainBiblioteca principal da LangChain, que fornece ferramentas e abstrações para a criação de aplicativos de IA
• langchain-communityInclui várias integrações e ferramentas contribuídas pela comunidade
• Pillowpara processamento de imagens, que é usado em tarefas multimodais
• faiss-cpu: para a construção de RAG retriever

Ele pode ser instalado com o seguinte comando:

pip install langchain-ollama langchain langchain-community Pillow faiss-cpu

2. faça o download dos modelos necessários e inicialize o OllamaLLM

Baixar o modelo llama3.1

1. Acesse o site oficial https://ollama.com/download para fazer o download e instalar o Ollama nas plataformas compatíveis disponíveis.
2. Acesse https://ollama.ai/library para ver todos os modelos disponíveis.
3. aprovar (um projeto de lei ou inspeção etc.) ollama pull <name-of-model> para obter os modelos LLM disponíveis (por exemplo:ollama pull llama3.1).

A linha de comando é executada conforme mostrado na figura:

Local de armazenamento do modelo:

• Mac. ~/.ollama/models/
• Linux (ou WSL). /usr/share/ollama/.ollama/models
• Windows. C:\Users\Administrator\.ollama\models

3. exemplos de uso básico

Conduzir uma conversa usando o ChatPromptTemplate

O ChatPromptTemplate nos permite criar um modelo reutilizável com um ou mais parâmetros. Esses parâmetros podem ser substituídos dinamicamente no tempo de execução para gerar prompts diferentes.

template = """
你是一个乐于助人的AI，擅长于解决回答各种问题。
问题：{question}
"""
prompt = ChatPromptTemplate.from_template(template)
chain = prompt | model
chain.invoke({"question": "你比GPT4厉害吗？"})

Na seção Criar cadeia, use o operador de pipe |Ele conecta o prompt ao modelo para formar um fluxo de processamento. Esse encadeamento facilita a combinação e a reutilização de diferentes componentes.

invoke aciona toda a cadeia de processamento, passando nossa pergunta para o modelo e, em seguida, enviando o prompt formatado para o modelo para processamento.

saída de streaming

A saída de fluxo contínuo é uma técnica que retorna resultados de forma incremental à medida que gera um texto longo. Esse método tem várias vantagens importantes:

1. Melhor experiência do usuário: os usuários podem ver os resultados parciais imediatamente, em vez de esperar a conclusão de toda a resposta.
2. Reduzir o tempo de espera: para respostas longas, os usuários podem começar a ler antes que a resposta completa seja gerada.
3. Interação em tempo real: permite a intervenção ou o encerramento durante o processo de geração.

Na prática, especialmente em chatbots ou sistemas de diálogo em tempo real, a saída de streaming é quase essencial.

from langchain_ollama import ChatOllama
model = ChatOllama(model="llama3.1", temperature=0.7)
messages = [
("human", "你好呀"),
]
for chunk in model.stream(messages):
print(chunk.content, end='', flush=True)

model.stream() é um wrapper em torno da Streaming Output Interface da API da Ollama, que retorna um objeto gerador. Ao chamar o método model.stream(messages) Quando você faz isso, as seguintes operações são concluídas:

• Envie uma solicitação para a API do Ollama para começar a gerar uma resposta.
• A API começa a gerar texto, mas, em vez de esperar até que todo o texto seja gerado, ela o retorna em pequenas partes.
• Para cada pequeno trecho de texto recebido, ostream() produz o bloco de texto.
• flush=True Certifique-se de que cada clipe seja exibido imediatamente, em vez de esperar que o buffer fique cheio.

Chamada de ferramenta

As chamadas de ferramenta são a capacidade de um modelo de IA de interagir com funções externas ou APIs. Isso permite que o modelo execute tarefas complexas, como cálculos matemáticos, consultas de dados ou chamadas de serviços externos.

def simple_calculator(operation: str, x: float, y: float) -> float:
'''实际的代码处理逻辑'''
llm = ChatOllama(
model="llama3.1",
temperature=0,
).bind_tools([simple_calculator])
result = llm.invoke("你知道一千万乘二是多少吗？")

bind_tools nos permite registrar uma função personalizada no modelo. Dessa forma, quando o modelo encontrar um problema que exija computação, ele poderá chamar essa função para obter resultados precisos, em vez de confiar em seu conhecimento de pré-treinamento.

Esse recurso é útil na criação de aplicativos complexos de IA, por exemplo:

• Crie chatbots que possam acessar dados em tempo real
• Crie assistentes inteligentes que executem tarefas específicas (por exemplo, reserva, consulta etc.)
• Desenvolvimento de sistemas de IA capazes de realizar cálculos precisos ou operações complexas

modelo multimodal

Os modelos multimodais são modelos de IA capazes de lidar com vários tipos de entrada (por exemplo, texto, imagens, áudio etc.). Esses modelos são excelentes para compreender e gerar conteúdo multimodal, permitindo interações homem-computador mais complexas e naturais.

Primeiro, é necessário fazer o download do modelo multimodal. Execute-o na linha de comando:

ollama pull llava

Em seguida, podemos usar o código a seguir para processar a imagem e a entrada de texto:

from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage
from langchain_core.output_parsers import StrOutputParser
llm = ChatOllama(model="llava", temperature=0)
def prompt_func(data):
'''构造多模态输入'''
chain = prompt_func | llm | StrOutputParser()
query_chain = chain.invoke(
{"text": "这个图片里是什么动物啊?", "image": image_b64}
)

O ponto principal aqui é:

1. Pré-processamento de imagem: precisamos converter a imagem em uma string codificada em base64.
2. Função de dica:prompt_func É criada uma entrada multimodal contendo texto e imagens.
3. Encadeamento: usamos | conecta a função de dica, o modelo e o analisador de saída.

Os modelos multimodais são úteis em muitos cenários, por exemplo:

• Geração de descrição da imagem
• sistema visual de perguntas e respostas
• Análise e recomendação de conteúdo com base em imagens

4. uso avançado

Conversa usando ConversationChain

ConversationChain é uma ferramenta avançada fornecida pela LangChain para gerenciar diálogos de várias rodadas. Ela combina modelos de linguagem, modelos de prompt e componentes na memória para facilitar a criação de sistemas de diálogo com reconhecimento de contexto.

memory = ConversationBufferMemory()
conversation = ConversationChain(
llm=model,
memory=memory,
verbose=True
)
# 进行对话
response = conversation.predict(input="你好，我想了解一下人工智能。")
print("AI:", response)
response = conversation.predict(input="能给我举个AI在日常生活中的应用例子吗？")
print("AI:", response)
response = conversation.predict(input="这听起来很有趣。AI在医疗领域有什么应用？")
print("AI:", response)

O principal componente aqui é:

1. ConversationBufferMemoryComponente de memória simples que armazena o histórico de todas as conversas anteriores.
2. ConversationChainModelo de linguagem: combina um modelo de linguagem, memória e um modelo de prompt de diálogo padrão.

Manter o histórico de diálogo é importante porque permite que os modelos:

• Compreensão do contexto e das informações mencionadas anteriormente
• Gerar respostas mais coerentes e relevantes
• Manuseio de cenários complexos de diálogo em várias rodadas

Na prática, talvez seja necessário considerar o uso de componentes de memória mais avançados, como ConversationSummaryMemorypara lidar com diálogos longos e evitar exceder o limite de comprimento do contexto do modelo.

Modelos personalizados de avisos

Modelos de prompt bem projetados são essenciais para a criação de aplicativos de IA eficientes. Neste exemplo, criamos um prompt complexo para gerar descrições de produtos:

system_message = SystemMessage(content="""
你是一位经验丰富的电商文案撰写专家。你的任务是根据给定的产品信息创作吸引人的商品描述。
请确保你的描述简洁、有力，并且突出产品的核心优势。
""")
human_message_template = """
请为以下产品创作一段吸引人的商品描述：
产品类型: {product_type}
核心特性: {key_feature}
目标受众: {target_audience}
价格区间: {price_range}
品牌定位: {brand_positioning}
请提供以下三种不同风格的描述，每种大约50字：
1. 理性分析型
2. 情感诉求型
3. 故事化营销型
"""
# 示例使用
product_info = {
"product_type": "智能手表",
"key_feature": "心率监测和睡眠分析",
"target_audience": "注重健康的年轻专业人士",
"price_range": "中高端",
"brand_positioning": "科技与健康的完美结合"
}

Há várias considerações importantes sobre o projeto dessa estrutura:

1. system_prompt: define as funções e as tarefas gerais da IA, estabelecendo o tom de todo o diálogo.
2. human_message_template: fornece a estrutura de instruções específicas e mensagens necessárias.
3. Design multiparâmetro: permite flexibilidade para se adaptar a diferentes produtos e requisitos.
4. Requisitos de diversidade de resultados: incentive os modelos a demonstrar sua diversidade exigindo diferentes estilos de descrição.

Considere o seguinte ao criar um modelo de prompt eficaz:

• Definir claramente o papel e a missão da IA
• Fornecer um formato de entrada claro e estruturado
• Contém requisitos específicos de saída e orientações de formatação
• Considere como maximizar a capacidade e a criatividade do modelo

Criação de um sistema simples de RAG Q&A

O RAG (Retrieval-Augmented Generation) é uma técnica de IA que combina recuperação e geração para aumentar a capacidade de resposta de um modelo de linguagem por meio da recuperação de informações relevantes:

1. Dividir os documentos da base de conhecimento em partes e criar índices vetoriais
2. Vetorizar o problema do usuário e recuperar documentos relevantes em um índice
3. Fornecer os documentos relevantes recuperados para o modelo de linguagem como contexto, juntamente com a pergunta original
4. O modelo de linguagem gera respostas com base nas informações recuperadas

A vantagem do RAG é que ele ajuda os modelos de linguagem a acessar informações atualizadas e especializadas, reduz as ilusões e melhora a precisão e a relevância das respostas.

A LangChain fornece uma variedade de componentes que podem ser perfeitamente integrados aos modelos Ollama. Aqui, mostraremos como usar o modelo Ollama em conjunto com um armazenamento de vetores e um retriever para criar um sistema simples de perguntas e respostas RAG.

A primeira coisa que você precisa fazer é garantir que o modelo de incorporação seja baixado, o que pode ser feito executando o seguinte comando na linha de comando:

ollama pull nomic-embed-text

Podemos então criar o sistema RAG:

# 初始化 Ollama 模型和嵌入
llm = ChatOllama(model="llama3.1")
embeddings = OllamaEmbeddings(model="nomic-embed-text")
# 准备文档
text = """
Datawhale 是一个专注于数据科学与 AI 领域的开源组织，汇集了众多领域院校和知名企业的优秀学习者，聚合了一群有开源精神和探索精神的团队成员。
Datawhale 以" for the learner，和学习者一起成长"为愿景，鼓励真实地展现自我、开放包容、互信互助、敢于试错和勇于担当。
同时 Datawhale 用开源的理念去探索开源内容、开源学习和开源方案，赋能人才培养，助力人才成长，建立起人与人，人与知识，人与企业和人与未来的联结。
如果你想在Datawhale开源社区发起一个开源项目，请详细阅读Datawhale开源项目指南[https://github.com/datawhalechina/DOPMC/blob/main/GUIDE.md]
"""
# 分割文本
text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)
chunks = text_splitter.split_text(text)
# 创建向量存储
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever()
# 创建提示模板
template = """只能使用下列内容回答问题:
{context}
Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
# 创建检索-问答链
chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
)
# 使用链回答问题
question = "我想为datawhale贡献该怎么做？"
response = chain.invoke(question)

Esse sistema RAG funciona da seguinte forma:

1. Segmentação de texto: uso RecursiveCharacterTextSplitter Dividir textos longos em partes menores.
2. Vetorização e indexação: usando OllamaEmbeddings Converte um bloco de texto em um vetor e cria um índice de vetor com FAISS.
3. Recuperação: quando uma pergunta é recebida, o sistema vetoriza a pergunta e recupera o bloco de texto mais relevante no índice FAISS.
4. Geração de respostas: os trechos de texto relevantes recuperados são fornecidos ao modelo de linguagem juntamente com a pergunta original para gerar a resposta final.

O sistema RAG é muito útil em muitos cenários da vida real, por exemplo:

• Atendimento ao cliente: as dúvidas dos clientes podem ser respondidas rapidamente com base no banco de conhecimentos da empresa.
• Auxílio à pesquisa: ajuda os pesquisadores a encontrar rapidamente a literatura relevante e a resumir as principais informações.
• Assistente pessoal: combina anotações pessoais e informações da Web para fornecer sugestões e recuperação de informações personalizadas.

chegar a um veredicto

Com esses exemplos, mostramos como usar o Ollama e o LangChain para criar uma variedade de aplicativos de IA, desde sistemas de diálogo simples até sistemas complexos de perguntas e respostas RAG. Essas ferramentas e técnicas oferecem uma base sólida para o desenvolvimento de aplicativos avançados de IA.

A combinação de Ollama e LangChain oferece aos desenvolvedores grande flexibilidade e possibilidades. Você pode escolher os modelos e componentes certos de acordo com suas necessidades específicas e criar um sistema de IA que se adapte ao cenário do seu aplicativo.

À medida que a tecnologia continua a evoluir, esperamos ver o surgimento de aplicativos mais inovadores. Esperamos que este guia o ajude a iniciar sua jornada de desenvolvimento de IA e inspire sua criatividade para explorar as infinitas possibilidades da tecnologia de IA.