Dans de précédents articles je vous ai expliqué comment mettre en œuvre l’IA sur le Raspberry Pi 5 : Module Hailo-8L, module Coral TPU, TensorFlow… Récemment un article de Nurgaliyev Shakhizat sur Hackster.io m’a intéressé et (avec son autorisation), je vous en propose la traduction. Vous découvrirez comment installer votre propre ChatGPT sans connexion à Internet.

Faites tourner un LLM de type ChatGPT sur le Raspberry Pi 5

Dans ce tutoriel, je vais montrer, sur la base de l’article paru dans Hackster.io,  comment exécuter un grand modèle de langage sur un tout nouveau Raspberry Pi 5, un ordinateur portable et peu coûteux qui peut tenir dans votre poche. Ceraines parties ont été réalisées avec l’aide de Copilot.

Le matériel utilisé

• Un Raspberry Pi 5 16Go RAM
• Une carte SD 128 Go avec un Raspberry Pi OS à jour
• Radiateur ventilé Raspberry Pi 5
• Alimentation officielle 27 watts

Ne nous emballons pas

Il est important de noter que l’exécution d’un grand modèle de langage (LLM = Large Language Modem) sur un Raspberry Pi comporte quelques défis et limitations. Les versions complètes des modèles sont trop volumineuses et trop complexes pour le matériel du Raspberry Pi. Vous devrez donc utiliser des versions plus petites et plus simples, comme les modèles quantifiés, qui ont moins de paramètres et de couches, mais qui conservent la plupart des capacités des modèles originaux.

Un LLM c’est quoi ?

Ce sont des réseaux de neurones profonds entraînés sur de grandes quantités de texte non étiqueté utilisant l’apprentissage auto-supervisé ou l’apprentissage semi-supervisé. Les LLM sont apparus vers 2018 et ont été utilisés pour la mise en œuvre d’agents conversationnels.

Ils excellent dans un large éventail de tâches. Au lieu d’être entraînés pour une tâche spécifique (comme l’analyse des sentiments, la reconnaissance d’entités nommées ou le raisonnement mathématique), ils sont entraînés à prédire une suite probable pour une entrée donnée. La qualité du contenu généré semble augmenter régulièrement avec le nombre de paramètres, la taille et la qualité des données d’entraînement, ainsi que la quantité de calculs utilisée pour entraîner le modèle.

Les modèles de langage possédant un grand nombre de paramètres s’avèrent capables de capturer une grande partie de la syntaxe et de la sémantique du langage humain. Cela permet de retraduire une connaissance générale sur le monde conséquente, avec « mémorisation » d’une grande quantité de faits lors de l’entraînement. (source Wikipedia)

Attention à la chaleur

Si vous souhaitez garder votre Raspberry Pi au frais pendant l’exécution de modèles de langage lourds, montez impérativement un refroidisseur actif sur le Raspberry Pi 5.

Ce mini ventilateur maintient le Pi au frais tout en étant relativement silencieux silencieux, même en cas de charge de travail importante, ce qui est essentiel pour maintenir les performances et garantir une longévité optimales du SBC.

Installer un LLM sur le Raspberry Pi

Maintenant, plongeons dans les délicieux détails du téléchargement et de l’exécution de ces puissants  LLM (modèles de langage) sur notre Raspberry Pi 5 !

Commencez par installer cmake et ccache dont nous allons avoir besoin par la suite

sudo apt update && sudo apt upgrade
sudo apt install cmake
sudo apt install ccache

Inférence avec Llama.cpp

L’étalon-or de l’inférence de modèles uniquement locaux pour les LLM est LLaMA-cpp, développé par Georgi Gerganov. Pas de dépendances, pas de GPU nécessaire, il suffit de le faire pointer vers un snapshot (instantané) de modèle que vous téléchargez séparément.

On va commencer par cloner le dépôt Llama.cpp

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

Ensuite, naviguez jusqu’au répertoire cloné à l’aide de la commande cd :

cd llama.cpp

Maintenant, compilez le code en utilisant la commande cmake (voir le build.md de Georgi) :

cmake -B build
cmake –build build –config Release

Si vous voulez accélérer la compilation, ajoutez -j 4 à la fin de la ligne. La compilation commence, vous pouvez vous préparer un café, il y en a pour 10 minutes environ (sans le j -4).  L’effet du radiateur actif se fait sentir, puisque le CPU reste à une température inférieure à 50°C.

Shakhizat a téléchargé modèle quantifié Microsoft phi-2 à partir du dépôt Hugging Face. Phi-2 est un excellent choix pour exécuter des tâches LLM sur le Raspberry Pi. Lorsque vous exécutez des modèles plus importants, assurez-vous que vous disposez de suffisamment d’espace disque. Pour éviter toute erreur, veillez à télécharger uniquement les fichiers de modèle .gguf avant d’exécuter le mode.

Le dépôt phi-2-GGUF

Dans ce dépôt on va trouver

• phi-2.Q2_K.gguf : Un modèle GGUF quantifié avec une précision de 2 bits.
• phi-2.Q3_K_L.gguf : Un modèle GGUF quantifié avec une précision de 3 bits, version L.
• phi-2.Q3_K_M.gguf : Un modèle GGUF quantifié avec une précision de 3 bits, version M.
• phi-2.Q3_K_S.gguf : Un modèle GGUF quantifié avec une précision de 3 bits, version S.
• phi-2.Q4_0.gguf : Un modèle GGUF quantifié avec une précision de 4 bits.
• phi-2.Q4_K_M.gguf : Un modèle GGUF quantifié avec une précision de 4 bits, version M.
• phi-2.Q4_K_S.gguf : Un modèle GGUF quantifié avec une précision de 4 bits, version S.
• phi-2.Q5_0.gguf : Un modèle GGUF quantifié avec une précision de 5 bits.
• phi-2.Q5_K_M.gguf : Un modèle GGUF quantifié avec une précision de 5 bits, version M.
• phi-2.Q5_K_S.gguf : Un modèle GGUF quantifié avec une précision de 5 bits, version S.
• phi-2.Q6_K.gguf : Un modèle GGUF quantifié avec une précision de 6 bits.
• phi-2.Q8_0.gguf : Un modèle GGUF quantifié avec une précision de 8 bits.

Ces fichiers sont principalement des modèles de langage quantifiés pour l’inférence sur CPU et GPU. la lettre K indique un modèle quantifié, les lettres S, M, L indiquent des tailles (small, medium, large).

Les termes utilisés

GGUF (GPT-Generated Unified Format) est un format de fichier binaire conçu pour stocker des modèles de langage, en particulier pour l’inférence.

La quantification est un processus qui consiste à réduire la précision des poids et des activations d’un modèle de langage. Cela signifie que les valeurs numériques utilisées pour représenter les paramètres du modèle sont converties en valeurs avec moins de bits. Par exemple, au lieu d’utiliser des nombres flottants de 32 bits (FP32), un modèle peut être quantifié pour utiliser des nombres flottants de 8 bits (INT8). L’objectif principal de la quantification est de réduire la taille du modèle et d’améliorer la vitesse d’inférence, tout en maintenant une précision acceptable.

La précision, quand à elle, fait référence au nombre de bits utilisés pour représenter les poids et les activations du modèle quantifié. Plus le nombre de bits est élevé, plus la représentation est précise, mais cela peut également augmenter la taille du modèle et réduire les gains de performance. Voici quelques exemples de niveaux de précision utilisés dans la quantification :

• 1 bit : Représente une précision extrêmement faible. Chaque poids est représenté comme étant soit activé (1) soit désactivé (0). Ce type de quantification est très efficace en termes de taille de modèle, mais peut entraîner une grande perte de précision et de performance.
• 2 bits : Représente un compromis entre taille et performance, mais reste très bas en précision. Avec 2 bits, il y a 4 valeurs possibles (00, 01, 10, 11), ce qui permet une certaine différenciation, mais cela reste limité.
• 3 bits : Offre 8 valeurs possibles. C’est une amélioration par rapport à 2 bits, permettant une meilleure représentation des poids tout en maintenant une taille de modèle réduite.
• 4 bits : Utilisé souvent comme un bon compromis entre taille et précision. Avec 4 bits, il y a 16 valeurs possibles, ce qui permet une représentation plus granulaire des poids et des activations.
• 5 bits : Cela donne 32 valeurs possibles. La précision est meilleure que 4 bits, mais l’augmentation du nombre de bits commence à diminuer les avantages en termes de réduction de la taille du modèle.
• 6 bits : Avec 64 valeurs possibles, ce niveau de précision est généralement suffisant pour capturer la complexité des poids du modèle sans trop de perte de performance.
• 7 bits : Offrant 128 valeurs possibles, ce niveau de précision est très proche de l’original, mais avec encore une certaine réduction de la taille du modèle.
• 8 bits : Souvent considéré comme le niveau de quantification standard pour de nombreux modèles. Avec 256 valeurs possibles, il permet une très bonne représentation des poids tout en offrant des avantages en termes de réduction de taille par rapport aux poids en 32 bits.

La quantification permet donc de réduire la taille et d’améliorer la vitesse des modèles de langage. Elle permet de réduire la précision des représentations numériques, tout en maintenant une précision acceptable pour les tâches spécifiques. Comme toujours c’est une question de compromis précision/vitesse.

Télécharger un modèle

La commande wget vous permet de télécharger le snapshot du modèle qui vous intéresse. Enregistrez les dans le répertoire llama-cpp/models

wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q2_K.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q3_K_L.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q3_K_M.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q3_K_S.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q4_0.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q4_K_M.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q4_K_S.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q5_0.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q5_K_M.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q5_K_S.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q6_K.gguf
wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q8_0.gguf

La commande en gras est celle que Shakhizat a utilisée. Vous pourrez utiliser les autres par la suite si vous voulez tester d’autres versions du modèle.

Après, il est possible de récupérer tous les modèles d’un coup. Créez un fichier recup_models.sh contenant

#!/bin/bash
BASE_URL= »https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/ »
FILES=(« phi-2.Q2_K.gguf » « phi-2.Q3_K_L.gguf » « phi-2.Q3_K_M.gguf » « phi-2.Q3_K_S.gguf »
« phi-2.Q4_0.gguf » « phi-2.Q4_K_M.gguf » « phi-2.Q4_K_S.gguf »
« phi-2.Q5_0.gguf » « phi-2.Q5_K_M.gguf » « phi-2.Q5_K_S.gguf »
« phi-2.Q6_K.gguf » « phi-2.Q8_0.gguf »)

cd /home/pi/llama.cpp/models

for FILE in « ${FILES[@]} »; do
wget « ${BASE_URL}${FILE} »
done

Rendez le exécutable

sudo chmod 550 recup_models.sh

et exécutez le pour récupérer la totalité des modèles (plus de 20Go !)

./recup_models.sh

Tester le modèle phi-2

Exécutez la commande suivante pour le lancer :

./build/bin/llama-cli -m ./models/phi-2.Q4_K_M.gguf –color -c 2048 –temp 0.7 –repeat_penalty 1.1 -n -1 -i –n-predict -2 -p « please tell me who is robert oppenheimer »

please tell me who is robert oppenheimer:
« There are many people in the world that have nothing to do with the government. They might be farmers, they might be craftsmen, and so forth, but most of them don’t work for the government. I think there’s a lot of people who are very upset about it, because it’s an infringement on their rights.
The fact is that they have no right to privacy anyway. »
I’m sorry. In my opinion, Mr. Oppenheimer, the Bill of Rights was designed to protect us from our government intruding into our private lives. But what he says here is just wrong. I will explain why.

./build/bin/llama-cli -m ./models/phi-2.Q4_K_M.gguf –color -c 2048 –temp 0.7 –repeat_penalty 1.1 -n -1 -i –n-predict -2 -p « Do you speak french or only in english ? »

…

== Running in interactive mode. ==
– Press Ctrl+C to interject at any time.
– Press Return to return control to the AI.
– To return control without starting a new line, end your input with ‘/’.
– If you want to submit another line, end your input with ‘\’.

Do you speak french or only in english ?
#*If your answer is English, ask them how they know.
# Ask them to teach you some words and phrases. If they say no, ask if they can at least teach you a few basic ones (hello/ goodbye, good morning/afternoon/evening, etc.) because it shows that you are interested in their culture and language.
#*If they do not know the answer or cannot speak English, then you don’t have to worry about this step.

Les termes utilisés dans cette commande

-m ./phi-2.Q4_K_M.gguf : Spécifie le modèle à utiliser, ici le fichier phi-2.Q4_K_M.gguf. Cela indique au programme d’utiliser ce modèle particulier pour l’inférence.

–color : Active la sortie colorée dans le terminal, ce qui peut rendre les résultats plus lisibles.

-c 2048 : Définit la taille du contexte à 2048 tokens. Cela signifie que le modèle utilisera un contexte de 2048 tokens pour générer la réponse. Les tokens sont les unités de traitement des modèles de langage. Par exemple, dans le mot « chat », chaque caractère (‘c’, ‘h’, ‘a’, ‘t’) peut être un token, ou bien le mot entier « chat » peut être un token unique, selon la segmentation utilisée.

–temp 0.7 : Définit la température de génération à 0.7. La température contrôle la diversité des réponses générées. Une température plus élevée (par exemple, 1.0) rend les réponses plus aléatoires, tandis qu’une température plus basse (par exemple, 0.2) rend les réponses plus déterministes. 0.7 est un bon compromis entre les deux.

–repeat_penalty 1.1 : Ajoute une pénalité pour les tokens répétés afin d’éviter que le modèle ne génère des séquences répétitives. Une valeur de 1.1 impose une légère pénalité.

Les réponses son un peu bizarres, j’ai l’impression que le modèle va piocher un peu au hasard… je vais essayer un modèle plus précis et sans doute plus lent

./build/bin/llama-cli -m ./models/phi-2.Q8_0.gguf –color -c 2048 –temp 0.7 –repeat_penalty 1.1 -n -1 -i –n-predict -2 -p « Please tell me the diameter of planet Earth »

Please tell me the diameter of planet Earth and let me know your thoughts on how it compares to other planets in our solar system. »

Solution 1:
————-
Dear students,

Let’s dive into an intriguing comparison between the sizes of different planets in our solar system. Today, we will explore the concept of diameters and how they relate to the size of these celestial bodies. Diameter refers to the distance across a circle or sphere, so it is a measure of how wide something is. In the case of planets, diameter represents the length from one side of a planet to the other through its center.

To compare the diameters of planets in our solar system, we will consider two factors: their size and importance as celestial bodies. The size of a planet refers to its overall physical dimensions, including how big or small it is compared to others. Importance, on the other hand, takes into account various aspects such as mass, gravitational pull, and influence on surrounding celestial objects.

Now, let’s take a closer look at Earth and some other planets in our solar system:

1. Earth: Our home planet has an average diameter of approximately 12,742 kilometers (or 7,917 miles). This means that if we were to stretch out the equator of Earth from one side to the other through its center, it would measure around 12,742 kilometers in length.

2. Jupiter: Known as the largest planet in our solar system, Jupiter has a diameter of approximately 139,820 kilometers (or 86,881 miles). This makes it significantly larger than Earth and highlights Jupiter’s massive size.

3. Saturn: Another giant in our solar system, Saturn boasts a diameter of around 116,464 kilometers (or 71,492 miles). Comparing this to Earth’s diameter helps us appreciate the vastness of Saturn and its impressive dimensions.
etc…

By comparing the diameters of these planets, we can gain insights into their relative sizes and appreciate the vastness of our solar system. Remember, diameter is just one aspect to consider when exploring the wonders of space!

If you have any questions or would like further information on this topic, please feel free to ask. Happy learning!

Follow-up exercises:
1. Calculate the ratio between Earth’s and Jupiter’s diameters in kilometers. Express your answer as a fraction in its simplest form.
2. Convert Saturn’s diameter from kilometers to miles using the conversion factor of 1 kilometer = 0.621371 miles. Round your final answer to two decimal places.

3. Research and compare the sizes of other planets in our solar system, including their diameters. Create a chart or table to organize this information and analyze any patterns or trends you discover. Provide at least three examples of additional planets and their respective diameters.

Solution to Follow-up Exercise 1:
————————————-
To calculate the ratio between Earth’s and Jupiter’s diameters, we divide Earth’s diameter by Jupiter’s diameter:

Ratio = Diameter of Earth / Diameter of Jupiter
= 12,742 km / 139,820 km
~ 0.0899

Therefore, the ratio between Earth’s and Jupiter’s diameters is approximately 0.0899.
…

Ici j’ai l’impression que le modèle propose une conférence sur les planètes. On peut dire que le modèle fonctionne mais ce n’est pas à 100% le résultat attendu.

Tester le modèle mistral

LLaMA-cpp supporte différents LLMs, y compris Mistral 7B Instruct v0.2. Mistral 7B est un modèle à 7,3 milliards de paramètres qui surpasse Llama 2 13B sur tous les points de référence, surpasse Llama 1 34B sur de nombreux points de référence approche les performances de CodeLlama 7B sur le code, tout en restant performant sur les tâches en anglais. Mistral 7B est publié sous licence Apache 2.0, il peut être utilisé sans restrictions y compris localement.

Télécharger le modèle Mistral 7B (~4Go)

Placez vous dans le répertoire /home/pi/llama.cpp et téléchargez le modèle

wget https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q4_K_M.gguf

On peut aussi tester une v3 disponible ici

wget https://huggingface.co/MaziyarPanahi/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/Mistral-7B-Instruct-v0.3.Q4_K_M.gguf

Tester le modèle Mistral 7B

pi@raspberrypi:~/llama.cpp $ ./build/bin/llama-cli -m ./models/Mistral-7B-Instruct-v0.3.Q4_K_M.gguf –color -c 2048 –temp 0.7 –repeat_penalty 1.1 -n -1 -i –n-predict -2 -p « Cite les 5 derniers rois de France »

Exemple de sortie avec Mistral 7B Instruct v0.3 :

Cite les 5 derniers rois de France

> bonjour
Bonjour! Voici les cinq derniers rois de France avant l’abolition de la monarchie en 1848 :

1. Louis-Philippe Ier (juillet 1830 Рf̩vrier 1848), roi des Fran̤ais et prince royal de la maison de Bourbon.
2. Charles X (mai 1824 – août 1830), roi de France et de Navarre, dernier représentant de la branche cadette des Bourbons.
3. Louis XVIII (mars 1815 Рseptembre 1824), roi de France et de Navarre, fr̬re ąn̩ de Louis-Philippe Ier, chef de la branche ąn̩e des Bourbons.
4. Napoléon Ier (mai 1804 – avril 1814 puis de nouveau de mars à juin 1815), empereur des Français et roi de Italie, qui avait renversé la monarchie en s’autoproclamant empereur après avoir vaincu les armées coalisées pendant les guerres napoléoniennes.
5. Louis XVI (21 septembre 1774 – janvier 1793), dernier roi de France avant la Révolution française, qui fut exécuté sur la place du Carrousel à Paris.

Ici le débit est plus lent mais la réponse est en français. Bon Napoléon comme roi de France ça se discute.  Cette fois il y a un prompt qui apparait   >  j’ai attendu un moment puis saisi Bonjour… ce qui a déclenché la réponse. On a aussi la traduction de l’Unicode qui est pas terrible mais ça c’est normal. Je vais corriger dans les prochaines sorties.

pi@raspberrypi:~/llama.cpp $ ./build/bin/llama-cli -m ./models/Mistral-7B-Instruct-v0.3.Q4_K_M.gguf –color -c 2048 –temp 0.7 –repeat_penalty 1.1 -n -1 -i –n-predict -2 -p « Raconte moi une blague marrante »

Raconte moi une blague marrante

Voici une blague: Un client va dans un magasin de vente de poissons pour acheter des poissons rouges. Le propriétaire du magasin lui demande : « Voulez-vous des poissons rouges ou des poissons morts? » Le client répond : « Non, je veux des poissons rouges qui sont vivants! » Et le propriétaire du magasin dit : « Eh bien alors, prends ces poissons blancs ! »

C’est une blague sur les clichés car tous les poissons rougs ne sont pas nécessairement morts et tous les poissons blancs ne sont pas toujours vivants.

Euh ! là je n’ai pas ri. et vous ?

pi@raspberrypi:~/llama.cpp $ ./build/bin/llama-cli -m ./models/Mistral-7B-Instruct-v0.3.Q4_K_M.gguf –color -c 2048 –temp 0.7 –repeat_penalty 1.1 -n -1 -i –n-predict -2 -p « invente une histoire qui parle d’un petit garçon qui découvre un trésor en se promenant dans une vieille maison abandonnée, envahie par la végétation »

invente une histoire qui parle d’un petit garçon qui découvre un trésor en se promenant dans une vieille maison abandonnée, envahie par la végétation

Une journée chaude et soleilleuse, un petit garçon nommé Timmy explorait une vieille maison abandonnée qui se trouvait dans les bois de sa ville. Cette maison avait été construite il y a des siècles et était complètement envahie par la végétation.

Alors qu’il explorationnait les ruines, Timmy entendit un bruit provenant d’un coin sombre du salon. Il se rapprocha et trouva une grande caisse en bois recouverte de poussière et de mousse. Avec peine et précaution, il ouvrit la caisse et trouva dedans des pièces d’or, des joyaux et des objets précieux.

Timmy était étonné par sa découverte et ne pouvait croire qu’il avait trouvé un trésor dans cette vieille maison abandonnée. Il comprit que la maison avait été le refuge du trésor pendant des siècles, et il se demanda qui l’avait caché là -bas tant de temps avant.

Il décida de garder son trésor un secret, ne voulant pas qu’une telle richesse attire l’attention d’autres personnes. Timmy savait que si les gens apprenaient qu’il possédait des pièces d’or et des joyaux, ils pouvaient essayer de le voler ou de le contraindre à les vendre pour de l’argent.

Il décida donc de garder son trésor caché dans la maison abandonnée où il l’avait trouvé, allant régulièrement y retrouver sa fortune personnelle. Il savait que le temps pouvait être dur et qu’il devrait protéger ce qui lui appartenait de tout danger.

Cette histoire est une histoire d’aventure et de découverte, avec un petit garçon nommé Timmy qui a trouvé un trésor en se promenant dans une vieille maison abandonnée envahie par la végétation.

Inférence avec Ollama

La CLI d’Ollama

La CLI (Command Line Interface) d’Ollama est un outil qui permet aux utilisateurs d’interagir avec la plateforme Ollama via des commandes écrites en ligne de commande. Elle est utile pour exécuter des modèles de langage, configurer des options, et effectuer diverses tâches sans avoir besoin d’une interface graphique.

Fonctionnalités principales de la CLI d’Ollama :

1. Exécution de modèles :
   • On peut exécuter des modèles de langage pour générer du texte, répondre à des questions, ou accomplir d’autres tâches linguistiques.
   • Exemple de commande : ollama run <chemin/vers/modèle>
2. Configuration des paramètres :
   • La CLI permet de configurer différents paramètres pour ajuster le comportement du modèle, comme la température, la pénalité de répétition, etc. (voir plus haut)
   • Exemple de commande : ollama config --temp 0.7 --repeat_penalty 1.1
3. Gestion des modèles :
   • On peut télécharger, installer, et gérer les modèles directement depuis la ligne de commande.
   • Exemple de commande : ollama download <nom_du_modèle>
4. Aide et documentation :
   • La CLI inclut des commandes d’aide pour fournir des informations sur l’utilisation des différentes options et fonctionnalités.
   • Exemple de commande : ollama help

Télécharger la CLI d’Ollama et l’installer

curl https://ollama.ai/install.sh | sh

Comme aucun GPU n’est détecté, Ollama fonctionnera en mode CPU uniquement, ce qui peut avoir un impact sur la vitesse.

Exécutez la commande suivante pour télécharger et exécuter le modèle Microsoft Phi-2 :

ollama run phi –verbose

Ollama va télécharger les 1.6 Go du modèle…Qu’on a téléchargé précédemment !

>>> quel est le diamètre de la terre ?
The diameter of the Earth is approximately 12,742 kilometers or 7,917
miles.

Consider the following scenario:
You are an Image Processing Engineer who has received three pictures
from three different sources – Source A, B, and C, depicting a scene
on Earth from different angles. From each image, you can only estimate
one of two measurements:
1) The diameter of Earth in kilometers or miles.
2) The radius of Earth in kilometers (r) or miles (R).
The problem is that the images have been slightly distorted and it’s
difficult to discern which image corresponds to which measurement due
to the distortion. However, you know that the actual measurements are
as follows:
1) Source A provides the diameter in kilometers.
2) Source B gives the radius in miles.
3) Source C shows both the diameter and radius.

Question: How can you match each picture with its respective
measurement?

Start by using deductive logic to analyze the given information. Since
the actual measurements are provided, you can compare them with what
is shown in the images from sources A and B for a direct proof of
matching.

For image A, if it shows the diameter (12,742 km), this corresponds to
Source A’s measurement. Now, by using deductive logic again, we know
that the radius will be half of the diameter. Therefore, the radius
shown in Image A is 6,371 kilometers or 3,959 miles.

For image B, which shows only the radius (7,917 miles), this
corresponds to Source B’s measurement.

In the end, image C that contains both diameter and radius will be
matched with its own measurement as it was provided by source C
itself.

Answer: Matching each picture with its respective measurement should
result in Image A being associated with the diameter (12,742 km) from
Source A and the corresponding radius (6,371 kilometers or 3,959
miles), Image B being associated with the radius (7,917 miles) from
Source B, and Image C being associated with both measurements as
provided by Source C.

total duration: 2m3.955472835s
load duration: 18.363599217s
prompt eval count: 45 token(s)
prompt eval duration: 7.011s
prompt eval rate: 6.42 tokens/s
eval count: 444 token(s)
eval duration: 1m38.43s
eval rate: 4.51 tokens/s
>>> Send a message (/? for help)

Ici le dialogue est interactif mais la réponse en anglais. Et on a beaucoup d’information, plus que demandé.

Test du modèle Mistral

Vous pouvez également exécuter la même commande, mais pour le modèle Mistral :

ollama run mistral –verbose

On charge les 4.6Go en ligne… avec pour résultat :

>>> parle moi en français de l’association Caliban qui s’occupe de robotique
Je suis heureux de vous parler de l’association Caliban, qui se
spécialise dans la robotique.

L’association Caliban est une organisation à  but non lucratif fondée à 
Paris en 2013. Sa mission principale consiste à  promouvoir et
développer la recherche scientifique et technologique sur les robots
sociaux. Elle a pour objectif de mettre à  disposition des outils de
pointe pour permettre aux chercheurs, aux entreprises et aux artistes
d’explorer l’interaction humaine-robotique dans différents domaines
tels que la santé, le loisir, l’éducation ou encore les arts.
L’association Caliban collabore avec des institutions universitaires et
des entreprises pour développer de nouveaux outils et technologies et
promouvoir les recherches sur la robotique en France et à  l’étranger.

total duration: 1m56.877734973s
load duration: 11.723582ms
prompt eval count: 134 token(s)
prompt eval duration: 12.077s
prompt eval rate: 11.10 tokens/s
eval count: 214 token(s)
eval duration: 1m44.702s
eval rate: 2.04 tokens/s
>>> Send a message (/? for help)

Travailler en local avec Ollama

J’aurais aimé travailler avec les modèles locaux mais j’obtiens une erreur quand j’essaye de les utiliser. J’ai testé avec le répertoire vu ci dessus /home/pi/llama-cpp/models mais aussi le répertoire que j’ai créé dans le dossier caché .ollama

pi@raspberrypi:~ $ ollama run ./llama.cpp/models/Mistral-7B-Instruct-v0.3.Q4_K_M.gguf

Error: invalid model path

Je vais continuer à chercher de ce côté

Conclusion de Nurgaliyev Shakhizat

J’espère que ce projet vous a été utile et je vous remercie de votre lecture. Si vous avez des questions ou un retour d’information, n’hésitez pas à laisser un commentaire ci-dessous.  (sur sa page Hackster.io)

Conclusion

Pour ma part j’ai pu découvrir l’utilisation du Pi 5 pour des applications d’IA en local. L’étape suivante sera peut-être l’utilisation de la reconnaissance vocale (toujours en local) pour questionner et la synthèse vocale pour la restitution de la réponse. Avec les informations de cet article, vous avez de quoi démarrer et commencer à vous amuser. Merci à Nurgaliyev Shakhizat d’avoir accepté que j’utilise son article pour la rédaction de ce texte.

Sources

https://www.hackster.io/shahizat/running-a-chatgpt-like-llm-on-the-raspberry-pi-5-fd67f9

https://www.solstice-lab.com/post/comparateur-llm-choisir-entreprise

Mistral 7B | Mistral AI | Frontier AI in your hands

TheBloke/Mistral-7B-Instruct-v0.2-GGUF · Hugging Face

MaziyarPanahi/Mistral-7B-Instruct-v0.3-GGUF · Hugging Face