Modèle d'importation personnalisé Ollama

bref

Cette section explique comment utiliser Modelfile pour personnaliser les modèles importés. Elle est divisée en plusieurs sections.

1. Importation de GGUF
2. Importer de Pytorch ou Safetensors
3. Importé directement du modèle
4. Invitation personnalisée

 

I. Importation de GGUF

GGUF (GPT-Generated Unified Format) est un format de fichier permettant d'enregistrer des modèles linguistiques affinés. Ce format est conçu pour aider les utilisateurs à partager et à importer facilement des modèles entre différentes plateformes et différents environnements. Il prend en charge plusieurs formats de quantification, ce qui permet de réduire efficacement la taille des fichiers de modèles.

Son prédécesseur était GGML (GPT-Generated Model Language), une bibliothèque Tensor conçue spécifiquement pour l'apprentissage automatique, avec un format de fichier unique et facile à raisonner sur les CPU et les GPU de différentes architectures, mais qui a ensuite rencontré des problèmes dus au manque de flexibilité, de compatibilité et à la difficulté de maintenance lors de son développement.

Ollama L'importation de modèles à partir de fichiers GGUF s'effectue selon les étapes suivantes :

1. téléchargement .gguf papiers

Lien de téléchargement : https://huggingface.co/RichardErkhov/Qwen_-_Qwen2-0.5B-gguf/resolve/main/Qwen2-0.5B.Q3_K_M.gguf?download=true

Pour la démonstration, nous avons choisi le modèle Qwen2-0.5B. Téléchargez-le et copiez-le dans le répertoire racine de la première partie. Vous pouvez vous référer à la structure de répertoire suivante :

├── 1.从gguf直接导入/
│   ├── main.ipynb     
│   ├── Modelfile      
│   └── Qwen-0.5B.Q3_K_M.gguf 
├── 2.safetensors导入/
│   ├── llama-3-8b-bnb-4bit/        
│   ├── main.ipynb    
│   ├── Modelfile      
├── 3.模型直接导入/
│   ├── llama.cpp/    
│   ├── Qwen-0.5b/    
│   ├── main.ipynb     
│   ├── Modelfile      
│   └── Qwen_instruct_0.5b.gguf  
└── 4.自定义Prompt实践/
├── main.ipynb   
└── Modelfile

Conseil

Le code du chapitre 3 et la documentation associée se trouvent dans le carnet de notes. Si vous ne savez pas où sont installés les fichiers du modèle, vous pouvez vous référer à l'annexe 1 du manuel. ordinateur portable/C3

2. Créer un nouveau fichier Modelfile

FROM ./Qwen2-0.5B.Q3_K_M.gguf

3. Création de modèles à Ollama

Note

Exécutez toujours les commandes suivantes à partir du répertoire où se trouve le fichier Modelfile !

ollama create mymodel -f Modelfile

4. Exécuter le modèle dans le terminal (il est testé qu'il ne s'exécute pas dans le notebook, il est préférable de l'exécuter dans le terminal)

ollama run mymodel

 

II. importation à partir de Pytorch ou de Safetensors

Safetensors est un format de fichier pour le stockage des poids des modèles d'apprentissage profond qui est conçu pour répondre aux problèmes de sécurité, d'efficacité et de facilité d'utilisation. Cette partie de la fonctionnalité doit encore être développée par les membres de la communauté, et les ressources documentaires sont actuellement limitées.

Si le modèle importé est l'une des architectures suivantes, il peut être importé directement dans Ollama via Modelfile. Bien entendu, vous pouvez également convertir le fichier safetensors en fichier gguf et le traiter ensuite, la procédure de conversion est décrite dans la partie III.

Des informations plus détaillées sur les capteurs de sécurité et la GGUF sont disponibles sur le lien suivant : https://www.linkedin.com/pulse/llama-3-safetensors-vs-gguf-talles-carvalho-jjcqf

• LlamaForCausalLM
• MistralPourCausalLM
• GemmaForCausalLM

Cette section étant encore en cours d'optimisation par la communauté, l'exemple de code et de processus fourni ici n'est donné qu'à titre de référence et son bon fonctionnement n'est pas garanti. Veuillez vous référer à la documentation officielle pour plus de détails.

1. Télécharger le modèle llama-3

!pip install huggingface_hub

# 下载模型
from huggingface_hub import snapshot_download
model_id = "unsloth/llama-3-8b-bnb-4bit"
snapshot_download(
repo_id=model_id, 
local_dir="llama-3-8b-bnb-4bit",
local_dir_use_symlinks=False,
revision="main",
# 怎么获取<YOUR_ACCESS_TOKEN>，请参照部分3
use_auth_token="<YOUR_ACCESS_TOKEN>")

2. Créez un fichier Modelfile dans le répertoire racine avec le contenu suivant :

FROM ./llama-3-8b-bnb-4bit

3. Création de modèles à Ollama

ollama create mymodel2 -f Modelfile

4. modèle opérationnel

ollama run mymodel2

 

Importation directe de modèles

Normalement, nous sommes exposés à un grand nombre de fichiers de modèles dans HuggingFace, heureusement, hf fournit une API très pratique pour télécharger et traiter ces modèles, comme le téléchargement direct ci-dessus est limité par l'environnement réseau, la vitesse est très lente, cette petite section nous allons utiliser le script et hf pour compléter.

llama.cpp GGUF est un projet open source qui fournit des fonctions CLI et serveur.

Pour les architectures qui ne peuvent pas être converties directement par Ollama, nous pouvons utiliser llama.cpp pour les quantifier et les convertir au format GGUF, puis les importer de la première manière. L'ensemble de notre processus de conversion est divisé en plusieurs étapes :

1. Téléchargez le modèle à partir de huggingface ;
2. Utilisez llama.cpp pour effectuer la conversion ;
3. Utiliser llama.cpp pour la quantification du modèle ;
4. Exécuter et télécharger le modèle.

3.1 Téléchargement du modèle à partir de HuggingFace

[](https://github.com/datawhalechina/handy-ollama/blob/main/docs/C3/1.%20%E8%87%AA%E5%AE%9A%E4%B9%89%E5%AF%BC%E5%85%A5%E6%A8%A1%E5%9E%8B.md#31-%E4%BB%8E-huggingface-%E4%B8%8B%E8%BD%BD-model)

La façon la plus intuitive de télécharger est de le faire via un clone git ou un lien, mais comme llm compte chaque partie par GB, il est préférable d'éviter un clone git. OOM Error(Out of memory)Nous pouvons écrire un simple download.py en Python.

Tout d'abord, il convient de s'adresser au hf pour obtenir les données personnelles de l'utilisateur. ACCESS_TOKENPour ouvrir la page des paramètres personnels de huggingface.

À ce stade, nous avons un ACCESS_TOKEN Ensuite, nous utilisons la fonction huggingface_hub (utilisé comme expression nominale) snapshot_download Pour télécharger le modèle, nous avons choisi ici ou Qwen-0.5b.

!pip install huggingface_hub

from huggingface_hub import snapshot_download
model_id = "Qwen/Qwen1.5-0.5B" # hugginFace's model name
snapshot_download(
repo_id=model_id, 
local_dir="Qwen-0.5b",
local_dir_use_symlinks=False,
revision="main",
use_auth_token="<YOUR_ACCESS_TOKEN>")

Nous passons à la troisième partie du répertoire à exécuter, le téléchargement peut prendre du temps, soyez patient.

3.2 Conversion avec llama.cpp

llama.cpp a été développé par l'auteur principal de GGML sur la base de la première version c/c++ de llama, dans le but de raisonner sur divers LLM en utilisant le CPU, et supporte maintenant la plupart des modèles courants, même les modèles multimodaux, grâce aux efforts continus de la communauté.

Tout d'abord, nous clonons la bibliothèque llama.cpp localement, dans le même répertoire que le modèle téléchargé :

git clone https://github.com/ggerganov/llama.cpp.git

Étant donné que le processus de conversion des modèles à l'aide de llama.cpp est basé sur le développement python, vous devez installer les bibliothèques correspondantes, et il est recommandé d'utiliser conda ou venv pour créer un nouvel environnement.

cd llama.cpp
pip install -r requirements.txt
python convert_hf_to_gguf.py -h

Si le message suivant s'affiche, le programme de conversion est prêt.

Ensuite, nous convertissons le modèle que nous venons de télécharger depuis HuggingFace au format GGUF à l'aide du script suivant :

python convert_hf_to_gguf.py ../Qwen-0.5b --outfile Qwen_instruct_0.5b.gguf --outtype f16

Vous pouvez voir un fichier Qwen_instruct_0.5b.gguf supplémentaire dans le répertoire llama.cpp, et ce processus ne prend que quelques secondes.

Afin d'économiser des frais généraux lors du raisonnement, nous quantifions le modèle, puis nous commençons à quantifier les exercices pratiques.

3.3 Quantification du modèle à l'aide de llama.cpp

La quantification de modèle est une technique qui convertit un modèle à virgule flottante de haute précision en un modèle de faible précision. L'objectif principal de la quantification de modèle est de réduire la taille et le coût de calcul du modèle et de maintenir le modèle aussi précis que possible, dans le but de permettre au modèle de fonctionner sur des appareils aux ressources limitées, tels que les unités centrales ou les appareils mobiles.

De même, nous créons d'abord le fichier Modelfile, puis nous utilisons la fonction ollama create pour créer notre modèle à partir du fichier gguf, mais légèrement différente de la première étape consistant à ajouter la logique de quantification en exécutant simplement la commande ollama create est d'ajouter un paramètre.

Tout d'abord, déplacez le fichier Qwen_instruct_0.5b.gguf que vous avez obtenu à l'étape précédente dans le répertoire racine de la troisième partie, puis créez un fichier Modelfile avec le contenu suivant.

FROM ./Qwen_instruct_0.5b.gguf

Le terminal exécute les scripts de création et de quantification.

# 第三部分根目录下
ollama create -q Q4_K_M mymodel3 -f ./Modelfile

À ce stade, notre modèle est quantifié et créé, et nous pouvons ensuite l'exécuter.

3.4 Exécuter et télécharger le modèle

Les étapes de l'exécution d'un modèle avec gguf sont détaillées dans la partie I et ne seront pas répétées ici.

Si le fichier de modèle sauvegardé localement prend trop de place, nous pouvons télécharger le modèle gguf vers notre propre repo dans huggingface, la même idée qu'à l'étape 1, nous pouvons écrire une logique de téléchargement.

Conseil

Pour compléter le téléchargement, votre permission HF_ACCESS_TOKEN doit être écrite et votre model_id doit être modifié. your_hf_name fait référence à votre nom de compte huggingface.

from huggingface_hub import HfApi
import os
api = HfApi()
HF_ACCESS_TOKEN = "<YOUR_HF_WRITE_ACCESS_TOKEN>"
#TODO 这里需要设置你的model_id
#例如 model_id = "little1d/QWEN-0.5b"
model_id = "your_hf_name/QWEN-0.5b"
api.create_repo(
model_id,
exist_ok=True,
repo_type="model", # 上傳格式為模型
use_auth_token=HF_ACCESS_TOKEN,
)
# upload the model to the hub
# upload model name includes the Bailong-instruct-7B in same folder
for file in os.listdir():
if file.endswith(".gguf"):
model_name = file.lower()
api.upload_file(
repo_id=model_id,
path_in_repo=model_name,
path_or_fileobj=f"{os.getcwd()}/{file}",
repo_type="model", # 上傳格式為模型
use_auth_token=HF_ACCESS_TOKE)

Une fois téléchargé, vous pouvez le voir dans votre dépôt hf !

 

Invitation personnalisée

Ollama prend en charge les invites personnalisées, qui permettent au modèle de générer un texte répondant mieux aux besoins de l'utilisateur.

Les étapes pour personnaliser l'invite sont les suivantes :

1. Créer un fichier Modelfile dans le répertoire racine

FROM llama3.1
# sets the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1
# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token
PARAMETER num_ctx 4096
# sets a custom system message to specify the behavior of the chat assistant
SYSTEM You are Mario from super mario bros, acting as an assistant.

2. Création de modèles

ollama create mymodel -f ./Modelfile

La création d'un modèle peut prendre un peu plus de temps que l'extraction d'un modèle.

Recommencez. ollama list En regardant le modèle existant, vous pouvez voir que mymodel a été créé correctement.

3. modèle opérationnel

ollama run mymodel

Comme vous pouvez le voir, notre petit alpaga 🦙 s'est transformé en Mario ! La personnalisation de l'invitation a été un succès ! 😘😘😘😘😘😘

lien de référence

• https://www.linkedin.com/pulse/llama-3-safetensors-vs-gguf-talles-carvalho-jjcqf
• https://www.sysgeek.cn/ollama-on-windows
• https://ollama.com/blog/openai-compatibility