LocalLm : une IA locale en Python

La montée en puissance de l'IA interroge les entreprises et les développeurs. Comment aborder ce secteur nouveau ? Quels outils open source utiliser ?

Face à ChatGPT et autres large language models (LLM) fermés, des alternatives open source se développent. De plus en plus de models open source font leur apparition : les Llama, Mistral et autres Falcon et consorts. Cet écosystème émergent permet d'envisager une utilisation interne en entreprise, hors plateformes géantes. Même si les coûts et la technologie restent incertains et en constante évolution, une telle approche permet de préserver la confidentialité des données, en ne les envoyant pas sur des plateformes externes.

Le code source de la libraririe est disponible dans ce repository : LocalLm.

Présentation et mise en place

La librairie LocalLm permet d'interroger des modèles de language en utilisant différents backends. Backends disponibles :

Llama.cpp Python : the local Python bindings for Llama.cpp: solution en Python local pur : aucun serveur n'est requis.
Koboldcpp : le serveur d'api Koboldcpp: fiable, rétro-compatible, performant.
Ollama : le serveur d'api Ollama: simple à installer et à utiliser.
Goinfer : le serveur d'api Goinfer api server: minimaliste.

Installons tout d'abord la librairie :


            pip install locallm

Téléchargeons maintenant un modèle de language open source. Nous utiliserons Mistral 7B instruct, en version quantitizée, afin que la démonstration présentée ici puisse tourner sur un configuration modeste (sur CPU uniquement avec 8Go de RAM). Note: se référer aux documentations des différents backends pour mettre en place un GPU si disponible, plus rapide. Créons un dossier models et téléchargeons notre modèle en fichier .gguf :

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

Voyons maintenant comment installer et utiliser différents providers.

Python local

Une fois la librairie installée tout est en place pour l'utiliser. Déclarons tout d'abord une instance de LocalLm :

from locallm import InferenceParams, LmParams, LocalLm

            lm = LocalLm(
                LmParams(
                    models_dir=/absolute/path/to/models,
                    is_verbose=True,
                )
            )

Chargeons le modèle en mémoire :


            lm.load_model("mistral-7b-instruct-v0.1.Q4_K_M.gguf", 4096)

Le premier paramètre est le nom du fichier gguf, le second étant la taille de la fenêtre de contexte. Explication : la fenêtre de contexte est le nombre total de tokens que le language model peut prendre en charge. Un token est une fraction de mot ou un mot, qui représente en moyenne 75% d'un mot.

Maintenant tout est en place, interrogeons le modèle :

from locallm import InferenceParams

            template = "<s>[INST] {prompt} [/INST]"
            lm.infer(
                "list the planets in the solar system and their distance from the sun",
                InferenceParams(
                    template=template,
                    stream=True,
                ),
            )

Du fait du paramètre stream=True, le texte s'affichera dans le terminal au fur et à mesure de son émission par le modèle. Le prompt template utilisé dépend du modèle : ici le format Mistral convient très bien.

Koboldcpp

Le serveur Koboldcpp présente certains avantages propres : notamment une bonne gestion de la mémoire, une certaine stabilité, et son cache.

Pour installer Koboldcpp (doc) :


            git clone https://github.com/LostRuins/koboldcpp
            cd koboldcpp
            make

Lançons maintenant le serveur avec notre modèle :


            python koboldcpp.py --contextsize 4096 --model ~/models/mistral-7b-instruct-v0.1.Q4_K_M.gguf --smartcontext

Le endpoint local localhost:5001 est maintenant disponible. Initialisons un provider afin de lancer des queries d'inférence dessus :

from locallm import InferenceParams, LmParams, KoboldcppLm

            lm = KoboldcppLm(
                LmParams(is_verbose=True)
            )

Note : ici nul besoin de charger le modèle, il est déjà préchargé par le serveur. Pour lancer un query d'inférence la même api que précédemment est disponible :


            template = "<s>[INST] {prompt} [/INST]"
            lm.infer(
                "list the planets in the solar system and their distance from the sun",
                InferenceParams(
                    template=template,
                    temperature: 0.2,
                    stream=True,
                ),
            )

Nous avons utilisé ici un paramètre temperature: différents paramètres pour régler l'inférence peuvent être passés au modèle de language : liste des paramètres.

Ollama

Le serveur Ollama est très facile à utiliser et constitue ainsi un bon choix pour démarrer. Il prend en charge l'installation des modèles. Téléchargeons et lançons une instance du serveur :


            wget https://ollama.ai/download/ollama-linux-amd64
            mv ollama-linux-amd64 ollama
            chmod +x ollama
            # on lance:
            ./ollama serve

Nous devons d'abord enregistrer notre modèle dans Ollama. Créons un fichier Modelfile avec ce contenu (remplacer le path par son models dir) :


            FROM /home/me/models/mistral-7b-instruct-v0.1.Q4_K_M.gguf

Nous pouvons maintenant enregister le modèle : dans un autre terminal :


            ./ollama create mistral-7b-instruct-v0.1.Q4_K_M.gguf -f Modelfile

Tout est maintenant en place pour utiliser l'api. Initialisons le provider et chargeons le modèle :


            lm = OllamaLm(
              LmParams(is_verbose=True)
            )
            lm.load_model("mistral-7b-instruct-v0.1.Q4_K_M.gguf", 4096)

Nous pouvons maintenant utiliser l'api pour lancer un query d'inférence :


            template = "<s>[INST] {prompt} [/INST]"
            lm.infer(
                "list the planets in the solar system and their distance from the sun",
                InferenceParams(
                    template=template,
                    temperature: 0,
                    top_p: 0.35,
                    stream=True,
                ),
            )

Conclusion

La montée en puissance de l'IA semble inéluctable. Utilisée pour de plus en plus d'applications en entreprise, son coût demeure élevé. Concurrençant les grandes plateformes closed source, les modèles open source prennent de plus en plus d'ampleur. Les méthodes de quantitization et les moteurs disponibles ouvrent de nouvelles possibilités en terme de coûts d'exploitation.

Localm permet d'utiliser différents backends pour interroger des modèles de language open source locaux. Dans un contexte d'entreprise où la confidentialité des données peut s'avérer essentielle, le développement de capacités IA, basées sur des modèles open source privés, émerge comme une priorité stratégique.