Avec AirLLM, vos LLM avec moins de RAM

Exécuter localement n'importe quel 70B LLM sur un simple GPU de 4GB

fred

Exécutez des modèles de langage de 70 milliards de paramètres avec 4Go de RAM seulement

AirLLM est une technologie révolutionnaire qui permet d’exécuter des modèles de langage de très grande taille (jusqu’à 70 milliards de paramètres) sur des ordinateurs personnels avec des ressources limitées, que ce soit sur PC ou Mac. Cette innovation rend accessible l’utilisation de modèles d’IA avancés sans nécessiter de matériel coûteux ou de services cloud.

Fonctionnement

AirLLM utilise une technique appelée “inférence par couches” pour optimiser l’utilisation de la mémoire. Au lieu de charger l’intégralité du modèle en mémoire, AirLLM ne charge qu’une couche à la fois, libérant la mémoire après chaque utilisation. Cette approche permet d’exécuter des modèles massifs sur des ordinateurs avec seulement 8 Go de RAM, sans compromettre les performances du modèle.

Avantages

  • Démocratisation de l’IA : Accès à des modèles de pointe sur du matériel grand public.
  • Pas de compression : Contrairement à d’autres solutions, AirLLM n’utilise pas de techniques de quantification ou de distillation qui pourraient dégrader les performances.
  • Flexibilité : Compatible avec de nombreux modèles populaires comme Llama, ChatGLM, QWen, Baichuan, Mistral, et InternLM.

Compatibilité

AirLLM fonctionne sur les PC Windows et Linux, ainsi que sur les Mac équipés de puces Apple Silicon (M1, M2, M3). Il tire parti des capacités d’IA intégrées dans ces architectures, notamment la mémoire unifiée des Mac qui permet un partage efficace entre CPU et GPU.

 
 

A essayer...

Guide d’installation et d’utilisation dans un contexte multi-agent

Etape 1 : Installation

  1. Assurez-vous d’avoir Python installé sur votre système.
  2. Ouvrez un terminal et exécutez la commande suivante :
    pip install airllm

Etape 2 : Configuration de base

  1. Créez un nouveau fichier Python (par exemple airllm_demo.py).
  2. Importez les modules nécessaires :
    from airllm import AutoModel
from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.core.tools import FunctionTool
from llama_index.llms.openai import OpenAI

Etape 3 : Création d’un agent simple

  1. Définissez une fonction outil :

    def get_fact():
    return "Un bébé lama s'appelle un 'Cria'."

tool = FunctionTool.from_defaults(fn=get_fact)

  2. Créez un agent avec AirLLM :

    model = AutoModel.from_pretrained("meta-llama/Llama-2-7b-hf")
worker = FunctionCallingAgentWorker.from_tools([tool], llm=model)
agent = worker.as_agent()

Etape 4 : Configuration multi-agent

  1. Importez les modules supplémentaires pour le système multi-agent :

    from llama_agents import AgentService, ControlPlaneServer, SimpleMessageQueue, AgentOrchestrator

  2. Configurez le système multi-agent :

    message_queue = SimpleMessageQueue()
control_plane = ControlPlaneServer(
    message_queue=message_queue,
    orchestrator=AgentOrchestrator(llm=model)
)

agent_service = AgentService(
    agent=agent,
    message_queue=message_queue,
    description="Assistant général",
    service_name="assistant"
)

Etape 5 : Exécution du système

  1. Lancez le service et le plan de contrôle :

    agent_service.start()
control_plane.start()

  2. Envoyez une requête au système :

    result = control_plane.process_query("Donne-moi un fait intéressant sur les lamas.")
print(result)

  3. N’oubliez pas d’arrêter les services à la fin :

    agent_service.stop()
control_plane.stop()

Ce guide vous permet de mettre en place un système multi-agent basique utilisant AirLLM. Vous pouvez étendre ce système en ajoutant d’autres agents avec des compétences spécifiques pour créer un environnement d’IA plus complexe et polyvalent.

Citations:
[1] https://www.reddit.com/r/LocalLLaMA/comments/18sj1ew/airllm_make_8gb_macbook_run_70b/
[2] https://huggingface.co/blog/lyogavin/airllm-mac
[3] https://pypi.org/project/airllm/2.6/
[4] https://www.youtube.com/watch?v=gYBlzMsII9c
[5] https://www.llamaindex.ai/blog/introducing-llama-agents-a-powerful-framework-for-building-production-multi-agent-ai-systems
[6] https://news.ycombinator.com/item?id=38790385
[7] https://huggingface.co/blog/lyogavin/airllm-mac

Intégration d’AirLLM avec Ollama

Actuellement, il n’existe pas d’intégration officielle entre AirLLM et Ollama. Cependant, il est possible de les utiliser ensemble en suivant ces étapes :

1. Installation d’Ollama

Commencez par installer Ollama sur votre système :

  1. Rendez-vous sur https://ollama.com/download
  2. Téléchargez et installez la version correspondant à votre système d’exploitation
  3. Vérifiez l’installation en exécutant dans un terminal :
ollama --version

2. Installation d’AirLLM

Installez AirLLM via pip :

pip install airllm

3. Configuration d’un modèle avec Ollama

Téléchargez un modèle compatible avec Ollama, par exemple Llama 2 :

ollama pull llama2

4. Création d’un script Python

Créez un script Python pour utiliser AirLLM avec le modèle Ollama :

from airllm import AutoModel
import requests

# Initialiser AirLLM avec le modèle Ollama
model = AutoModel.from_pretrained("ollama/llama2")

# Fonction pour interagir avec Ollama via son API
def query_ollama(prompt):
    response = requests.post('http://localhost:11434/api/generate', 
                             json={
                                 "model": "llama2",
                                 "prompt": prompt
                             })
    return response.json()['response']

# Utiliser AirLLM pour optimiser l'utilisation de la mémoire
def generate_response(prompt):
    with model:
        return query_ollama(prompt)

# Exemple d'utilisation
prompt = "Explique-moi le concept de l'intelligence artificielle en termes simples."
response = generate_response(prompt)
print(response)

5. Exécution

  1. Dans un terminal, démarrez le serveur Ollama :
ollama serve
  1. Dans un autre terminal, exécutez votre script Python.

Remarques importantes

  • Cette approche combine les avantages d’AirLLM (optimisation de la mémoire) et d’Ollama (facilité d’utilisation des modèles).
  • Assurez-vous que le modèle choisi est compatible avec les deux systèmes.
  • Les performances peuvent varier selon la configuration de votre machine.

Pour aller plus loin

  • Explorez les différents modèles disponibles dans la bibliothèque Ollama : https://ollama.com/library
  • Consultez la documentation d’AirLLM pour des optimisations avancées : https://github.com/lyogavin/airllm
  • Envisagez de contribuer à l’intégration officielle d’AirLLM dans Ollama en proposant des améliorations sur le dépôt GitHub d’Ollama[6].

Cette intégration vous permettra de bénéficier de l’optimisation de mémoire d’AirLLM tout en profitant de la simplicité d’utilisation d’Ollama pour l’exécution de modèles LLM en local.

Citations:
[1] https://www.sfeir.dev/back/votre-premier-llm-en-5-minutes-avec-ollama/
[2] https://ollama.com
[3] https://scalastic.io/mixtral-ollama-llamaindex-llm/
[4] https://www.devturtleblog.com/ollama-guide/
[5] https://sedona.fr/2024/04/04/ollama-executer-les-modeles-de-langages-llm-en-local/
[6] https://github.com/ollama/ollama/issues/6294
[7] https://hackernoon.com/fr/comment-utiliser-ollama-avec-des-llms-locaux-et-créer-un-chatbot
[8] https://www.langchain.ca/blog/step-by-step-guide-how-to-use-ollama-to-run-open-source-llm-models-locally/


Comment bloquer les publicités

et naviguer en paix

fred

Lire le suivant