Ollama dans LangChain - Intégration Python

bref

Ce document décrit comment utiliser le Ollama Ollama est un outil de déploiement open source pour les grands modèles de langage, tandis que LangChain est un cadre pour la création d'applications basées sur des modèles de langage. En combinant les deux, nous pouvons rapidement déployer et utiliser des modèles d'IA avancés dans un environnement local.

Note : Ce document contient des extraits de code et des explications détaillées. Le code complet se trouve dans leCe carnet JupyterTrouvé dans.

1) Paramètres environnementaux

Configuration de l'environnement Conda

Tout d'abord, nous devons utiliser l'environnement Conda dans Jupyter. Exécutez la commande suivante dans la ligne de commande :

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

Après l'exécution, redémarrez Jupyter et sélectionnez le Kernel pour cet environnement comme indiqué :

⚠️ Note

Attention : Il est également possible d'utiliser l'environnement global directement sans l'environnement virtuel conda.

Installation des dépendances

Avant de commencer, nous devons installer les paquets suivants :

• langchain-ollama: pour l'intégration du modèle Ollama dans le cadre LangChain
• langchainLangChain : la bibliothèque de base de LangChain, qui fournit des outils et des abstractions pour la création d'applications d'intelligence artificielle.
• langchain-communityLe système de gestion de l'information de l'Union européenne (UE) : il comprend diverses intégrations et outils fournis par la communauté.
• Pillowle traitement de l'image, qui est utilisé dans les tâches multimodales
• faiss-cpuPour la construction d'un système simple RAG retriever

Il peut être installé à l'aide de la commande suivante :

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

2. télécharger les modèles requis et initialiser OllamaLLM

Télécharger le modèle llama3.1

1. Rendez-vous sur le site officiel https://ollama.com/download pour télécharger et installer Ollama sur les plates-formes compatibles disponibles.
2. Consultez le site https://ollama.ai/library pour connaître tous les modèles disponibles.
3. faire passer (un projet de loi, une inspection, etc.) ollama pull <name-of-model> pour obtenir les modèles LLM disponibles (par exemple :ollama pull llama3.1).

La ligne de commande est exécutée comme indiqué dans la figure :

Emplacement de stockage du modèle :

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

3. exemples d'utilisation de base

Mener une conversation à l'aide de ChatPromptTemplate

ChatPromptTemplate permet de créer un modèle réutilisable avec un ou plusieurs paramètres. Ces paramètres peuvent être remplacés dynamiquement lors de l'exécution pour générer différentes invites.

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

Dans la section Créer une chaîne, utilisez l'opérateur de tuyauterie |Il relie l'invite au modèle pour former un flux de traitement. Ce chaînage permet de combiner et de réutiliser facilement différents composants.

invoke déclenche l'ensemble de la chaîne de traitement, en passant notre question dans le modèle, puis en envoyant l'invite formatée au modèle pour qu'il la traite.

sortie en continu

La sortie en continu est une technique qui renvoie les résultats de manière incrémentielle au fur et à mesure qu'elle génère un texte long. Cette méthode présente plusieurs avantages importants :

1. Amélioration de l'expérience utilisateur : les utilisateurs peuvent voir des résultats partiels immédiatement, au lieu d'attendre que la réponse soit complète.
2. Réduire le temps d'attente : pour les réponses longues, les utilisateurs peuvent commencer à lire avant que la réponse complète ne soit générée.
3. Interaction en temps réel : permet d'intervenir ou de mettre fin au processus de génération.

Dans la pratique, en particulier dans les chatbots ou les systèmes de dialogue en temps réel, la sortie en continu est presque essentielle.

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() est une enveloppe autour de l'interface de sortie en continu de l'API Ollama, qui renvoie un objet générateur. Lors de l'appel de la méthode model.stream(messages) Les opérations suivantes sont alors effectuées :

• Envoyer une requête à l'API Ollama pour commencer à générer une réponse.
• L'API commence à générer du texte, mais au lieu d'attendre qu'il soit entièrement généré, elle le renvoie par petits morceaux.
• Pour chaque petit morceau de texte reçu, lestream() permet d'obtenir le bloc de texte.
• flush=True Veillez à ce que chaque clip soit affiché immédiatement, sans attendre que la mémoire tampon se remplisse.

Appel d'outil

Les appels d'outils sont la capacité d'un modèle d'IA à interagir avec des fonctions externes ou des API. Cela permet au modèle d'effectuer des tâches complexes telles que des calculs mathématiques, des requêtes de données ou des appels de services externes.

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 nous permet d'enregistrer une fonction personnalisée dans le modèle. Ainsi, lorsque le modèle rencontre un problème nécessitant un calcul, il peut appeler cette fonction pour obtenir des résultats précis, plutôt que de s'appuyer sur ses connaissances préalables à l'entraînement.

Cette capacité est utile lors de la création d'applications complexes d'intelligence artificielle, par exemple :

• Créer des chatbots capables d'accéder à des données en temps réel
• Créer des assistants intelligents qui effectuent des tâches spécifiques (par exemple, réservation, demande de renseignements, etc.)
• Développement de systèmes d'IA capables d'effectuer des calculs précis ou des opérations complexes

modèle multimodal

Ollama prend en charge les modèles multimodaux tels que bakllava et llava. Les modèles multimodaux sont des modèles d'IA capables de gérer plusieurs types d'entrées (par exemple, texte, images, audio, etc.). Ces modèles excellent dans la compréhension et la génération de contenus multimodaux, ce qui permet des interactions plus complexes et plus naturelles entre l'homme et l'ordinateur.

Tout d'abord, le modèle multimodal doit être téléchargé. Exécutez-le en ligne de commande :

ollama pull llava

Nous pouvons alors utiliser le code suivant pour traiter l'image et le texte saisis :

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

Le point clé est le suivant :

1. Prétraitement de l'image : nous devons convertir l'image en une chaîne encodée en base64.
2. Fonction de conseil :prompt_func Une entrée multimodale contenant du texte et des images est créée.
3. Chaînage : nous utilisons | relie la fonction d'indication, le modèle et l'analyseur de sortie.

Les modèles multimodaux sont utiles dans de nombreux scénarios, par exemple :

• Génération de descriptions d'images
• système visuel de questions-réponses
• Analyse et recommandation de contenu à partir d'images

4. utilisation avancée

Conversation utilisant la chaîne de conversation

ConversationChain est un outil puissant fourni par LangChain pour gérer les dialogues à plusieurs tours. Il combine des modèles linguistiques, des modèles d'invite et des composants en mémoire pour faciliter la création de systèmes de dialogue tenant compte du contexte.

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)

L'élément clé est le suivant :

1. ConversationBufferMemory: Il s'agit d'un simple composant en mémoire qui stocke l'historique de toutes les conversations précédentes.
2. ConversationChainIl combine un modèle linguistique, une mémoire et un modèle d'invite de dialogue par défaut.

Le maintien de l'historique du dialogue est important car il permet aux modèles :

• Comprendre le contexte et les informations mentionnées précédemment
• Générer des réponses plus cohérentes et plus pertinentes
• Gestion de scénarios complexes de dialogue à plusieurs tours

Dans la pratique, vous devrez peut-être envisager d'utiliser des composants de mémoire plus avancés, tels que la fonction ConversationSummaryMemorypour gérer les longs dialogues et éviter de dépasser la limite de longueur du contexte du modèle.

Modèles de messages personnalisés

Des modèles d'invite bien conçus sont essentiels pour créer des applications d'IA efficaces. Dans cet exemple, nous avons créé une invite complexe pour générer des descriptions de produits :

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": "科技与健康的完美结合"
}

Il y a plusieurs considérations importantes à prendre en compte lors de la conception de cette structure :

1. system_prompt : définit le rôle et la tâche générale de l'IA, en donnant le ton à l'ensemble du dialogue.
2. human_message_template : fournit la structure des instructions spécifiques et des messages requis.
3. Conception multiparamétrique : permet une adaptation souple à différents produits et exigences.
4. Diversité des exigences en matière de production : encourager les modèles à démontrer leur diversité en exigeant différents styles de description.

Tenez compte des éléments suivants lors de la conception d'un modèle d'invite efficace :

• Définir clairement le rôle et la mission de l'IA
• Fournir un format d'entrée clair et structuré
• Contient des exigences spécifiques en matière de production et des conseils de mise en forme
• Réfléchir à la manière de maximiser la capacité et la créativité du modèle

Création d'un système RAG Q&A simple

RAG (Retrieval-Augmented Generation) est une technique d'IA qui combine la recherche et la génération pour augmenter la capacité de réponse d'un modèle de langage en récupérant des informations pertinentes :

1. Découper les documents de la base de connaissances en morceaux et créer des index vectoriels
2. Vectoriser le problème de l'utilisateur et retrouver les documents pertinents dans un index.
3. Fournir les documents pertinents extraits au modèle de langage en tant que contexte avec la question d'origine
4. Le modèle linguistique génère des réponses basées sur les informations récupérées

L'avantage du RAG est qu'il aide les modèles linguistiques à accéder à des informations actualisées et spécialisées, réduit les désillusions et améliore la précision et la pertinence des réponses.

LangChain fournit une variété de composants qui peuvent être intégrés de manière transparente aux modèles Ollama. Nous montrerons ici comment utiliser le modèle Ollama en conjonction avec un magasin de vecteurs et un récupérateur pour créer un système simple de questions-réponses RAG.

La première chose à faire est de s'assurer que le modèle d'intégration est téléchargé, ce qui peut être fait en exécutant la commande suivante sur la ligne de commande :

ollama pull nomic-embed-text

Nous pouvons alors mettre en place le système 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)

Ce système RAG fonctionne de la manière suivante :

1. Segmentation du texte : utilisation RecursiveCharacterTextSplitter Diviser un texte long en morceaux plus petits.
2. Vectorisation et indexation : utiliser OllamaEmbeddings Convertit un bloc de texte en vecteur et crée un index vectoriel avec FAISS.
3. Récupération : lorsqu'une question est reçue, le système la vectorise et récupère le bloc de texte le plus pertinent dans l'index FAISS.
4. Génération de réponses : les morceaux de texte pertinents récupérés sont fournis au modèle de langage avec la question originale pour générer la réponse finale.

Le système RAG est très utile dans de nombreux scénarios de la vie réelle, par exemple :

• Service à la clientèle : les demandes des clients peuvent être traitées rapidement grâce à la base de connaissances de l'entreprise.
• Aide à la recherche : aide les chercheurs à trouver rapidement la documentation pertinente et à résumer les informations clés.
• Assistant personnel : combine des notes personnelles et des informations sur le web pour fournir une recherche d'informations et des suggestions personnalisées.

rendre un verdict

Avec ces exemples, nous montrons comment utiliser Ollama et LangChain pour construire une variété d'applications d'IA, allant de simples systèmes de dialogue à des systèmes complexes de Q&R RAG. Ces outils et techniques constituent une base solide pour le développement d'applications d'IA puissantes.

La combinaison d'Ollama et de LangChain offre aux développeurs une grande flexibilité et de nombreuses possibilités. Vous pouvez choisir les bons modèles et composants en fonction de vos besoins spécifiques et construire un système d'IA adapté à votre scénario d'application.

Au fur et à mesure que la technologie continue d'évoluer, nous nous attendons à voir émerger de nouvelles applications innovantes. Nous espérons que ce guide vous aidera à vous lancer dans le développement de l'IA et inspirera votre créativité pour explorer les possibilités infinies de la technologie de l'IA.