Utiliser des fichiers Llama pour simplifier l'exécution de LLM

Republié par Platon

Suiveurs: 0

Introduction

L’exécution de grands modèles linguistiques a toujours été un processus fastidieux. Il faut télécharger un ensemble de logiciels tiers pour charger ces LLM ou télécharger Python et créer un environnement en téléchargeant de nombreuses bibliothèques Pytorch et HuggingFace. Si vous suivez l'approche pythonique, il faut passer par le processus d'écriture de code pour télécharger et exécuter le modèle. Ce guide examinera une approche plus simple pour exécuter ces LLM.

Objectifs d'apprentissage

Comprendre les défis de l'exécution LLM traditionnelle
Saisissez le concept innovant de Llamafiles
Apprenez à télécharger et à exécuter facilement vos propres exécutables Llamafile
Apprendre à créer des Llamfiles à partir de LLM quantifiés
Identifier les limites de cette approche

Cet article a été publié dans le cadre du Blogathon sur la science des données.

Table des matières

Problèmes avec les grands modèles de langage

Les grands modèles linguistiques (LLM) ont révolutionné la façon dont nous interagissons avec les ordinateurs, en générant du texte, en traduisant des langues, en écrivant différents types de contenu créatif et même en répondant à vos questions de manière informative. Cependant, exécuter ces modèles puissants sur votre ordinateur s’avère souvent difficile.

Pour exécuter les LLM, nous devons télécharger Python et de nombreuses dépendances d'IA, et en plus de cela, nous devons même écrire du code pour les télécharger et les exécuter. Même lors de l’installation des interfaces utilisateur prêtes à l’emploi pour les grands modèles linguistiques, cela implique de nombreuses configurations, qui peuvent facilement mal tourner. Les installer et les exécuter comme un exécutable n’a pas été un processus simple.

Que sont les Llamafiles ?

Les fichiers Llama sont créés pour fonctionner facilement avec les grands modèles de langage open source populaires. Ce sont des exécutables mono-fichiers. C'est comme télécharger un LLM et l'exécuter comme un exécutable. Il n'est pas nécessaire d'installer initialement des bibliothèques. Tout cela a été possible grâce à llama.cpp et à la libc cosmopolite, qui permet aux LLM de fonctionner sur différents systèmes d'exploitation.

Le llama.cpp a été développé par Georgi Gerganov pour exécuter des modèles de langage étendus au format quantifié afin qu'ils puissent fonctionner sur un processeur. le llama.cpp est une bibliothèque C qui nous permet d'exécuter des LLM quantifiés sur du matériel grand public. D'un autre côté, la libc cosmopolite est une autre bibliothèque C qui construit un binaire pouvant fonctionner sur n'importe quel système d'exploitation (Windows, Mac, Ubuntu) sans avoir besoin d'un interpréteur. Ainsi, le Llamafile est construit au-dessus de ces bibliothèques, ce qui lui permet de créer des LLM exécutables à fichier unique.

Les modèles disponibles sont au format quantifié GGUF. GGUF est un format de fichier pour les grands modèles linguistiques développé par Georgi Gerganov, le créateur de llama.cpp. Le GGUF est un format permettant de stocker, partager et charger de manière efficace et efficiente des modèles de langage étendus sur les processeurs et les GPU. Le GGUF utilise une technique de quantification pour compresser les modèles de leur virgule flottante originale de 16 bits vers un format entier de 4 bits ou 8 bits. Les poids de ce modèle quantifié peuvent être stockés dans ce format GGUF

Cela simplifie l’exécution des modèles à 7 milliards de paramètres sur un ordinateur doté d’une VRAM de 16 Go. Nous pouvons exécuter les grands modèles de langage sans nécessiter de GPU (bien que Llamafile nous permette même d'exécuter les LLM sur un GPU). À l'heure actuelle, les fichiers lama des grands modèles de langage Open Source populaires tels que LlaVa, Mistral et WizardCoder sont facilement disponibles pour téléchargement et exécution.

Exécutables One Shot

Dans cette section, nous allons télécharger et essayer d'exécuter un fichier LlaVa Llama multimodal. Ici, nous ne travaillerons pas avec GPU et exécuterons le modèle sur CPU. Accédez au référentiel GitHub officiel de Llamafile en cliquant sur ici et en téléchargeant le modèle LlaVa 1.5.

Télécharger le modèle

L'image ci-dessus montre tous les modèles disponibles avec leurs noms, tailles et liens de téléchargement. Le LlaVa 1.5 fait environ 4 Go et est un multimodèle puissant capable de comprendre les images. Le modèle téléchargé est un modèle à 7 milliards de paramètres quantifié sur 4 bits. Après avoir téléchargé le modèle, accédez au dossier dans lequel il a été téléchargé.

Ensuite, ouvrez le CMD, accédez au dossier où ce modèle est téléchargé, tapez le nom du fichier que nous avons téléchargé et appuyez sur Entrée.

llava-v1.5-7b-q4.llamafile

Pour les utilisateurs Mac et Linux

Pour Mac et Linux, par défaut, l'autorisation d'exécution est désactivée pour ce fichier. Par conséquent, nous devons fournir l’autorisation d’exécution pour le fichier lama, ce que nous pouvons faire en exécutant la commande ci-dessous.

chmod +x llava-v1.5-7b-q4.llamafile

Il s'agit d'activer l'autorisation d'exécution pour le fichier llava-v1.5-7b-q4.llama. Ajoutez également le « ./ » avant le nom du fichier pour exécuter le fichier sur Mac et Linux. Après avoir appuyé sur le mot-clé Entrée, le modèle sera transféré dans la RAM du système et affichera la sortie suivante.

Pour les utilisateurs Mac et Linux | Lamafichiers

Ensuite, le navigateur apparaîtra et le modèle s'exécutera sur l'URL http://127.0.0.1:8080/

L'image ci-dessus montre l'invite par défaut, le nom d'utilisateur, le nom LLM, le modèle d'invite et le modèle d'historique de discussion. Celles-ci peuvent être configurées, mais pour l’instant, nous conserverons les valeurs par défaut.

Ci-dessous, nous pouvons même vérifier les hyperparamètres LLM configurables comme le Top P, le Top K, la température et les autres. Même ceux-ci, nous les laisserons par défaut pour le moment. Maintenant, tapons quelque chose et cliquons sur envoyer.

Dans la photo ci-dessus, nous pouvons voir que nous avons tapé un message et même reçu une réponse. En dessous, nous pouvons vérifier que nous obtenons environ 6 jetons par seconde, ce qui est un bon jeton/seconde étant donné que nous l'exécutons entièrement sur CPU. Cette fois, essayons avec une image.

Bien qu'il ne soit pas exact à 100 %, le modèle pourrait presque obtenir la plupart des éléments directement de l'image. Lançons maintenant une conversation à plusieurs tours avec le LlaVa pour tester s'il se souvient de l'historique des discussions.

Sur la photo ci-dessus, nous pouvons voir que le LlaVa LLM a réussi à bien suivre la conversation. Il pourrait prendre en compte la conversation historique et ensuite générer les réponses. Bien que la dernière réponse générée ne soit pas tout à fait vraie, elle a rassemblé la conversation précédente pour la générer. Ainsi, de cette façon, nous pouvons télécharger un fichier lama et simplement les exécuter comme un logiciel et travailler avec ces modèles téléchargés.

Création de fichiers Lama

Nous avons vu une démo de Llamafile qui était déjà présente sur le GitHub officiel. Souvent, nous ne souhaitons pas travailler avec ces modèles. Au lieu de cela, nous souhaitons créer des exécutables à fichier unique de nos grands modèles de langage. Dans cette section, nous passerons en revue le processus de création d'exécutables à fichier unique, c'est-à-dire des fichiers lama à partir de LLM quantifiés.

Sélectionnez un LLM

Nous commencerons par sélectionner un grand modèle de langage. Pour cette démo, nous sélectionnerons une version quantifiée de TinyLlama. Ici, nous allons télécharger le modèle GGUF quantifié 8 bits de TinyLlama (vous pouvez cliquer sur ici pour aller sur HuggingFace et télécharger le modèle)

Téléchargez le dernier Llamafile

Le dernier zip lamafile à partir du lien officiel GitHub peut être téléchargé. Téléchargez également le zip et extrayez le fichier zip. La version actuelle de cet article est lama file-0.6. Après l'extraction du lama, le dossier bin avec le dossier de fichiers contiendra les fichiers comme l'image ci-dessous.

Déplacez maintenant le modèle quantifié TinyLlama 8 bits téléchargé vers ce dossier bin. Pour créer les exécutables monofichiers, nous devons créer un fichier .args dans le dossier bin de llamafile. À ce fichier, nous devons ajouter le contenu suivant :

-m
tinyllama-1.1b-chat-v0.3.Q8_0.gguf
--host
0.0.0.0
...

La première ligne indique l'indicateur -m. Cela indique au fichier lama que nous chargeons dans les poids d'un modèle.
Dans la deuxième ligne, nous spécifions le nom du modèle que nous avons téléchargé, qui est présent dans le même répertoire dans lequel le fichier .args est présent, c'est-à-dire le dossier bin du fichier lama.
Dans la troisième ligne, nous ajoutons l'indicateur hôte, indiquant que nous exécutons le fichier exécutable et que nous souhaitons l'héberger sur un serveur Web.
Enfin, dans la dernière ligne, nous mentionnons l'adresse où nous souhaitons héberger, qui correspond à localhost. Viennent ensuite les trois points, qui spécifient que nous pouvons transmettre des arguments à notre fichier lama une fois qu'il est créé.
Ajoutez ces lignes au fichier .args et enregistrez-le.

Pour les utilisateurs de Windows

Maintenant, la prochaine étape s'adresse aux utilisateurs Windows. Si nous travaillons sous Windows, nous devions avoir installé Linux via le WSL. Sinon, cliquez ici pour suivre les étapes d'installation de Linux via le WSL. Sous Mac et Linux, aucune étape supplémentaire n'est requise. Ouvrez maintenant le dossier bin du dossier llamafile dans le terminal (si vous travaillez sous Windows, ouvrez ce répertoire dans le WSL) et tapez les commandes suivantes.

cp llamafile tinyllama-1.1b-chat-v0.3.Q8_0.llamafile

Ici, nous créons un nouveau fichier appelé tinyllama-1.1b-chat-v0.3.Q3_0.llamafile ; c'est-à-dire que nous créons un fichier avec l'extension .llamafile et déplaçons le fichier llamafile dans ce nouveau fichier. Maintenant, suite à cela, nous allons saisir la commande suivante.

./zipalign -j0 tinyllama-1.1b-chat-v0.3.Q8_0.llamafile tinyllama-1.1b-chat-v0.3.Q8_0.gguf .args

Ici, nous travaillons avec le fichier zipalign fourni lorsque nous avons téléchargé le zip lamafile depuis GitHub. Nous travaillons avec cette commande pour créer le fichier lama pour notre TinyLlama quantifié. A cette commande zipalign, on passe le fichier tinyllama-1.1b-chat-v0.3.Q8_0.llama que nous avons créé à l'étape précédente, puis on passe le fichier tinyllama-1.1b-chat-v0.3.Q8_0.llama modèle que nous avons dans le dossier bin et enfin transmettre le fichier .args que nous avons créé précédemment.

Cela produira finalement notre fichier exécutable unique tinyllama-1.1b-chat-v0.3.Q8_0.llamafile. Pour nous assurer que nous sommes sur la même longueur d'onde, le dossier bin contient désormais les fichiers suivants.

Maintenant, nous pouvons exécuter le fichier tinyllama-1.1b-chat-v0.3.Q8_0.llama de la même manière que nous le faisions auparavant. Sous Windows, vous pouvez même renommer le fichier .llama en .exe et l'exécuter en double-cliquant dessus.

Serveur compatible OpenAI

Cette section examinera comment serveur les LLM via le Llamfile. Nous avons remarqué que lorsque nous exécutons le fichier lama, le navigateur s'ouvre et nous pouvons interagir avec LLM via le WebUI. C'est essentiellement ce que nous appelons l'hébergement du Large Language Model.

Une fois que nous avons exécuté le Llamafile, nous pouvons interagir avec le LLM respectif en tant que point de terminaison car le modèle est servi sur l'hôte local au PORT 8080. Le serveur suit le protocole API OpenAI, c'est-à-dire similaire au point de terminaison OpenAI GPT, rendant ainsi il est facile de basculer entre le modèle OpenAI GPT et le LLM fonctionnant avec Llamafile.

Ici, nous allons exécuter le fichier lama TinyLlama précédemment créé. Maintenant, cela doit fonctionner sur localhost 8080. Nous allons maintenant le tester via l'API OpenAI elle-même en Python

from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8080/v1", 
    api_key = "sk-no-key-required"
)
completion = client.chat.completions.create(
    model="TinyLlama",
    messages=[
        {"role": "system", "content": "You are a usefull AI 
        Assistant who helps answering user questions"},
        {"role": "user", "content": "Distance between earth to moon?"}
    ]
)
print(completion.choices[0].message.content)

Ici, nous travaillons avec la bibliothèque OpenAI. Mais au lieu de spécifier le point de terminaison OpenAI, nous spécifions l'URL où notre TinyLlama est hébergé et donnons le "sk-no-token-obligatoire" pour l'api_key
Ensuite, le client sera connecté à notre point de terminaison TinyLlama
Désormais, de la même manière que nous travaillons avec OpenAI, nous pouvons utiliser le code pour discuter avec notre TinyLlama.
Pour cela, nous travaillons avec le finitions classe de l'OpenAI. Nous créons du nouveau finitions des .créer() objet et transmettez les détails comme le nom du modèle et les messages.
Les messages se présentent sous la forme d'une liste de dictionnaires, où nous avons le rôle, qui peut être système, utilisateur ou assistant, et nous avons le contenu.
Enfin, nous pouvons récupérer les informations générées via l'instruction print ci-dessus.

Le résultat de ce qui précède peut être vu ci-dessous.

De cette façon, nous pouvons exploiter les fichiers lama et remplacer facilement l'API OpenAI par le fichier lama que nous avons choisi d'exécuter.

Limites des fichiers Llamafile

Bien que révolutionnaires, les lamafiles sont encore en développement. Certaines limitations incluent :

Sélection de modèles limitée : Actuellement, tous les LLM ne sont pas disponibles sous forme de fichiers lama. La sélection actuelle de Llamafiles prédéfinis continue de s'élargir. Actuellement, les fichiers Llamafile sont disponibles pour Llama 2, LlaVa, Mistral et Wizard Coder.
Matériel requis: L’exécution de LLM, même via des Llamafiles, nécessite encore beaucoup de ressources informatiques. Bien qu’elles soient plus faciles à utiliser que les méthodes traditionnelles, les ordinateurs plus anciens ou moins puissants peuvent avoir besoin d’aide pour les faire fonctionner correctement.
Problèmes de sécurité : Le téléchargement et l'exécution d'exécutables à partir de sources non fiables comportent des risques inhérents. Il doit donc y avoir une plateforme fiable sur laquelle nous pouvons télécharger ces fichiers de lama.

Les lamafiles contre le reste

Avant Llamafiles, il existait différentes manières d'exécuter des modèles de langage étendus. L'un était à travers le lama_cpp_python. Il s'agit de la version Python de llama.cpp qui nous permet d'exécuter des modèles de langage étendus quantifiés sur du matériel grand public comme les ordinateurs portables et de bureau. Mais pour l'exécuter, nous devons télécharger et installer Python et même des bibliothèques d'apprentissage en profondeur comme Torch, Huggingface, Transformers et bien d'autres. Et après cela, cela impliquait d’écrire de nombreuses lignes de code pour exécuter le modèle.

Même dans ce cas, nous pouvons parfois être confrontés à des problèmes dus à des problèmes de dépendance (c'est-à-dire que certaines bibliothèques ont des versions inférieures ou supérieures à celles nécessaires). Et il y a aussi le Transformateurs bibliothèque qui nous permet d'exécuter des LLM quantifiés. Même cela nécessite le même processus que celui dont nous avons discuté pour llama_cpp_python

Et puis, il y a Ollama. Ollama a connu un grand succès dans la communauté de l'IA grâce à sa facilité d'utilisation permettant de charger et d'exécuter facilement des modèles de langage étendus, en particulier les modèles quantifiés. Ollama est une sorte de TUI (Terminal User Interface) pour les LLM. La seule différence entre Ollama et Llamafile est la possibilité de partage. Autrement dit, si je le souhaite, je peux partager mon fichier model.llama avec n'importe qui et ils peuvent l'exécuter sans télécharger de logiciel supplémentaire. Mais dans le cas d'Ollama, je dois partager le fichier model.gguf, que l'autre personne ne peut exécuter que lorsqu'elle installe le logiciel Ollama ou via les bibliothèques Python ci-dessus.

Concernant les ressources, elles nécessitent toutes la même quantité de ressources car toutes ces méthodes utilisent le lama.cpp en dessous pour exécuter les modèles quantifiés. Il s’agit uniquement de la facilité d’utilisation là où il existe des différences entre ceux-ci.

Conclusion

Les Llamafiles marquent une étape cruciale pour rendre les LLM facilement exécutables. Leur facilité d'utilisation et leur portabilité ouvrent un monde de possibilités aux développeurs, aux chercheurs et aux utilisateurs occasionnels. Bien qu'il existe des limites, le potentiel des lamafiles pour démocratiser l'accès LLM est évident. Que vous soyez un développeur expert ou un novice curieux, Llamafiles ouvre des possibilités passionnantes pour explorer le monde des LLM. Dans ce guide, nous avons expliqué comment télécharger des Llamafiles et même comment créer nos propres Llamafiles avec nos modèles quantifiés. . Nous avons même jeté un œil au serveur compatible OpenAI créé lors de l'exécution de Llamafiles.

Faits marquants

Les fichiers Llama sont des exécutables à fichier unique qui rendent l'exécution de grands modèles de langage (LLM) plus faciles et plus facilement disponibles.
Ils éliminent le besoin d'installations et de configurations complexes, permettant aux utilisateurs de télécharger et d'exécuter des LLM directement sans exigences Python ou GPU.
Les fichiers Llama sont actuellement disponibles pour une sélection limitée de LLM open source, notamment LlaVa, Mistral et WizardCoder.
Bien que pratiques, les Llamafiles ont toujours des limites, comme la configuration matérielle requise et les problèmes de sécurité associés au téléchargement d'exécutables à partir de sources non fiables.
Malgré ces limitations, Llamafiles représente une étape importante vers la démocratisation de l'accès LLM pour les développeurs, les chercheurs et même les utilisateurs occasionnels.

Foire aux Questions

T1. Quels sont les avantages de l’utilisation de Llamafiles ?

A. Les fichiers Llamafile offrent plusieurs avantages par rapport aux méthodes de configuration LLM traditionnelles. Ils rendent les LLM plus faciles et plus rapides à configurer et à exécuter car vous n'avez pas besoin d'installer Python ni de disposer d'un GPU. Cela rend les LLM plus facilement accessibles à un public plus large. De plus, les Llamafiles peuvent fonctionner sur différents systèmes d'exploitation.

Q2. Quelles sont les limites de Llamafiles ?

R. Bien que les Llamafiles offrent de nombreux avantages, ils présentent également certaines limites. La sélection de LLM disponibles dans Llamafiles est limitée par rapport aux méthodes traditionnelles. De plus, l'exécution de LLM via Llamafiles nécessite toujours une bonne quantité de ressources matérielles, et les ordinateurs plus anciens ou moins puissants peuvent ne pas le prendre en charge. Enfin, les problèmes de sécurité sont associés au téléchargement et à l'exécution d'exécutables à partir de sources non fiables.

Q3. Comment puis-je démarrer avec Llamafiles ?

A. Pour démarrer avec Llamafiles, vous pouvez visiter le référentiel officiel Llamafile GitHub. Là, vous pouvez télécharger le Llamafile pour le modèle LLM que vous souhaitez utiliser. Une fois le fichier téléchargé, vous pouvez l'exécuter directement comme un exécutable.

Q4. Puis-je utiliser mon propre modèle LLM avec Llamafiles ?

R. Non. Actuellement, Llamafiles ne prend en charge que des modèles prédéfinis spécifiques. La création de nos propres Llamafiles est prévue pour les futures versions.

Q5. Quelles sont les perspectives de Llamafiles ?

R. Les développeurs de Llamafiles s'efforcent d'élargir la sélection de modèles LLM disponibles, de les exécuter plus efficacement et de mettre en œuvre des mesures de sécurité. Ces avancées visent à rendre Llamafiles encore plus disponibles et sécurisés pour davantage de personnes ayant peu de connaissances techniques.

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur.