LeaderGPU® | Solutions GPU pour le calcul haute performance

Qwen3-Coder : un paradigme brisé

Tue, 12 Aug 2025 14:11:06 +0200

Nous avons l'habitude de penser que les modèles open-source sont toujours moins bons que leurs homologues commerciaux en termes de qualité. Il peut sembler qu'ils soient développés exclusivement par des passionnés qui n'ont pas les moyens d'investir des sommes considérables dans la création d'ensembles de données de haute qualité et dans l'entraînement de modèles sur des dizaines de milliers de GPU modernes.

Il en va tout autrement lorsque de grandes entreprises comme OpenAI, Anthropic ou Meta s'attellent à la tâche. Elles disposent non seulement des ressources nécessaires, mais aussi des meilleurs spécialistes mondiaux des réseaux neuronaux. Malheureusement, les modèles qu'elles créent, en particulier les dernières versions, sont fermés. Les développeurs expliquent cela par les risques d'une utilisation incontrôlée et la nécessité d'assurer la sécurité de l'IA.

D'une part, leur raisonnement est compréhensible : de nombreuses questions éthiques restent en suspens et la nature même des modèles de réseaux neuronaux ne permet qu'une influence indirecte sur le résultat final. D'autre part, le fait de garder les modèles fermés et de n'en offrir l'accès que par l'intermédiaire de leur propre API est également un modèle commercial solide.

Cependant, toutes les entreprises ne se comportent pas de la sorte. Par exemple, la société française Mistral AI propose à la fois des modèles commerciaux et des modèles libres, permettant aux chercheurs et aux passionnés de les utiliser dans leurs projets. Mais il convient d'accorder une attention particulière aux réalisations des entreprises chinoises, dont la plupart construisent des modèles à poids ouvert et à code source ouvert capables de concurrencer sérieusement les solutions propriétaires.

DeepSeek, Qwen3 et Kimi K2

La première avancée majeure a été réalisée avec DeepSeek-V3. Ce modèle de langage multimodal de DeepSeek AI a été développé en utilisant l'approche du mélange d'experts (MoE) et comprend 671 milliards de paramètres, dont 37 milliards de paramètres les plus pertinents activés pour chaque token. Plus important encore, tous ses composants (poids du modèle, code d'inférence et pipelines d'entraînement) ont été rendus publics.

Cela en a fait instantanément l'un des LLM les plus attrayants pour les développeurs d'applications d'IA et les chercheurs. DeepSeek-R1, le premier modèle de raisonnement en libre accès, a ensuite fait la une des journaux. Le jour de sa sortie, il a fait trembler le marché boursier américain après que ses développeurs ont affirmé que la formation d'un modèle aussi avancé n'avait coûté que 6 millions de dollars.

Si le battage médiatique autour de DeepSeek s'est finalement calmé, les versions suivantes n'en ont pas moins été importantes pour l'industrie mondiale de l'IA. Il s'agit bien sûr de Qwen 3. Nous avons abordé ses caractéristiques en détail dans notre analyse des Nouveautés de Qwen 3, et nous ne nous attarderons donc pas sur ce point ici. Peu de temps après, un autre joueur est apparu : Kimi K2 de Moonshot AI.

Avec son architecture MoE, ses paramètres 1T (32B activés par jeton) et son code open-source, Kimi K2 a rapidement attiré l'attention de la communauté. Plutôt que de se concentrer sur le raisonnement, Moonshot AI visait des performances de pointe en mathématiques, en programmation et en connaissances interdisciplinaires approfondies.

L'atout de Kimi K2 était son optimisation pour l'intégration dans des agents d'intelligence artificielle. Ce réseau a été littéralement conçu pour exploiter pleinement tous les outils disponibles. Il excelle dans les tâches qui requièrent non seulement l'écriture de codes, mais aussi des tests itératifs à chaque étape du développement. Cependant, il présente également des faiblesses, que nous aborderons plus loin.

Kimi K2 est un grand modèle de langage dans tous les sens du terme. L'exécution de la version complète nécessite ~2 TB de VRAM (FP8 : ~1 TB). Pour des raisons évidentes, ce n'est pas quelque chose que vous pouvez faire chez vous, et même de nombreux serveurs GPU ne le supporteront pas. Le modèle nécessite au moins 8 accélérateurs NVIDIA® H200. Les versions quantifiées peuvent aider, mais au prix d'une baisse sensible de la précision.

Qwen3-Codeur

Voyant le succès de Moonshot AI, Alibaba a développé son propre modèle semblable à Kimi K2, mais avec des avantages significatifs dont nous parlerons bientôt. Au départ, il a été publié en deux versions :

Qwen3-Coder-480B-A35B-Instruct (~250 Go VRAM)
Qwen3-Coder-480B-A35B-Instruct-FP8 (~120 Go de VRAM)

Quelques jours plus tard, des modèles plus petits sans le mécanisme de raisonnement sont apparus, nécessitant beaucoup moins de VRAM :

Qwen3-Coder-30B-A3B-Instruct (~32 Go de VRAM)
Qwen3-Coder-30B-A3B-Instruct-FP8 (~18 Go VRAM)

Qwen3-Coder a été conçu pour être intégré à des outils de développement. Il comprend un analyseur spécial pour les appels de fonction (qwen3coder_tool_parser.py, analogue à l'appel de fonction d'OpenAI). Parallèlement au modèle, un utilitaire de console a été publié, capable d'effectuer des tâches allant de la compilation de code à l'interrogation d'une base de connaissances. Cette idée n'est pas nouvelle, il s'agit essentiellement d'une extension fortement retravaillée de l'application de code Gemini d'Anthropic.

Le modèle est compatible avec l'API OpenAI, ce qui permet de le déployer localement ou sur un serveur distant et de le connecter à la plupart des systèmes qui supportent cette API. Cela inclut à la fois les applications clientes prêtes à l'emploi et les bibliothèques d'apprentissage automatique. Cela le rend viable non seulement pour le segment B2C mais aussi pour le segment B2B, offrant un remplacement transparent du produit d'OpenAI sans aucune modification de la logique de l'application.

L'une de ses caractéristiques les plus demandées est l'extension de la longueur du contexte. Par défaut, il prend en charge 256k jetons mais peut être porté à 1M à l'aide du mécanisme YaRN (Yet another RoPe extensioN). Les LLM modernes sont généralement formés sur des ensembles de données courts (2k-8k tokens), et de grandes longueurs de contexte peuvent leur faire perdre la trace du contenu antérieur.

YaRN est une "astuce" élégante qui fait croire au modèle qu'il travaille avec ses séquences courtes habituelles alors qu'il traite en réalité des séquences beaucoup plus longues. L'idée clé est d'"étirer" ou de "dilater" l'espace positionnel tout en préservant la structure mathématique attendue par le modèle. Cela permet de traiter efficacement des séquences de plusieurs dizaines de milliers de tokens sans réentraînement ni mémoire supplémentaire requise par les méthodes traditionnelles d'extension du contexte.

Télécharger et exécuter Inference

Assurez-vous d'avoir installé CUDA® au préalable, soit en utilisant les instructions officielles de NVIDIA®, soit en consultant le guide Installer la boîte à outils CUDA® sous Linux. Vérifiez que vous disposez du compilateur requis :

nvcc --version

Résultat attendu :

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Tue_Feb_27_16:19:38_PST_2024
Cuda compilation tools, release 12.4, V12.4.99
Build cuda_12.4.r12.4/compiler.33961263_0

Si vous obtenez :

Command 'nvcc' not found, but can be installed with:
sudo apt install nvidia-cuda-toolkit

vous devez ajouter les binaires CUDA® au $PATH de votre système.

export PATH=/usr/local/cuda-12.4/bin:$PATH

export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:$LD_LIBRARY_PATH

Il s'agit d'une solution temporaire. Pour une solution permanente, éditez ~/.bashrc et ajoutez les deux mêmes lignes à la fin.

Maintenant, préparez votre système à gérer des environnements virtuels. Vous pouvez utiliser le logiciel intégré venv de Python ou le logiciel plus avancé Miniforge. En supposant que Miniforge est installé :

conda create -n venv python=3.10

conda activate venv

Installez PyTorch avec le support CUDA® correspondant à votre système :

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124

Installez ensuite les bibliothèques essentielles :

Transformers - La bibliothèque de modèles principale de Hugging Face
Accelerate - permet l'inférence multi-GPU
HuggingFace Hub - pour le téléchargement de modèles et d'ensembles de données
Safetensors - format de poids de modèle sûr
vLLM - bibliothèque d'inférence recommandée pour Qwen

pip install transformers accelerate huggingface_hub safetensors vllm

Télécharger le modèle :

hf download Qwen/Qwen3-Coder-30B-A3B-Instruct --local-dir ./Qwen3-30B

Exécuter l'inférence avec le parallélisme tensoriel (répartir les couches tensorielles sur les GPU, par exemple 8) :

python -m vllm.entrypoints.openai.api_server \
--model /home/usergpu/Qwen3-30B \
--tensor-parallel-size 8 \
--gpu-memory-utilization 0.9 \
--dtype auto \
--host 0.0.0.0 \
--port 8000

Ceci lance le serveur vLLM OpenAI API.

Test et intégration

cURL

Installer jq pour l'impression de JSON :

sudo apt -y install jq

Tester le serveur :

curl -s http://127.0.0.1:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "/home/usergpu/Qwen3-30B",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello! What can you do?"}
  ],
  "max_tokens": 180
}' | jq -r '.choices[0].message.content'

VSCode

Pour intégrer Visual Studio Code, installez l'extension Continue et ajoutez-la à config.yaml:

- name: Qwen3-Coder 30B
  provider: openai
  apiBase: http://[server_IP_address]:8000/v1
  apiKey: none
  model: /home/usergpu/Qwen3-30B
  roles:
    - chat
    - edit
    - apply

Qwen-Agent

Pour une installation basée sur l'interface graphique avec Qwen-Agent (y compris RAG, MCP et l'interpréteur de code) :

pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"

Ouvrez l'éditeur nano :

nano script.py

Exemple de script Python pour lancer Qwen-Agent avec une WebUI Gradio :

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

llm_cfg = {
    'model': '/home/usergpu/Qwen3-30B',
    'model_server': 'http://localhost:8000/v1',
    'api_key': 'EMPTY',
    'generate_cfg': {'top_p': 0.8},
}

tools = ['code_interpreter']

bot = Assistant(
    llm=llm_cfg,
    system_message="You are a helpful coding assistant.",
    function_list=tools
)

WebUI(bot).run()

Exécuter le script :

python script.py

Le serveur sera disponible à l'adresse suivante : http://127.0.0.1:7860

Vous pouvez également intégrer Qwen3-Coder dans des cadres d'agents tels que CrewAI pour automatiser des tâches complexes à l'aide d'outils tels que la recherche sur le web ou la mémoire de base de données vectorielles.

Voir aussi :

Comment installer CrewAI avec l'interface graphique

Wed, 23 Jul 2025 15:05:43 +0200

Les capacités des modèles de réseaux neuronaux augmentent chaque jour. Les chercheurs et les entreprises commerciales investissent de plus en plus dans leur formation. Mais ces modèles ne peuvent pas agir de manière autonome. Pour résoudre des tâches spécifiques, ils ont besoin d'être guidés : extension du contexte et définition d'une orientation. Cette approche n'est pas toujours efficace, en particulier pour les problèmes complexes.

Mais que se passerait-il si nous permettions à un réseau neuronal d'agir de manière autonome ? Et si nous lui fournissions de nombreux outils pour interagir avec le monde extérieur ? Vous obtiendriez un agent d'intelligence artificielle capable de résoudre des tâches en déterminant de manière autonome les outils à utiliser. Cela semble compliqué, mais cela fonctionne très bien. Toutefois, même pour un utilisateur expérimenté, la création d'un agent d'intelligence artificielle à partir de zéro peut s'avérer une tâche non triviale.

La raison en est que la plupart des bibliothèques courantes n'ont pas d'interface utilisateur graphique. Elles requièrent une interaction à travers un langage de programmation comme Python. Cela augmente considérablement le seuil d'entrée et rend les agents d'intelligence artificielle trop complexes pour une mise en œuvre indépendante. C'est exactement le cas de CrewAI.

Qu'est-ce que CrewAI ?

CrewAI est une bibliothèque très populaire et pratique, mais elle n'est pas livrée avec une interface graphique par défaut. Cela a incité des développeurs indépendants à créer une interface non officielle. La nature open source de CrewAI a rendu la tâche beaucoup plus facile, et la communauté a rapidement publié le projet CrewAI Studio.

Les développeurs et les passionnés ont acquis une meilleure connaissance de l'architecture du système et ont pu créer des outils adaptés à des tâches spécifiques. Les utilisateurs réguliers pouvaient créer des agents d'intelligence artificielle sans avoir à écrire une seule ligne de code. Il est devenu plus facile d'assigner des tâches et de gérer l'accès aux réseaux neuronaux et aux outils. Il a également permis d'exporter et d'importer des agents d'un serveur à l'autre et de les partager avec des amis, des collègues ou la communauté open source.

Un autre avantage de CrewAI Studio est sa souplesse de déploiement. Il peut être installé comme une application normale ou comme un conteneur Docker - la méthode préférée étant donné qu'elle inclut toutes les bibliothèques et tous les composants nécessaires pour faire fonctionner le système.

Installation de CrewAI Studio

Mettez à jour les paquets de votre système d'exploitation et les applications installées avec les dernières versions :

sudo apt update && sudo apt -y upgrade

Utilisez le script d'installation automatique des pilotes ou suivez notre guide Installer les pilotes NVIDIA® sous Linux:

sudo ubuntu-drivers autoinstall

Redémarrez le serveur pour que les changements soient pris en compte :

sudo shutdown - r now

Après vous être reconnecté via SSH, installez les utilitaires du serveur web Apache 2, qui vous donneront accès au générateur de fichiers .htpasswd utilisé pour l'authentification de base des utilisateurs :

sudo apt install -y apache2-utils

Installez Docker Engine en utilisant le script shell officiel :

curl -sSL https://get.docker.com/ | sh

Ajouter Docker Compose au système :

sudo apt install -y docker-compose

Cloner le dépôt :

git clone https://github.com/strnad/CrewAI-Studio.git

Naviguez jusqu'au répertoire téléchargé :

cd CrewAI-Studio

Créez un fichier .htpasswd pour l'utilisateur usergpu. Vous serez invité à entrer un mot de passe à deux reprises :

htpasswd -c .htpasswd usergpu

Modifiez maintenant le fichier de déploiement du conteneur. Par défaut, il y a deux conteneurs :

sudo nano docker-compose.yaml

Supprimez la section :

ports:
  - "5432:5432"

Et ajouter le service suivant :


nginx:
  image: nginx:latest
  container_name: crewai_nginx
  ports:
    - "80:80"
  volumes:
    - ./nginx.conf:/etc/nginx/nginx.conf:ro
    - ./.htpasswd:/etc/nginx/.htpasswd:ro
  depends_on:
    - web

Nginx aura besoin d'un fichier de configuration, alors créez-en un :

sudo nano nginx.conf

Collez ce qui suit :

events {}

http {
  server {
    listen 80;

    location / {
      proxy_pass http://web:8501;

      # WebSocket headers
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      # Forward headers
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;

      auth_basic "Restricted Content";
      auth_basic_user_file /etc/nginx/.htpasswd;
    }
  }
}

Toutes les variables de service importantes pour CrewAI sont définies dans le fichier .env. Ouvrez le fichier .env_example pour l'éditer :

nano .env_example

Ajoutez les lignes suivantes :

OLLAMA_HOST="http://open-webui:11434"
OLLAMA_MODELS="ollama/llama3.2:latest"

Et ajoutez la configuration Postgres :

POSTGRES_USER="admin"
POSTGRES_PASSWORD="your_password"
POSTGRES_DB="crewai_db"
AGENTOPS_ENABLED="False"

Copiez maintenant le fichier exemple et renommez-le en .env pour que le système puisse le lire lors du déploiement du conteneur :

cp .env_example .env

Dans cet exemple, nous utiliserons des modèles locaux dont l'inférence sera gérée par Ollama. Nous recommandons notre guide Open WebUI : Tout en un, et lors du déploiement ajouter -e OLLAMA_HOST=0.0.0.0 pour permettre à CrewAI de se connecter directement au conteneur Ollama. Téléchargez le modèle désiré (par exemple, llama3.2:latest) via WebUI ou en vous connectant à la console du conteneur et exécutez :

ollama pull llama3.2:latest

Une fois que tout est configuré, lancez le déploiement :

sudo docker-compose up -d --build

En visitant le site http://[your_server_ip]/, vous serez invité à saisir vos identifiants de connexion. Une fois les données saisies correctement, l'interface CrewAI s'affichera.

Fonctionnalités

Explorons les entités clés utilisées par CrewAI. Cela vous aidera à comprendre comment configurer les flux de travail. L'entité centrale du site Agent, un exécuteur de tâches autonome. Chaque agent possède des attributs qui l'aident à remplir ses fonctions :

Role. Une brève description de poste de 2 à 3 mots.
Backstory. Facultatif ; aide le modèle de langage à comprendre comment l'agent doit se comporter et sur quelles expériences s'appuyer.
Goal. L'objectif que l'agent doit poursuivre.
Allow delegation. Permet à l'agent de déléguer des tâches (ou des parties de tâches) à d'autres.
Verbose. Indique à l'agent d'enregistrer des actions détaillées.
LLM Provider and Model. Spécifie le modèle et le fournisseur à utiliser.
Temperature. Détermine la créativité de la réponse. Plus élevée = plus créative.
Max iterations. Nombre d'essais dont dispose l'agent pour réussir, agissant comme une garantie (par exemple, contre les boucles infinies).

Les agents fonctionnent en analysant les données de manière itérative, en raisonnant et en tirant des conclusions à l'aide des outils disponibles.

Les données d'entrée sont définies par une entité Task. Chaque tâche comprend une description, un agent assigné et, éventuellement, un résultat attendu. Les tâches s'exécutent séquentiellement par défaut mais peuvent être parallélisées en utilisant le drapeau Async execution.

Le travail des agents autonomes est soutenu par Tools qui permet une interaction avec le monde réel. CrewAI comprend des outils pour les recherches sur le web, l'analyse de sites, les appels d'API et la gestion de fichiers, ce qui améliore le contexte et aide les agents à atteindre leurs objectifs.

Enfin, le site Crew entity réunit des agents ayant des rôles différents au sein d'une équipe pour s'attaquer à des problèmes complexes. Ils peuvent communiquer, déléguer, réviser et se corriger mutuellement, formant ainsi une intelligence collective.

L'utilisation de

Maintenant que vous êtes familiarisé avec les entités, construisons et exécutons un flux de travail CrewAI minimal. Dans cet exemple, nous suivrons les progrès réalisés au niveau mondial dans le développement de médicaments contre le cancer.

Nous utiliserons trois agents :

Oncology Drug Pipeline Analyst - suit les nouveaux développements depuis les premières étapes jusqu'aux essais cliniques.
Regulatory and Approval Watchdog - suit les nouvelles approbations de médicaments et les changements de réglementation.
Scientific Literature and Innovation Scout - analyse les publications scientifiques et les brevets liés à l'oncologie.

Ouvrez la section Agents et créez le premier agent :

Pour l'instant, nous utilisons le modèle llama3.2:latest précédemment téléchargé, mais dans un scénario réel, choisissez celui qui correspond le mieux à la tâche. Répétez le processus pour les autres agents et passez à la création de la tâche.

Rassemblez tous les agents en une équipe et assignez-leur la tâche préparée :

Activez les outils nécessaires à partir de la liste :

Enfin, allez sur la page Kickoff! et cliquez sur Run Crew! Après quelques itérations, le système renverra un résultat, tel que :

Avant de terminer, vérifions la section Import/export. Votre flux de travail ou votre équipage peut être exporté sous forme de JSON pour être transféré vers un autre serveur CrewAI. Vous pouvez également créer une application à page unique (SPA) en un seul clic, ce qui est parfait pour un déploiement en production :

Conclusion

CrewAI simplifie considérablement la création d'agents d'intelligence artificielle, permettant l'intégration dans n'importe quelle application ou l'utilisation autonome. La bibliothèque est basée sur l'idée de l'intelligence distribuée, où chaque agent est un expert du domaine, et l'équipe combinée est plus performante qu'un seul agent généraliste.

Comme elle est écrite en Python, CrewAI s'intègre facilement aux plateformes et outils de ML. Sa nature open source permet de l'étendre grâce à des modules tiers. La communication entre agents réduit l'utilisation de jetons en distribuant le traitement du contexte.

Par conséquent, les tâches complexes sont accomplies plus rapidement et plus efficacement. La barrière d'entrée réduite offerte par CrewAI Studio élargit la portée des agents d'IA et des systèmes multi-agents. La prise en charge des modèles locaux garantit un meilleur contrôle des données sensibles.

Voir aussi :

Nouveautés de Qwen 3

Mon, 14 Jul 2025 08:05:08 +0200

La course mondiale à l'IA s'accélère. Des instituts de recherche, des entreprises privées et même des nations entières se disputent aujourd'hui le leadership dans le domaine de l'IA. D'une manière générale, cette course peut être divisée en plusieurs phases. La première étape a consisté à créer une IA étroite. Les modèles de réseaux neuronaux existants tels que GPT, MidJourney et AlphaFold montrent que cette étape a été franchie avec succès.

L'étape suivante envisage l'évolution de l'IA vers l'AGI (Intelligence Générale Artificielle). L'AGI devrait égaler l'intelligence humaine dans la résolution d'un large éventail de tâches, depuis l'écriture d'histoires et les calculs scientifiques jusqu'à la compréhension de situations sociales et l'apprentissage autonome. À l'heure où nous écrivons ces lignes, ce niveau n'a pas encore été atteint.

Le stade ultime du développement de l'IA est appelé ASI (Artificial Super Intelligence). Elle dépasserait de loin les capacités humaines dans tous les domaines. Elle permettrait de développer des technologies que nous ne pouvons même pas imaginer aujourd'hui et de gérer des systèmes globaux avec une précision dépassant les capacités humaines. Toutefois, cela ne pourrait devenir une réalité qu'après des décennies (voire des siècles) de progrès continus.

C'est pourquoi la plupart des participants à la course à l'IA s'efforcent d'atteindre l'AGI tout en gardant le contrôle sur elle. Le développement de l'AGI est étroitement lié à une série de défis techniques, éthiques et juridiques complexes. Néanmoins, les bénéfices potentiels dépassent largement les coûts, ce qui explique pourquoi des entreprises comme Alibaba Group investissent massivement dans ce domaine.

La sortie de Qwen 3 marque une étape importante non seulement pour les réseaux neuronaux d'une entreprise, mais aussi sur la scène mondiale. Par rapport à son prédécesseur, le modèle introduit plusieurs innovations importantes.

Caractéristiques

Qwen 2.5 a été pré-entraîné sur un ensemble de données de 18 milliards de jetons, alors que le nouveau modèle a doublé cette quantité pour atteindre 36 milliards de jetons. Le plus grand ensemble de données a considérablement amélioré la précision du modèle de base. Il est intéressant de noter qu'en plus des données Internet accessibles au public recueillies par l'analyse syntaxique, le système a également été entraîné sur des documents PDF. Ces documents sont généralement bien structurés et riches en connaissances, ce qui permet au modèle de fournir des réponses plus précises et de mieux comprendre les formulations complexes.

L'une des orientations les plus prometteuses du développement de l'IA est la construction de modèles capables de raisonner, qui peuvent élargir le contexte de la tâche grâce à un processus itératif. D'une part, cela permet une résolution plus complète des problèmes, mais d'autre part, le raisonnement a tendance à ralentir considérablement le processus. C'est pourquoi les développeurs de Qwen 3 ont introduit deux modes de fonctionnement :

Thinking mode. Le modèle construit le contexte étape par étape avant de fournir une réponse finale. Cela permet d'aborder des problèmes complexes qui nécessitent une compréhension approfondie.
Non-thinking mode. Le modèle répond presque instantanément mais peut produire des réponses plus superficielles sans analyse approfondie.

Ce contrôle manuel du comportement du modèle améliore l'expérience de l'utilisateur pour de nombreuses tâches de routine. La réduction de l'utilisation du mode réflexion diminue également de manière significative la charge du GPU, ce qui permet de traiter plus de jetons dans le même laps de temps.

Outre ce choix binaire, il existe également un mécanisme de commutation douce. Ce comportement hybride permet au modèle de s'adapter au contexte en utilisant des mécanismes de pondération internes. Si le modèle estime qu'une tâche est difficile, il déclenchera automatiquement un raisonnement ou même une auto-vérification. Il peut également répondre à des signaux de l'utilisateur tels que "Réfléchissons étape par étape".

Une autre amélioration significative est l'extension de la prise en charge multilingue. Alors que Qwen 2.5 ne prenait en charge que 29 langues, la version 3 peut désormais comprendre et générer du texte dans 119 langues et dialectes. Cela a considérablement amélioré le suivi des instructions et la compréhension du contexte. Par conséquent, Qwen 3 peut désormais être utilisé efficacement dans des environnements non anglophones.

En outre, Qwen 3 est désormais beaucoup mieux intégré aux serveurs MCP, ce qui permet au modèle d'approfondir la résolution des problèmes et d'exécuter des actions. Il peut désormais interagir avec des sources externes et gérer directement des processus complexes.

Formation au modèle

Préformation

Un tel bond en avant n'aurait pas été possible sans un système de formation en plusieurs étapes. Dans un premier temps, le modèle a été pré-entraîné sur 30B tokens avec une longueur de contexte de 4K, ce qui lui a permis d'acquérir des connaissances générales et des compétences linguistiques de base.

Cette étape a été suivie d'une phase d'affinement à l'aide de données plus scientifiques et mieux structurées. Au cours de cette étape, le modèle a également acquis la capacité d'écrire efficacement des applications dans plusieurs langages de programmation.

Enfin, il a été entraîné sur un ensemble de données de haute qualité avec un contexte étendu. Par conséquent, Qwen 3 prend désormais en charge une longueur de contexte effective de 128 000 tokens, soit environ 350 pages de texte dactylographié, en fonction de la langue. Par exemple, les langues basées sur le cyrillique ont souvent des tokens plus courts en raison de la morphologie et de l'utilisation de préfixes, de suffixes, etc.

Pipeline de raisonnement

La construction de modèles capables de raisonner est un processus fascinant mais laborieux qui combine plusieurs techniques existantes visant à simuler la pensée humaine. Sur la base des informations publiquement disponibles, nous pouvons supposer que la formation au raisonnement de Qwen 3 s'est déroulée en quatre étapes principales :

Cold start for long chains of thought. Entraînement du modèle à décomposer les problèmes en plusieurs étapes sans adaptation préalable. Cela l'aide à apprendre la pensée itérative et à développer une couche de base de compétences de raisonnement.
Reinforcement learning based on reasoning. À ce stade, les récompenses dépendent non seulement de la réponse finale, mais aussi de la manière dont le modèle construit des chaînes de raisonnement logiques, interprétables et structurées. L'absence d'erreurs et d'hallucinations est également évaluée.
Merging reasoning modes. L'être humain s'appuie généralement sur deux styles de pensée : rapide (intuitif) et lent (analytique). En fonction du type de tâche, le modèle neuronal doit apprendre à passer d'un style à l'autre et à les intégrer. Cela se fait généralement à l'aide d'exemples qui mélangent les deux styles ou par le biais de jetons spéciaux indiquant le style à appliquer.
General reinforcement learning. Cette dernière étape ressemble à un environnement de bac à sable où le modèle apprend à interagir avec des outils, à effectuer des tâches en plusieurs étapes et à développer un comportement adaptatif. C'est également à ce stade qu'il s'adapte aux préférences de l'utilisateur.

Conclusion

Qwen 3 est une étape importante pour Alibaba Group. Sa qualité de formation et sa méthodologie en font un concurrent sérieux face à des acteurs établis comme OpenAI et Anthropic. Les améliorations par rapport à la version précédente sont substantielles.

Un avantage supplémentaire est sa nature open-source, avec la base de code disponible publiquement sur GitHub sous la licence Apache 2.0.

La poursuite du développement de la famille de modèles Qwen contribuera à renforcer sa position dans l'arène mondiale de l'IA et à réduire l'écart avec les modèles commerciaux à source fermée. Toutes les réalisations actuelles sont, d'une manière ou d'une autre, des étapes vers le progrès de l'humanité dans la construction de l'AGI.

Voir aussi :

Serveur MCP basé sur le N8N

Wed, 02 Jul 2025 15:28:18 +0200

Le développement des réseaux neuronaux génératifs s'est considérablement accéléré ces dernières années. Ils sont devenus nettement plus rapides et plus précis dans leurs réponses et ont appris à raisonner. Cependant, leurs capacités sont encore fondamentalement limitées par leur architecture. Par exemple, chaque LLM existant au moment de la rédaction du présent document a une date limite de connaissance. Cela signifie que chaque jour qui passe, un tel LLM devient plus susceptible de produire des réponses incorrectes, simplement parce qu'il manque d'informations sur les événements qui se sont produits après cette date.

Cette limitation nécessite de réentraîner le modèle entièrement sur des données plus fraîches, ce qui est coûteux et prend du temps. Mais il existe une autre solution. Si vous permettez au modèle d'interagir avec le monde extérieur, il peut trouver et mettre à jour de manière indépendante les informations demandées lors d'une conversation avec l'utilisateur, sans avoir besoin d'être réentraîné.

C'est à peu près ainsi que fonctionne le mécanisme RAG (Retrieval Augmented Generation). Lorsqu'il répond à une question, le modèle interroge d'abord une base de données vectorielles préparée à l'avance et, s'il trouve des informations pertinentes, il les incorpore à l'invite. Ainsi, en expliquant et en mettant à jour la base de données vectorielle, la qualité des réponses LLM peut être grandement améliorée.

Mais il existe un autre moyen, encore plus intéressant, d'intégrer un contexte actualisé dans les messages-guides. Il s'agit du MCP, qui signifie Model Context Protocol (protocole de contexte de modèle). Il a été développé à l'origine par Anthropic pour son modèle Claude. Le moment clé a été l'ouverture du code source du MCP, qui a permis à des milliers de chercheurs en IA de construire des serveurs personnalisés à des fins diverses.

L'essence de MCP est de donner à un modèle de réseau neuronal l'accès à des outils qui lui permettent de mettre à jour ses connaissances de manière indépendante et d'effectuer diverses actions pour résoudre efficacement des tâches données. C'est le modèle lui-même qui décide de l'outil à utiliser et de son adéquation à chaque situation.

La prise en charge du MCP est rapidement apparue dans divers IDE tels que Cursor, ainsi que dans des plates-formes d'automatisation telles que N8N. Cette dernière est particulièrement intuitive, car les flux de travail sont créés visuellement, ce qui les rend plus faciles à comprendre. Dans N8N, vous pouvez vous connecter à un serveur MCP existant ou créer votre propre serveur. En outre, vous pouvez même organiser une connexion directe au sein d'un seul flux de travail. Mais allons-y pas à pas.

Création d'un agent IA simple

Avant de commencer, assurez-vous que l'exigence principale est remplie, vous avez un LLM prêt pour les connexions. Il peut s'agir d'un modèle local utilisant Ollama ou d'un service externe comme ChatGPT d'OpenAI. Dans le premier cas, vous aurez besoin de connaître l'adresse de l'API locale d'Ollama (et éventuellement son authentification), et dans le second cas, vous aurez besoin d'un compte OpenAI actif avec suffisamment de crédits.

La construction d'un agent commence par le nœud clé AI Agent. Au minimum, il doit être lié à deux autres nœuds, l'un pour servir de déclencheur et l'autre pour se connecter au LLM. Si vous ne spécifiez pas de déclencheur, le système en créera un automatiquement, déclenchant l'agent à la réception de n'importe quel message dans le chat interne :

La seule pièce manquante est le LLM. Vous pouvez par exemple utiliser notre Open WebUI : Tout en un pour configurer Ollama avec une interface web. Le seul changement requis est que les conteneurs du N8N et de l'Open WebUI doivent être sur le même réseau. Par exemple, si le conteneur N8N est sur un réseau nommé web, alors dans la commande de déploiement pour Open WebUI, remplacez --network=host par --network=web.

Dans certains cas, vous devrez également définir manuellement la variable d'environnement OLLAMA_HOST, par exemple : -e OLLAMA_HOST=0.0.0.0. Cela permet de se connecter à l'API Ollama non seulement à partir de l'hôte local, mais aussi à partir d'autres conteneurs. Supposons qu'Ollama soit déployé dans un conteneur nommé ollama-webui. L'URL de base pour se connecter à partir de N8N serait alors :

http://open-webui:11434

Avant de connecter le nœud Ollama Chat Model, n'oubliez pas de télécharger au moins un modèle. Vous pouvez le faire depuis l'interface web ou via le CLI du conteneur. La commande suivante téléchargera le modèle Llama 3.1 avec 8 milliards de paramètres :

ollama pull llama3.1:8b

Une fois téléchargé et installé, le modèle apparaîtra automatiquement dans la liste des modèles disponibles :

Un flux de travail minimal d'agent d'intelligence artificielle ressemble à ceci :

Sous cette forme, l'agent ne peut utiliser qu'un seul modèle et ne stocke pas les données d'entrée ni n'améliore les invites à l'aide d'outils externes. Il est donc logique d'ajouter au moins le nœud Simple Memory. Pour les charges légères, il suffit de stocker les demandes et les réponses.

Mais revenons à MCP. Pour commencer, créez un serveur en utilisant le nœud spécial MCP Server Trigger:

Ce nœud est entièrement autonome et ne nécessite aucune activation externe. Il est déclenché uniquement par une requête externe entrante à son adresse webhook. Par défaut, il existe deux URL : Test URL et Production URL. La première est utilisée pendant le développement, tandis que la seconde ne fonctionne que lorsque le flux de travail est sauvegardé et activé.

Le déclencheur est inutile en soi, il a besoin d'outils connectés. Par exemple, connectons l'un des outils les plus simples : une calculatrice. Elle attendra une expression mathématique en entrée. Les nœuds communiquent à l'aide de JSON, de sorte que pour que la calculatrice calcule 2 + 2, l'entrée doit être :

[
  {
    "query": {
      "input": "2 + 2"
    }
  }
]

Les LLM peuvent facilement générer ce type de JSON à partir de descriptions de tâches en texte brut et les envoyer au nœud, qui effectue les calculs et renvoie le résultat. Connectons le client MCP à l'agent :

Il convient de noter que ce nœud n'a besoin d'aucune connexion supplémentaire. Dans ses paramètres, il suffit de spécifier l'adresse du point de terminaison où il enverra les données de l'agent IA. Dans notre exemple, cette adresse pointe vers le conteneur nommé n8n.

Bien sûr, à ce stade, vous pouvez spécifier n'importe quelle adresse de serveur MCP externe disponible. Mais pour cet article, nous utiliserons une instance locale fonctionnant au sein de N8N. Voyons comment le client et le serveur se comportent lorsqu'il est demandé à l'agent AI d'effectuer une simple opération mathématique :

Dès qu'il reçoit la demande, l'agent d'intelligence artificielle.. :

Rechercher dans la mémoire simple si l'utilisateur a déjà demandé cette opération ou si un contexte peut être réutilisé.
Envoyer l'invite au LLM, qui décomposera correctement l'expression mathématique et préparera le JSON correspondant.
Envoyez le JSON à la calculatrice et recevez le résultat.
Utilisez le LLM pour générer la réponse finale et insérez le résultat dans la réponse.
Stocker le résultat dans la mémoire simple.
Produire le message dans le chat.

De même, les agents peuvent travailler avec d'autres outils sur le serveur MCP. Au lieu de la mémoire simple, vous pouvez utiliser des options plus avancées comme MongoDB, Postgres, Redis, ou même quelque chose comme Zep. Bien entendu, ces options nécessitent une maintenance minimale de la base de données, mais les performances globales augmenteront de manière significative.

Il existe également beaucoup plus d'options pour la sélection des outils. Dans sa version initiale, le nœud MCP Server Trigger prend en charge plus de 200 outils. Il peut s'agir de n'importe quoi, depuis de simples requêtes HTTP jusqu'à des intégrations préconstruites avec des services internet publics. Au sein d'un même flux de travail, vous pouvez créer à la fois un serveur et un client. Une chose importante à noter : ces nœuds ne peuvent pas être connectés visuellement dans l'éditeur, et c'est le comportement attendu :

Au lieu du déclencheur par défaut, vous pouvez utiliser d'autres options telles que la réception d'un message par l'intermédiaire d'un messager, la soumission d'un formulaire sur un site web ou l'exécution selon un calendrier. Cela vous permet de mettre en place des flux de travail qui réagissent à des événements ou effectuent des opérations de routine, comme l'exportation quotidienne de données de Google Ads.

Les possibilités offertes par les agents d'intelligence artificielle ne s'arrêtent pas là. Vous pouvez construire des systèmes multi-agents utilisant différents modèles de réseaux neuronaux qui travaillent ensemble pour résoudre des tâches avec une plus grande précision, en tenant compte de beaucoup plus de facteurs d'influence dans le processus.

Voir aussi :

Comment installer N8N

Mon, 23 Jun 2025 14:30:26 +0200

En 2025, les agents d'intelligence artificielle restent l'une des approches les plus prometteuses pour résoudre des tâches complexes à l'aide de grands modèles linguistiques. Ces agents sont autonomes et capables de sélectionner eux-mêmes divers outils pour accomplir les tâches qui leur sont confiées. Cette approche permet d'obtenir des résultats avec moins d'implication humaine et une meilleure qualité. Elle ouvre également la voie à la découverte de méthodes plus originales et plus efficaces pour traiter les problèmes.

Au lieu de simplement formuler une tâche, vous demandez au réseau neuronal de la résoudre de manière autonome, en fonction des ressources qui lui sont allouées. Toutefois, pour que ce système fonctionne, il faut un mécanisme qui relie les interfaces des réseaux neuronaux à divers outils, qu'il s'agisse d'une recherche sur le web ou d'une base de données vectorielles pour le stockage des résultats intermédiaires.

n8n est une plateforme d'automatisation qui prend en charge l'intégration de divers réseaux neuronaux et services publics. Les utilisateurs peuvent concevoir visuellement la manière dont les données seront traitées et le résultat final à obtenir. Contrairement aux solutions classiques sans code, n8n permet d'inclure du code arbitraire à n'importe quelle étape du processus, ce qui est particulièrement utile lorsque les fonctionnalités intégrées ne sont pas suffisantes.

Le résultat est un système qui combine la simplicité de l'absence de code avec la flexibilité de la programmation traditionnelle. Cependant, pour bien le comprendre, vous devrez passer du temps à explorer et à examiner des exemples de flux de travail pour une meilleure compréhension. Dans cet article, nous allons vous expliquer comment déployer n8n sur les serveurs LeaderGPU.

Préparation du serveur

Mise à jour du système

Mettre à jour la liste des paquets et mettre à niveau tous les paquets installés :

sudo apt update && sudo apt -y upgrade

Installez automatiquement le pilote NVIDIA® recommandé (propriétaire) ou utilisez notre guide pas à pas Installer les pilotes NVIDIA® sous Linux:

sudo ubuntu-drivers autoinstall

Redémarrez le serveur :

sudo shutdown -r now

Installer Docker

Vous pouvez utiliser le script d'installation officiel :

curl -sSL https://get.docker.com/ | sh

Ajoutons la clé GPG du NVIDIA® container toolkit et le dépôt pour l'intégration de Docker :

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Mettez à jour la liste des paquets et installez le NVIDIA® container toolkit :

sudo apt update && sudo apt -y install nvidia-container-toolkit

Redémarrez Docker pour appliquer les changements et activer le toolkit installé :

sudo systemctl restart docker

Installer n8n

Pour permettre au système de stocker des données, vous devez créer un volume avant de lancer le conteneur :

sudo docker volume create n8n_data

Lançons maintenant un conteneur qui ouvrira le port 5678 pour les connexions externes et montera le volume n8n_data créé dans le répertoire /home/node/.n8n à l'intérieur du conteneur :

sudo docker run -d --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

La première fois que vous lancerez l'application, vous serez peut-être surpris par le message d'erreur suivant :

Il ne s'agit pas vraiment d'une erreur, mais plutôt d'un avertissement sur la manière de configurer correctement le système pour l'accès. Le problème est que, par défaut, le système ne dispose pas d'un certificat TLS/HTTPS. Sans ce certificat, la connexion ne sera pas sécurisée. Vous avez donc trois options :

Connect your own certificate. Vous pouvez le faire en spécifiant les chemins d'accès aux fichiers de certificat via des variables d'environnement, ou en configurant un serveur proxy inverse.
Create an SSH tunnel and forward port 5678 Pour ce faire, vous pouvez utiliser le nom de l'hôte local sur l'ordinateur à partir duquel vous vous connectez. De cette manière, vous obtiendrez immédiatement une connexion personnelle sécurisée. Cependant, personne d'autre ne pourra accéder au serveur de manière externe.
Bypass the warning. S'il s'agit d'un serveur de test qui n'est pas destiné à être utilisé en production et que vous ne vous souciez pas de la sécurité, vous pouvez désactiver l'avertissement en définissant la variable d'environnement N8N_SECURE_COOKIE à FALSE. Cette pratique est fortement déconseillée car elle rend le serveur vulnérable à des attaques potentielles. Néanmoins, cela peut être acceptable dans certains cas.

Cet article explorera chaque option en détail afin que vous puissiez choisir la bonne.

Connexion au serveur

Si vous n'avez pas encore de certificat SSL, nous vous recommandons d'en commander un sur LeaderSSL. Il peut être utilisé pour n'importe quel site web, magasin en ligne ou pour vérifier l'authenticité d'un courriel.

Utilisation des variables d'environnement

La manière la plus simple de configurer HTTPS est de télécharger votre certificat sur le serveur et de le spécifier via les variables d'environnement Docker. Commencez par créer un répertoire pour les fichiers du certificat :

mkdir ~/n8n-certs

Vous pouvez télécharger ces fichiers (généralement cert.crt et privkey.key) dans ce répertoire en utilisant n'importe quelle méthode. Pour plus d'informations, voir :

Lançons maintenant le conteneur à l'aide d'une commande complète :

sudo docker run -d \
--name n8n \
-p 5678:5678 \
-v n8n_data:/home/node/.n8n \
-v ~/n8n-certs:/certs \
-e N8N_PROTOCOL=https \
-e N8N_SSL_CERT="/certs/cert.crt" \
-e N8N_SSL_KEY="/certs/privkey.key" \
docker.n8n.io/n8nio/n8n

Voici une description détaillée de chaque argument :

sudo docker run -d lance le conteneur Docker en mode démon (arrière-plan)
--name n8n attribue un nom au conteneur n8n
-p 5678:5678 transmet le port 5678 au conteneur
-v n8n_data:/home/node/.n8n crée et monte un volume nommé n8n_data dans le répertoire caché /home/node/.n8n à l'intérieur du conteneur
-v ~/n8n-certs:/certs monte le répertoire des certificats
-e N8N_PROTOCOL=https force N8N à utiliser le protocole HTTPS
-e N8N_SSL_CERT="/certs/cert.crt" définit le chemin d'accès au fichier de certificat
-e N8N_SSL_KEY="/certs/privkey.key" définit le chemin d'accès à la clé du certificat
docker.n8n.io/n8nio/n8n source de l'image du conteneur

Traefik

Une configuration un peu plus complexe mais flexible consiste à utiliser le serveur proxy inverse Traefik pour sécuriser la connexion à N8N. Le fichier de configuration est basé sur la méthode officielle spécifiée dans la documentation. Tout d'abord, installez l'outil docker-compose:

sudo apt -y install docker-compose

Nous allons déployer Traefik et N8N ensemble, et ils doivent être sur le même réseau. Créez un réseau appelé web.

sudo docker network create web

Maintenant, créez un fichier docker-compose.yml pour définir et exécuter les deux conteneurs :

nano docker-compose.yml

services:
  traefik:
    image: "traefik"
    container_name: "proxy"
    restart: always
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.mytlschallenge.acme.tlschallenge=true"
      - "--certificatesresolvers.mytlschallenge.acme.email=${SSL_EMAIL}"
      - "--certificatesresolvers.mytlschallenge.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - traefik_data:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: "n8n"
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    labels:
      - traefik.enable=true
      - traefik.http.routers.n8n.rule=Host(`${SUBDOMAIN}.${DOMAIN_NAME}`)
      - traefik.http.routers.n8n.tls=true
      - traefik.http.routers.n8n.entrypoints=web,websecure
      - traefik.http.routers.n8n.tls.certresolver=mytlschallenge
      - traefik.http.middlewares.n8n.headers.SSLRedirect=true
      - traefik.http.middlewares.n8n.headers.STSSeconds=315360000
      - traefik.http.middlewares.n8n.headers.browserXSSFilter=true
      - traefik.http.middlewares.n8n.headers.contentTypeNosniff=true
      - traefik.http.middlewares.n8n.headers.forceSTSHeader=true
      - traefik.http.middlewares.n8n.headers.SSLHost=${DOMAIN_NAME}
      - traefik.http.middlewares.n8n.headers.STSIncludeSubdomains=true
      - traefik.http.middlewares.n8n.headers.STSPreload=true
      - traefik.http.routers.n8n.middlewares=n8n@docker
    environment:
      - N8N_HOST=${SUBDOMAIN}.${DOMAIN_NAME}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://${SUBDOMAIN}.${DOMAIN_NAME}/
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
    volumes:
      - n8n_data:/home/node/.n8n
      - ./local-files:/files
    networks:
      - web

volumes:
  n8n_data:
  traefik_data:

networks:
  web:
    name: web

En plus du fichier docker-compose.yml, nous allons créer un autre fichier nommé .env. Ce fichier contiendra des variables telles que le nom de domaine et l'adresse électronique utilisés pour demander un certificat SSL à Let's Encrypt. Si nous devons changer quelque chose, comme le nom de domaine, il nous suffira de le mettre à jour dans ce fichier et de recréer le conteneur.

nano .env

DOMAIN_NAME=example.com
SUBDOMAIN=n8n
GENERIC_TIMEZONE=Europe/Amsterdam
SSL_EMAIL=user@example.com

Enfin, déployez les deux conteneurs :

sudo docker-compose up -d

Maintenant, N8N est disponible ici : https://n8n.example.com.

Gestionnaire de proxy Nginx

Contrairement à Traefik, qui est configuré via des fichiers, Nginx Proxy Manager offre une interface web conviviale. Cependant, il ne détecte pas les services de manière dynamique, vous devez les ajouter manuellement. Néanmoins, il fonctionne bien pour les services statiques comme N8N.

Créez un autre fichier docker-compose.yml dans un répertoire séparé avec le contenu suivant :

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: proxy
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '81:81'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    environment:
      - N8N_HOST=n8n.example.com
      - N8N_PORT=5678
      - WEBHOOK_URL=https://n8n.example.com/
      - N8N_PROTOCOL=http
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - web

volumes:
  n8n_data:

networks:
  web:
    external: true

Déployer avec :

sudo docker-compose up -d

Ouvrez ensuite l'interface web à l'adresse suivante http://your_hostname_or_ip:81

Nom d'utilisateur : admin@example.com
Mot de passe : changeme

Vous serez invité à mettre à jour vos informations d'identification. Ensuite, ouvrez Hosts → Proxy Hosts → Add Proxy Host, entrez votre nom de domaine (par exemple, n8n.example.com) :

Remplissez les champs nécessaires :

Remplacez Destination/IP par n8n.
Réglez Port sur 5678.
Sous l'onglet SSL, choisissez Request a new SSL certificate with Let’s Encrypt.
Saisissez votre adresse électronique et acceptez les conditions.
Cliquez sur Websockets support.
Cliquez éventuellement sur Force SSL.

Après avoir appuyé sur le bouton Save, le certificat sera demandé et installé :

Une fois cela fait, l'ouverture de votre domaine conduira à l'interface N8N.

Tunnel SSH

Si vous n'avez pas besoin de l'accessibilité externe de N8N, vous pouvez transférer le port 5678 via SSH. Cela crypte tout le trafic, et N8N sera disponible à l'adresse http://localhost:5678/.

Remarque : cette configuration ne fonctionnera pas pour les intégrations avec des services externes tels que les messageries qui nécessitent un accès HTTPS public.

La manière la plus simple de transférer le port est d'utiliser le client SSH populaire PuTTY. Une fois installé, ouvrez SSH → Tunnels et définissez Source port - 5678 et Destination - localhost:5678. Cliquez ensuite sur Add.

Retournez à Session, entrez l'IP de votre serveur et cliquez sur Open. Une fois authentifié, le tunnel est actif. Ouvrez http://localhost:5678 dans un navigateur pour accéder à N8N.

Remarque : la connexion ne fonctionne que lorsque la session SSH est active. La fermeture de PuTTY met fin au tunnel.

Contournement

Cette méthode n'est pas recommandée sur les réseaux publics. Si vous lancez le conteneur avec la variable d'environnement N8N_SECURE_COOKIE=false, l'avertissement disparaîtra et vous accéderez au tunnel via HTTP :

sudo docker run -d --name n8n -p 5678:5678 -e N8N_SECURE_COOKIE=false -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Warning: cela expose le panneau d'administration de N8N via HTTP non chiffré, ce qui le rend vulnérable aux attaques MITM (Man-In-The-Middle) et permet potentiellement à un attaquant de prendre entièrement le contrôle de votre serveur.

Voir aussi:

Triton™ Inference Server

Wed, 26 Feb 2025 16:40:21 +0100

Les exigences des entreprises peuvent varier, mais elles partagent toutes un principe fondamental : les systèmes doivent fonctionner rapidement et offrir la meilleure qualité possible. Lorsqu'il s'agit d'inférence de réseaux neuronaux, l'utilisation efficace des ressources informatiques devient cruciale. Toute sous-utilisation du GPU ou tout temps d'inactivité se traduit directement par des pertes financières.

Prenons l'exemple d'une place de marché. Ces plateformes hébergent de nombreux produits, chacun avec de multiples attributs : descriptions textuelles, spécifications techniques, catégories et contenu multimédia comme des photos et des vidéos. Tous les contenus doivent être modérés afin de maintenir des conditions équitables pour les vendeurs et d'éviter que des produits interdits ou des contenus illégaux n'apparaissent sur la plateforme.

La modération manuelle est possible, mais elle est lente et inefficace. Dans l'environnement concurrentiel actuel, les vendeurs doivent élargir rapidement leur gamme de produits : plus les articles apparaissent rapidement sur la place de marché, plus ils ont de chances d'être découverts et achetés. La modération manuelle est également coûteuse et sujette à l'erreur humaine, ce qui risque de laisser passer des contenus inappropriés.

La modération automatique à l'aide de réseaux neuronaux spécialement entraînés offre une solution. Cette approche présente de multiples avantages : elle réduit considérablement les coûts de modération tout en améliorant généralement la qualité. Les réseaux neuronaux traitent les contenus beaucoup plus rapidement que les humains, ce qui permet aux vendeurs de passer plus vite l'étape de la modération, en particulier lorsqu'ils traitent de gros volumes de produits.

Cette approche n'est pas sans poser de problèmes. La mise en œuvre de la modération automatisée nécessite le développement et l'entraînement de modèles de réseaux neuronaux, ce qui requiert à la fois du personnel qualifié et des ressources informatiques considérables. Toutefois, les avantages apparaissent rapidement après la mise en œuvre initiale. L'ajout d'un déploiement automatisé des modèles peut considérablement rationaliser les opérations en cours.

Inférence

Supposons que nous ayons compris les procédures d'apprentissage automatique. L'étape suivante consiste à déterminer comment exécuter l'inférence du modèle sur un serveur loué. Pour un modèle unique, vous choisissez généralement un outil qui fonctionne bien avec le cadre spécifique sur lequel il a été construit. Cependant, lorsqu'il s'agit de plusieurs modèles créés dans des cadres différents, deux options s'offrent à vous.

Vous pouvez soit convertir tous les modèles dans un format unique, soit choisir un outil qui prend en charge plusieurs cadres. Le serveur d'inférence Triton™ s'inscrit parfaitement dans la deuxième approche. Il prend en charge les backends suivants :

TensorRT™
TensorRT-LLM
vLLM
Python
PyTorch (LibTorch)
ONNX Runtime
Tensorflow
FIL
DALI

En outre, vous pouvez utiliser n'importe quelle application comme backend. Par exemple, si vous avez besoin d'un post-traitement avec une application C/C++, vous pouvez l'intégrer de manière transparente.

Mise à l'échelle

Triton™ Inference Server gère efficacement les ressources informatiques sur un seul serveur en exécutant plusieurs modèles simultanément et en répartissant la charge de travail sur les GPU.

L'installation se fait par le biais d'un conteneur Docker. Les ingénieurs DevOps peuvent contrôler l'allocation des GPU au démarrage, en choisissant d'utiliser tous les GPU ou d'en limiter le nombre. Bien que le logiciel ne gère pas directement la mise à l'échelle horizontale, vous pouvez utiliser des équilibreurs de charge traditionnels comme HAproxy ou déployer des applications dans un cluster Kubernetes à cette fin.

Préparation du système

Pour configurer Triton™ sur un serveur LeaderGPU fonctionnant sous Ubuntu 22.04, commencez par mettre à jour le système à l'aide de cette commande :

sudo apt update && sudo apt -y upgrade

Tout d'abord, installez les pilotes NVIDIA® à l'aide du script d'installation automatique :

sudo ubuntu-drivers autoinstall

Redémarrez le serveur pour appliquer les modifications :

sudo shutdown -r now

Une fois le serveur remis en ligne, installez Docker à l'aide du script d'installation suivant :

curl -sSL https://get.docker.com/ | sh

Étant donné que Docker ne peut pas transmettre les GPU aux conteneurs par défaut, vous aurez besoin du NVIDIA® Container Toolkit. Ajoutez le dépôt NVIDIA® en téléchargeant et en enregistrant sa clé GPG :

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Mettez à jour le cache des paquets et installez la boîte à outils :

sudo apt update && sudo apt -y install nvidia-container-toolkit

Redémarrer Docker pour activer les nouvelles capacités :

sudo systemctl restart docker

Le système d'exploitation est maintenant prêt à être utilisé.

Installation du serveur d'inférence Triton™

Téléchargez le référentiel du projet :

git clone https://github.com/triton-inference-server/server

Ce référentiel contient des échantillons de réseaux neuronaux préconfigurés et un script de téléchargement de modèle. Naviguez jusqu'au répertoire examples :

cd server/docs/examples

Téléchargez les modèles en exécutant le script suivant, qui les enregistrera à l'adresse ~/server/docs/examples/model_repository:

./fetch_models.sh

L'architecture du serveur d'inférence Triton™ exige que les modèles soient stockés séparément. Vous pouvez les stocker localement dans n'importe quel répertoire du serveur ou sur le réseau de stockage. Lorsque vous démarrez le serveur, vous devez monter ce répertoire dans le conteneur au point de montage /models. Ce répertoire sert de dépôt pour toutes les versions des modèles.

Lancez le conteneur à l'aide de la commande suivante

sudo docker run --gpus=all --rm -p8000:8000 -p8001:8001 -p8002:8002 -v ~/server/docs/examples/model_repository:/models nvcr.io/nvidia/tritonserver:25.01-py3 tritonserver --model-repository=/models

Voici ce que fait chaque paramètre :

--gpus=all spécifie que tous les GPU disponibles seront utilisés dans le serveur ;
--rm détruit le conteneur une fois le processus terminé ou arrêté ;
-p8000:8000 transmet le port 8000 pour recevoir les requêtes HTTP ;
-p8001:8001 transmet le port 8001 pour recevoir les requêtes gRPC ;
-p8002:8002 transmet le port 8002 pour demander des métriques ;
-v ~/server/docs/examples/model_repository:/models transmet le répertoire contenant les modèles ;
nvcr.io/nvidia/tritonserver:25.01-py3 l'adresse du conteneur du catalogue NGC™ ;
tritonserver --model-repository=/models lance le serveur d'inférence Triton™ avec l'emplacement du référentiel de modèles à /models.

La sortie de la commande montrera tous les modèles disponibles dans le référentiel, chacun étant prêt à accepter des requêtes :

+----------------------+---------+--------+
| Model                | Version | Status |
+----------------------+---------+--------+
| densenet_onnx        | 1       | READY  |
| inception_graphdef   | 1       | READY  |
| simple               | 1       | READY  |
| simple_dyna_sequence | 1       | READY  |
| simple_identity      | 1       | READY  |
| simple_int8          | 1       | READY  |
| simple_sequence      | 1       | READY  |
| simple_string        | 1       | READY  |
+----------------------+---------+--------+

Les trois services ont été lancés avec succès sur les ports 8000, 8001 et 8002 :

I0217 08:00:34.930188 1 grpc_server.cc:2466] Started GRPCInferenceService at 0.0.0.0:8001
I0217 08:00:34.930393 1 http_server.cc:4636] Started HTTPService at 0.0.0.0:8000
I0217 08:00:34.972340 1 http_server.cc:320] Started Metrics Service at 0.0.0.0:8002

En utilisant l'utilitaire nvtop, nous pouvons vérifier que tous les GPU sont prêts à accepter la charge :

Installation du client

Pour accéder à notre serveur, nous devons générer une requête appropriée à l'aide du client inclus dans le SDK. Nous pouvons télécharger ce SDK sous la forme d'un conteneur Docker :

sudo docker pull nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Exécutez le conteneur en mode interactif pour accéder à la console :

sudo docker run -it --gpus=all --rm --net=host nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Testons ceci avec le modèle DenseNet au format ONNX, en utilisant la méthode INCEPTION pour prétraiter et analyser l'image mug.jpg:

/workspace/install/bin/image_client -m densenet_onnx -c 3 -s INCEPTION /workspace/images/mug.jpg

Le client contactera le serveur, qui créera un lot et le traitera en utilisant les GPU disponibles du conteneur. Voici le résultat :

Request 0, batch size 1
Image '/workspace/images/mug.jpg':
   15.349562 (504) = COFFEE MUG
   13.227461 (968) = CUP
   10.424891 (505) = COFFEEPOT

Préparation du dépôt

Pour que Triton™ gère correctement les modèles, vous devez préparer le référentiel d'une manière spécifique. Voici la structure du répertoire :

model_repository/ 
        └── your_model/ 
                ├── config.pbtxt 
                └── 1/
                    └── model.*

Chaque modèle a besoin de son propre répertoire contenant un fichier de configuration config.pbtxt avec sa description. Voici un exemple :

name: "Test"
platform: "pytorch_libtorch"
max_batch_size: 8
input [
  {
    name: "INPUT_0"
    data_type: TYPE_FP32
    dims: [ 3, 224, 224 ]
  }
]
output [
  {
    name: "OUTPUT_0"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]

Dans cet exemple, un modèle nommé Test sera exécuté sur le backend PyTorch. Le paramètre max_batch_size définit le nombre maximal d'éléments pouvant être traités simultanément, ce qui permet d'équilibrer efficacement la charge entre les ressources. La définition de cette valeur à zéro désactive la mise en lot, ce qui fait que le modèle traite les demandes de manière séquentielle.

Le modèle accepte une entrée et produit une sortie, toutes deux utilisant le type de nombre FP32. Les paramètres doivent correspondre exactement aux exigences du modèle. Pour le traitement d'images, une spécification de dimension typique est dims: [ 3, 224, 224 ], où :

3 - nombre de canaux de couleur (RVB) ;
224 - hauteur de l'image en pixels ;
224 - largeur de l'image en pixels.

La sortie dims: [ 1000 ] représente un vecteur unidimensionnel de 1000 éléments, ce qui convient aux tâches de classification d'images. Pour déterminer la dimensionnalité correcte de votre modèle, consultez sa documentation. Si le fichier de configuration est incomplet, Triton™ tentera de générer automatiquement les paramètres manquants.

Lancement d'un modèle personnalisé

Lançons l'inférence du modèle DeepSeek-R1 distillé dont nous avons parlé précédemment. Tout d'abord, nous allons créer la structure de répertoire nécessaire :

mkdir ~/model_repository && mkdir ~/model_repository/deepseek && mkdir ~/model_repository/deepseek/1

Naviguez jusqu'au répertoire du modèle :

cd ~/model_repository/deepseek

Créer un fichier de configuration config.pbtxt:

nano config.pbtxt

Collez les éléments suivants :

# Copyright 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
# Note: You do not need to change any fields in this configuration.
    
backend: "vllm"
    
# The usage of device is deferred to the vLLM engine
instance_group [
  {
    count: 1
    kind: KIND_MODEL
  }
]

Enregistrez le fichier en appuyant sur Ctrl + O, puis l'éditeur avec Ctrl + X. Naviguez jusqu'au répertoire 1:

cd 1

Créer un fichier de configuration du modèle model.json avec les paramètres suivants :

{
    "model":"deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
    "disable_log_requests": true,
    "gpu_memory_utilization": 0.9,
    "enforce_eager": true
}

Notez que la valeur de gpu_memory_utilization varie selon le GPU et doit être déterminée expérimentalement. Pour ce guide, nous utiliserons 0.9. La structure de votre répertoire à l'intérieur de ~/model_repository devrait maintenant ressembler à ceci :

└── deepseek
        ├── 1
        │   └── model.json
        └── config.pbtxt

Définissez la variable LOCAL_MODEL_REPOSITORY pour plus de commodité :

LOCAL_MODEL_REPOSITORY=~/model_repository/

Démarrez le serveur d'inférence avec cette commande :

sudo docker run --rm -it --net host --shm-size=2g  --ulimit memlock=-1 --ulimit stack=67108864 --gpus all -v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository  nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 tritonserver --model-repository=model_repository/

Voici ce que fait chaque paramètre :

--rm supprime automatiquement le conteneur après l'avoir arrêté ;
-it exécute le conteneur en mode interactif avec une sortie terminal ;
--net L'hôte utilise la pile réseau de l'hôte au lieu de l'isolation du conteneur ;
--shm-size=2g fixe la mémoire partagée à 2 Go ;
--ulimit memlock=-1 supprime la limite de verrouillage de la mémoire ;
--ulimit stack=67108864 fixe la taille de la pile à 64 Mo ;
--gpus all autorise l'accès à tous les GPU du serveur ;
-v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository monte le répertoire du modèle local dans le conteneur ;
nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 spécifie le conteneur avec le support du backend vLLM ;
tritonserver --model-repository=model_repository/ lance le serveur d'inférence Triton™ avec l'emplacement du référentiel de modèles à model_repository.

Testez le serveur en envoyant une requête avec curl, en utilisant une simple invite et une limite de réponse de 4096 jetons :

curl -X POST localhost:8000/v2/models/deepseek/generate -d '{"text_input": "Tell me about the Netherlands?", "max_tokens": 4096}'

Le serveur reçoit et traite la demande avec succès.

Le planificateur de tâches interne de Triton™ traite toutes les demandes entrantes lorsque le serveur est en charge.

Conclusion

Le serveur d'inférence Triton™ excelle dans le déploiement de modèles d'apprentissage automatique en production en distribuant efficacement les demandes sur les GPU disponibles. Cela permet de maximiser l'utilisation des ressources serveur louées et de réduire les coûts de l'infrastructure informatique. Le logiciel fonctionne avec différents backends, notamment vLLM pour les modèles de langage de grande taille.

Comme il s'installe sous forme de conteneur Docker, vous pouvez facilement l'intégrer dans n'importe quel pipeline CI/CD moderne. Essayez-le vous-même en louant un serveur auprès de LeaderGPU.

DeepSeek-R1 : l'avenir des LLM

Wed, 19 Feb 2025 15:10:33 +0100

Bien que les réseaux neuronaux génératifs se soient développés rapidement, leur progression est restée relativement stable ces dernières années. Cette situation a changé avec l'arrivée de DeepSeek, un réseau neuronal chinois qui a non seulement eu un impact sur le marché boursier, mais qui a également attiré l'attention des développeurs et des chercheurs du monde entier. Contrairement à d'autres grands projets, le code de DeepSeek a été publié sous la licence permissive MIT. Cette évolution vers l'open source a été saluée par la communauté, qui s'est empressée d'explorer les capacités du nouveau modèle.

L'aspect le plus impressionnant est que l'entraînement de ce nouveau réseau neuronal aurait coûté 20 fois moins cher que les concurrents offrant une qualité similaire. La formation du modèle n'a nécessité que 55 jours et 5,6 millions de dollars. La publication de DeepSeek a déclenché l'une des plus fortes baisses en une seule journée de l'histoire des marchés boursiers américains. Bien que les marchés se soient finalement stabilisés, l'impact a été considérable.

Cet article examine dans quelle mesure les titres des médias reflètent la réalité et explore les configurations LeaderGPU adaptées à l'installation de ce réseau neuronal.

Caractéristiques architecturales

DeepSeek a choisi une voie d'optimisation maximale, ce qui n'est pas surprenant compte tenu des restrictions à l'exportation imposées par la Chine aux États-Unis. Ces restrictions empêchent le pays d'utiliser officiellement les modèles de GPU les plus avancés pour le développement de l'IA.

Le modèle utilise la technologie Multi Token Prediction (MTP), qui prédit plusieurs jetons en une seule étape d'inférence au lieu d'un seul. Cela fonctionne grâce à un décodage parallèle des jetons combiné à des couches masquées spéciales qui maintiennent l'autorégressivité.

Les essais de MTP ont donné des résultats remarquables, augmentant les vitesses de génération de 2 à 4 fois par rapport aux méthodes traditionnelles. L'excellente évolutivité de la technologie la rend précieuse pour les applications actuelles et futures de traitement du langage naturel.

Le modèle Multi-Head Latent Attention (MLA) est doté d'un mécanisme d'attention amélioré. Lorsque le modèle construit de longues chaînes de raisonnement, il maintient une attention ciblée sur le contexte à chaque étape. Cette amélioration permet de mieux gérer les concepts abstraits et les dépendances textuelles.

La principale caractéristique de MLA est sa capacité à ajuster dynamiquement les poids de l'attention à travers différents niveaux d'abstraction. Lors du traitement de requêtes complexes, MLA examine les données sous plusieurs angles : le sens des mots, la structure des phrases et le contexte général. Ces perspectives forment des couches distinctes qui influencent le résultat final. Pour maintenir la clarté, MLA équilibre soigneusement l'impact de chaque couche tout en restant concentré sur la tâche principale.

Les développeurs de DeepSeek ont intégré la technologie Mixture of Experts (MoE) dans le modèle. Elle contient 256 réseaux neuronaux experts pré-entraînés, chacun étant spécialisé dans des tâches différentes. Le système active 8 de ces réseaux pour chaque entrée de jeton, ce qui permet un traitement efficace des données sans augmenter les coûts de calcul.

Dans le modèle complet avec 671b paramètres, seuls 37b sont activés pour chaque jeton. Le modèle sélectionne intelligemment les paramètres les plus pertinents pour traiter chaque jeton entrant. Cette optimisation efficace permet d'économiser des ressources informatiques tout en maintenant des performances élevées.

Une caractéristique cruciale de tout chatbot à réseau neuronal est la longueur de sa fenêtre contextuelle. Llama 2 a une limite de contexte de 4 096 tokens, GPT-3.5 traite 16 284 tokens, tandis que GPT-4 et DeepSeek peuvent traiter jusqu'à 128 000 tokens (environ 100 000 mots, soit l'équivalent de 300 pages de texte dactylographié).

R - pour Reasoning (raisonnement)

DeepSeek-R1 a acquis un mécanisme de raisonnement similaire à celui de l'OpenAI o1, ce qui lui permet de traiter des tâches complexes de manière plus efficace et plus précise. Au lieu de fournir des réponses immédiates, le modèle élargit le contexte en générant un raisonnement étape par étape dans de petits paragraphes. Cette approche améliore la capacité du réseau neuronal à identifier les relations complexes entre les données, ce qui permet d'obtenir des réponses plus complètes et plus précises.

Lorsqu'il est confronté à une tâche complexe, DeepSeek utilise son mécanisme de raisonnement pour décomposer le problème en éléments et analyser chacun d'entre eux séparément. Le modèle synthétise ensuite ces résultats pour générer une réponse de l'utilisateur. Bien que cette approche semble idéale pour les réseaux neuronaux, elle s'accompagne de défis importants.

Tous les LLM modernes partagent un trait inquiétant : des hallucinations artificielles. Lorsqu'il est confronté à une question à laquelle il ne peut répondre, au lieu de reconnaître ses limites, le modèle peut générer des réponses fictives étayées par des faits inventés.

Appliquées à un réseau neuronal de raisonnement, ces hallucinations pourraient compromettre le processus de réflexion en fondant les conclusions sur des informations fictives plutôt que factuelles. Cela pourrait conduire à des conclusions erronées - un défi que les chercheurs et les développeurs de réseaux neuronaux devront relever à l'avenir.

Consommation de VRAM

Voyons comment exécuter et tester DeepSeek R1 sur un serveur dédié, en nous concentrant sur les besoins en mémoire vidéo du GPU.

Modèle	VRAM (Mo)	Taille du modèle (Gb)
deepseek-r1:1.5b	1,952	1.1
deepseek-r1:7b	5,604	4.7
deepseek-r1:8b	6,482	4.9
deepseek-r1:14b	10,880	9
deepseek-r1:32b	21,758	20
deepseek-r1:70b	39,284	43
deepseek-r1:671b	470,091	404

Les trois premières options (1.5b, 7b, 8b) sont des modèles de base qui peuvent gérer efficacement la plupart des tâches. Ces modèles fonctionnent sans problème avec n'importe quel GPU grand public doté de 6 à 8 Go de mémoire vidéo. Les versions intermédiaires (14b et 32b) sont idéales pour les tâches professionnelles mais nécessitent plus de VRAM. Les plus grands modèles (70b et 671b) nécessitent des GPU spécialisés et sont principalement utilisés pour la recherche et les applications industrielles.

Choix du serveur

Pour vous aider à choisir un serveur pour l'inférence DeepSeek, voici les configurations LeaderGPU idéales pour chaque groupe de modèles :

1.5b / 7b / 8b / 14b / 32b / 70b

Pour ce groupe, n'importe quel serveur avec les types de GPU suivants conviendra. La plupart des serveurs LeaderGPU exécuteront ces réseaux neuronaux sans problème. Les performances dépendent principalement du nombre de cœurs CUDA®. Nous recommandons les serveurs dotés de plusieurs GPU, tels que :

671b

Passons maintenant au cas le plus difficile : comment exécuter l'inférence sur un modèle dont la taille de base est de 404 Go ? Cela signifie qu'environ 470 Go de mémoire vidéo seront nécessaires. LeaderGPU propose plusieurs configurations avec les GPU suivants capables de gérer cette charge :

A100
H100

Les deux configurations gèrent la charge du modèle de manière efficace, en la répartissant de manière égale sur plusieurs GPU. Par exemple, voici à quoi ressemble un serveur avec 8xH100 après avoir chargé le modèle deepseek-r1:671b :

La charge de calcul s'équilibre dynamiquement entre les GPU, tandis que les interconnexions NVLink® à haut débit évitent les goulets d'étranglement dans l'échange de données, garantissant ainsi des performances maximales.

Conclusion

DeepSeek-R1 combine de nombreuses technologies innovantes telles que la prédiction multi-token, l'attention latente multi-têtes et le mélange d'experts en un seul modèle significatif. Ce logiciel open-source démontre que les LLM peuvent être développés plus efficacement avec moins de ressources informatiques. Le modèle comporte plusieurs versions, de la plus petite (1,5 milliard) à la plus grande (671 milliards), qui nécessitent du matériel spécialisé avec plusieurs GPU haut de gamme travaillant en parallèle.

En louant un serveur chez LeaderGPU pour l'inférence DeepSeek-R1, vous bénéficiez d'une large gamme de configurations, de fiabilité et de tolérance aux pannes. Notre équipe de support technique vous aidera en cas de problèmes ou de questions, tandis que l'installation automatique du système d'exploitation réduit le temps de déploiement.

Choisissez votre serveur LeaderGPU et découvrez les possibilités qui s"offrent à vous lorsque vous utilisez des modèles de réseaux neuronaux modernes. Si vous avez des questions, n'hésitez pas à les poser dans notre chat ou par e-mail.

Intel Habana Gaudi 2 : installation et test

Thu, 23 Jan 2025 13:41:09 +0100

Avant de commencer à installer le logiciel d'accélération Gaudi 2, il y a une caractéristique importante qui mérite d'être mentionnée. Nous sommes habitués au fait que l'entraînement et l'inférence des réseaux neuronaux peuvent être réalisés à l'aide de GPU. Cependant, Intel Habana Gaudi 2 est très différent des GPU et représente une classe différente de dispositifs conçus uniquement pour accélérer les tâches d'IA.

De nombreuses applications et cadres familiers ne fonctionneront pas sans une préparation préalable du système d'exploitation et, dans certains cas, sans un kit d'outils de migration GPU spécial. Cela explique le grand nombre d'étapes préparatoires que nous décrivons dans cet article. Commençons dans l'ordre.

Étape 1. Installer la pile logicielle SynapseAI

Pour commencer à travailler avec les accélérateurs Intel Habana Gaudi 2, vous devez installer la pile logicielle SynapseAI. Elle comprend un compilateur graphique spécial qui transforme la topologie du modèle de réseau neuronal pour optimiser efficacement l'exécution sur l'architecture Gaudi, des bibliothèques API pour la mise à l'échelle horizontale, ainsi qu'un SDK distinct pour la création d'algorithmes et de modèles d'apprentissage automatique de haute performance.

Séparément, nous notons que SynapseAI est la partie qui vous permet de créer un pont entre les cadres populaires tels que PyTorch/TensorFlow et les accélérateurs d'IA de Gaudi 2. Cela vous permet de travailler avec des abstractions familières, et Gaudi 2 optimise indépendamment les calculs. Les opérateurs spécifiques pour lesquels les accélérateurs n'ont pas de support matériel sont exécutés sur le CPU.

Pour simplifier l'installation des composants individuels de SynapseAI, un script shell pratique a été créé. Téléchargez-le :

wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.sh

Rendez le fichier exécutable :

chmod +x habanalabs-installer.sh

Exécuter le script :

./habanalabs-installer.sh install --type base

Suivez les invites du système pendant l'installation. Vous trouverez un rapport détaillé dans le fichier journal. Vous pouvez y voir quels paquets ont été installés et si les accélérateurs ont été trouvés et initialisés avec succès.

Les journaux sont ici : /var/log/habana_logs/install-YYYY-MM-DD-HH-MM-SS.log

[  +3.881647] habanalabs hl5: Found GAUDI2 device with 96GB DRAM
[  +0.008145] habanalabs hl0: Found GAUDI2 device with 96GB DRAM
[  +0.032034] habanalabs hl3: Found GAUDI2 device with 96GB DRAM
[  +0.002376] habanalabs hl4: Found GAUDI2 device with 96GB DRAM
[  +0.005174] habanalabs hl1: Found GAUDI2 device with 96GB DRAM
[  +0.000390] habanalabs hl2: Found GAUDI2 device with 96GB DRAM
[  +0.007065] habanalabs hl7: Found GAUDI2 device with 96GB DRAM
[  +0.006256] habanalabs hl6: Found GAUDI2 device with 96GB DRAM

Tout comme l'utilitaire nvidia-smi fournit des informations sur les GPU installés et les processus de calcul en cours, SynapseAI dispose d'un programme similaire. Vous pouvez le lancer pour obtenir un rapport sur l'état actuel des accélérateurs d'IA Gaudi 2 :

hl-smi

Étape 2. Test TensorFlow

TensorFlow est l'une des plateformes les plus populaires pour l'apprentissage automatique. En utilisant le même script d'installation, vous pouvez installer une version préconstruite de TensorFlow avec le support des accélérateurs Gaudi 2. Commençons par installer les dépendances générales :

./habanalabs-installer.sh install -t dependencies

Ensuite, nous allons installer les dépendances pour TensorFlow :

./habanalabs-installer.sh install -t dependencies-tensorflow

Installer la plateforme TensorFlow dans un environnement virtuel implémenté à l'aide du mécanisme Python Virtual Environment (venv) :

./habanalabs-installer.sh install --type tensorflow --venv

Activons l'environnement virtuel créé :

source habanalabs-venv/bin/activate

Créer un exemple de code Python simple qui utilisera les capacités des accélérateurs Gaudi 2 :

nano example.py


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import os
# Import Habana Torch Library
import habana_frameworks.torch.core as htcore
class SimpleModel(nn.Module):
   def __init__(self):
       super(SimpleModel, self).__init__()
       self.fc1   = nn.Linear(784, 256)
       self.fc2   = nn.Linear(256, 64)
       self.fc3   = nn.Linear(64, 10)
   def forward(self, x):
       out = x.view(-1,28*28)
       out = F.relu(self.fc1(out))
       out = F.relu(self.fc2(out))
       out = self.fc3(out)
       return out
def train(net,criterion,optimizer,trainloader,device):
   net.train()
   train_loss = 0.0
   correct = 0
   total = 0
   for batch_idx, (data, targets) in enumerate(trainloader):
       data, targets = data.to(device), targets.to(device)
       optimizer.zero_grad()
       outputs = net(data)
       loss = criterion(outputs, targets)
       loss.backward()
       # API call to trigger execution
       htcore.mark_step()
       optimizer.step()
       # API call to trigger execution
       htcore.mark_step()
       train_loss += loss.item()
       _, predicted = outputs.max(1)
       total += targets.size(0)
       correct += predicted.eq(targets).sum().item()
   train_loss = train_loss/(batch_idx+1)
   train_acc = 100.0*(correct/total)
   print("Training loss is {} and training accuracy is {}".format(train_loss,train_acc))
def test(net,criterion,testloader,device):
   net.eval()
   test_loss = 0
   correct = 0
   total = 0
   with torch.no_grad():
       for batch_idx, (data, targets) in enumerate(testloader):
           data, targets = data.to(device), targets.to(device)
           outputs = net(data)
           loss = criterion(outputs, targets)
           # API call to trigger execution
           htcore.mark_step()
           test_loss += loss.item()
           _, predicted = outputs.max(1)
           total += targets.size(0)
           correct += predicted.eq(targets).sum().item()
   test_loss = test_loss/(batch_idx+1)
   test_acc = 100.0*(correct/total)
   print("Testing loss is {} and testing accuracy is {}".format(test_loss,test_acc))
def main():
   epochs = 20
   batch_size = 128
   lr = 0.01
   milestones = [10,15]
   load_path = './data'
   save_path = './checkpoints'
   if(not os.path.exists(save_path)):
       os.makedirs(save_path)
   # Target the Gaudi HPU device
   device = torch.device("hpu")
   # Data
   transform = transforms.Compose([
       transforms.ToTensor(),
   ])
   trainset = torchvision.datasets.MNIST(root=load_path, train=True,
                                           download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
   testset = torchvision.datasets.MNIST(root=load_path, train=False,
                                       download=True, transform=transform)
   testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
   net = SimpleModel()
   net.to(device)
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(net.parameters(), lr=lr,
                       momentum=0.9, weight_decay=5e-4)
   scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
   for epoch in range(1, epochs+1):
       print("=====================================================================")
       print("Epoch : {}".format(epoch))
       train(net,criterion,optimizer,trainloader,device)
       test(net,criterion,testloader,device)
       torch.save(net.state_dict(), os.path.join(save_path,'epoch_{}.pth'.format(epoch)))
       scheduler.step()
if __name__ == '__main__':
   main()

Enfin, exécutez l'application :

python3 example.py

Pour quitter l'environnement virtuel, exécutez la commande suivante :

deactivate

Étape 3. Cloner le référentiel de formation

Cloner le référentiel avec le code MLperf :

git clone https://github.com/mlcommons/training_results_v3.0

Créer un répertoire séparé qui sera utilisé par le conteneur Docker avec MLperf :

mkdir -p mlperf

Modifier le répertoire :

cd mlperf

Exportons quelques variables d'environnement :

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Créez de nouveaux répertoires en utilisant les variables créées :

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Copier l'application benchmark dans $MLPERF_DIR/Habana :

cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/Habana

Exporter une autre variable qui contiendra un lien pour télécharger la version désirée du conteneur Docker :

export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41

Étape 4. Installer Docker

Notre instance fonctionne sous Ubuntu Linux 22.04 LTS et ne supporte pas Docker par défaut. Donc, avant de télécharger et d'exécuter des conteneurs, vous devez installer le support Docker. Rafraîchissons le cache des paquets et installons quelques paquets de base dont vous aurez besoin plus tard :

sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Pour installer Docker, vous devez ajouter un dépôt de projet signé numériquement. Téléchargez la clé de signature numérique et ajoutez-la au magasin de clés du système d'exploitation :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Docker peut fonctionner sur des plateformes aux architectures diverses. La commande suivante détectera l'architecture de votre serveur et ajoutera la ligne de dépôt correspondante à la liste du gestionnaire de paquets APT :

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Mettez à jour le cache des paquets et les politiques et installez docker-ce (Docker Community Edition) :

sudo apt update && apt-cache policy docker-ce && sudo apt install docker-ce

Enfin, vérifiez que le démon Docker est opérationnel :

sudo systemctl status docker

Étape 5. Exécuter le conteneur Docker

Lançons le conteneur en mode privilégié en utilisant les variables spécifiées précédemment :

sudo docker run --privileged --security-opt seccomp=unconfined \
  --name mlperf3.0 -td                    \
  -v /dev:/dev                            \
  --device=/dev:/dev                      \
  -e LOG_LEVEL_ALL=6                      \
  -v /sys/kernel/debug:/sys/kernel/debug  \
  -v /tmp:/tmp                            \
  -v $MLPERF_DIR:/root/MLPERF             \
  -v $SCRATCH_DIR:/root/scratch           \
  -v $DATASETS_DIR:/root/datasets/        \
  --cap-add=sys_nice --cap-add=SYS_PTRACE \
  --user root --workdir=/root --net=host  \
  --ulimit memlock=-1:-1 $MLPERF_DOCKER_IMAGE

Pour plus de commodité, vous pouvez accéder au terminal à l'intérieur du conteneur via SSH :

sudo docker exec mlperf3.0 bash -c "service ssh start"

Pour ouvrir un shell de commande (bash) dans la session en cours, exécutez la commande suivante :

sudo docker exec -it mlperf3.0 bash

Étape 6. Préparer un jeu de données

Pour exécuter les tests d'implémentation de Bert à partir de MLperf, vous avez besoin d'un jeu de données préparé. La meilleure méthode consiste à générer un jeu de données à partir de données préchargées. Le référentiel MLperf comprend un script spécial, prepare_data.sh, qui nécessite un ensemble spécifique de paquets pour fonctionner. Naviguons vers le répertoire suivant :

cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorch

Installer tous les paquets nécessaires en utilisant la liste pré-générée et le gestionnaire de paquets pip :

pip install -r requirements.txt

Définissez la variable PYTORCH_BERT_DATA pour indiquer au script où stocker les données :

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Exécutez le script :

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

La procédure de génération est assez longue et peut prendre plusieurs heures. Soyez patient et n'interrompez pas le processus. Si vous prévoyez de vous déconnecter de la session SSH, il est recommandé d'utiliser l'utilitaire screen immédiatement avant de démarrer le conteneur Docker.

Étape 7. Emballer l'ensemble de données

L'étape suivante consiste à "découper" l'ensemble de données en morceaux égaux pour le lancement ultérieur de MLperf. Créons un répertoire séparé pour les données empaquetées :

mkdir $PYTORCH_BERT_DATA/packed

Exécuter le script d'emballage :

python3 pack_pretraining_data_pytorch.py \
  --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
  --output_dir=$PYTORCH_BERT_DATA/packed \
  --max_predictions_per_seq=76

Étape 8. Exécuter un test

Maintenant que l'ensemble de données est préparé, il est temps d'exécuter le test. Cependant, il est impossible de le faire sans préparation préalable. Les auteurs du test de Bert ont laissé quelques valeurs codées en dur dans le script, qui vont interférer avec l'exécution du test. Tout d'abord, renommez le répertoire suivant :

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Changez le répertoire :

cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PT

L'éditeur GNU Nano n'étant pas installé dans le conteneur, il doit être installé séparément. Vous pouvez également utiliser l'éditeur Vi intégré :

apt update && apt -y install nano

Maintenant, éditez le script de lancement du test :

nano launch_bert_pytorch.sh

Trouvez la première ligne :

DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_data

Remplacer par ce qui suit :

DATA_ROOT=/root/datasets/pytorch_bert

Trouvez la deuxième ligne :

INPUT_DIR=$DATA_ROOT/packed

Remplacer par ce qui suit :

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Enregistrer le fichier et quitter.

Le code du test comprend une fonction de limitation qui empêche le gradient de dépasser certaines valeurs, prévenant ainsi une croissance exponentielle potentielle. Pour des raisons qui nous sont inconnues, cette fonction est absente de la version de PyTorch utilisée dans le conteneur, ce qui fait que le test se termine anormalement pendant la phase d'échauffement.

Une solution potentielle pourrait être de supprimer temporairement cette fonction du code du fichier fastddp.py. Pour ce faire, ouvrez le fichier :

nano ../PyTorch/fastddp.py

Trouvez et commentez les trois lignes de code suivantes en utilisant le # (symbole shebang) de manière à ce qu'elles ressemblent à ceci :

#from habana_frameworks.torch import _hpex_C
#    clip_global_grad_norm = _hpex_C.fused_lamb_norm(grads, 1.0)
#    _fusion_buffer.div_((clip_global_grad_norm * _all_reduce_group_size).to(_fusion_buffer.dtype))

Enregistrez également le fichier et quittez. Changez de répertoire :

cd ../HLS-Gaudi2-PT

Enfin, exécutez le script. L'exécution prendra environ 20 minutes :

./launch_bert_pytorch.sh

Voir aussi:

NVIDIA® RTX™ 50 : attentes et réalité

Thu, 23 Jan 2025 13:34:30 +0100

The highlight of CES 2025 was NVIDIA® CEO Jensen Huang’s speech. The revelation of new GPU specifications within minutes caught many off guard. In this article, we’ll examine how expert predictions matched the actual announcements.

Examinons tout d'abord la gamme. La série RTX™ 40 a été lancée avec 6 modèles, allant de la RTX™ 4060 à la RTX™ 4090. Alors que beaucoup s'attendaient à une gamme similaire pour la série RTX™ 50, cela ne s'est pas produit. Au lieu de cela, la famille RTX™ 50 ne comprend que 4 modèles : RTX™ 5070, RTX™ 5070 Ti, RTX™ 5080, et RTX™ 5090. Nous pourrions voir les RTX™ 5050 et RTX5060 à l'avenir, mais aucune source officielle n'a encore vérifié ces cartes graphiques.

Processus technologique

La loi de Moore, l'observation empirique selon laquelle "le nombre de transistors dans un circuit intégré double environ tous les deux ans", est souvent considérée comme n'étant plus pertinente pour les performances des puces. Depuis 2022, Jensen Huang a déclaré à plusieurs reprises que la loi de Moore était morte. Il a proposé un nouveau concept qui met l'accent sur le développement simultané de l'architecture, des micropuces, des bibliothèques de logiciels et des algorithmes.

Ce changement nous permet de nous concentrer sur les performances globales du système plutôt que sur le seul nombre de transistors. Le concept d'efficacité informatique a suscité des discussions permanentes au sein de la communauté technologique. Bien que les points de vue sur ce sujet varient, l'industrie est clairement confrontée à des obstacles physiques et économiques qui l'empêchent de poursuivre la miniaturisation.

Examinons la nouvelle génération de technologie de traitement des GPU. La présentation ne l'a pas spécifiquement mentionné, mais toutes les cartes de la génération précédente ont été construites sur le processus 4N. The RTX™ 50 series uses a different 4NP process technology. En même temps, il est important de comprendre que 4N et 4NP ne sont que des noms marketing. Les transistors eux-mêmes conservent une taille de 5 nm.

La technologie améliorée du processus 4NP permet principalement une plus grande densité de transistors sur la puce et des vitesses d'horloge plus rapides. Alors que les experts avaient prédit que la RTX™ 50 utiliserait la même technologie de traitement que la RTX™ 40, ils se sont techniquement trompés, mais pas de beaucoup, puisque la taille des transistors reste inchangée et que TSMC continue d'être le fabricant.

Nombre de cœurs

Avant la sortie de la série RTX™ 50, de nombreuses fuites de données ont révélé les caractéristiques de base du GPU. Les premiers rapports d'initiés datant de juillet 2024 suggéraient que le vaisseau amiral comporterait 24 576 cœurs, 192 cœurs de Ray-tracing et 768 cœurs de Tensor. Toutefois, des fuites ultérieures ont ajusté ces chiffres à des valeurs plus réalistes.

La RTX™ 5090 finale a été livrée avec 21,760 CUDA® cores (contre 16 384 pour la RTX™ 4090), 170 Ray-tracing cores et 680 Tensor cores. Cette évolution s'inscrit dans la stratégie récente de l'entreprise, qui consiste à augmenter les performances non seulement en augmentant le nombre de transistors, mais aussi en optimisant l'architecture de manière globale.

Mémoire

L'utilisation de la mémoire GDDR7 par les nouveaux GPU n'est pas une surprise. Les experts du secteur avaient prédit cette évolution en 2024 après que les trois principaux fabricants (Samsung, Micron et SK hynix) eurent présenté successivement leurs prototypes GDDR7. NVIDIA® a été généreux dans la distribution de la mémoire : le modèle de base RTX™ 5070 comprend 12 GB GDDR7 sur un bus 192-bit, tandis que le modèle RTX™ 5070 Ti and RTX™ 5080 comprend 16 GB GDDR7 sur un bus 256-bit. En haut de gamme, le modèle phare RTX™ 5090 est accompagné d'une énorme mémoire 32 GB GDDR7 sur un bus 512-bit.

Les experts avaient initialement prévu que le débit maximal de cette configuration de mémoire serait de 1,5 Tbps. Cependant, la réalité a dépassé ces attentes, achieving a throughput of 1,7 Tbps. Cette amélioration spectaculaire profite principalement aux capacités de traitement de l'intelligence artificielle du GPU plutôt qu'aux performances des jeux. La combinaison d'une capacité élevée et d'une mémoire rapide de la nouvelle génération est particulièrement précieuse pour les grands modèles de langage et les réseaux neuronaux génératifs.

Technologies

Pour les joueurs

Le ray tracing en temps réel est devenu l'une des technologies GPU les plus révolutionnaires, marquant le début de la gamme RTX™. Pour de nombreux consommateurs, cette fonctionnalité a été un facteur clé dans leur décision d'achat. Dans les cartes de la série RTX™ 50, la version 4 de DLSS (Deep Learning Super Sampling) pourrait jouer un rôle tout aussi important. Cette technologie augmente considérablement les performances du GPU dans les jeux grâce à son approche de rendu d'images hybrides.

Lorsque DLSS est activé, au lieu de rendre chaque image de manière conventionnelle, certaines images sont générées en temps réel à l'aide de l'IA. Alors que les premières versions de cette technologie ne permettaient que d'augmenter la résolution des images, DLSS 3 a introduit une capacité plus avancée : pour chaque image rendue de manière conventionnelle, il est possible de générer une image supplémentaire créée par l'IA.

DLSS 4 génère trois images créées par l'IA pour chaque image rendue de manière traditionnelle. This significantly increases the frame per second (FPS) without putting heavy load on the GPU. L'IA analyse les mouvements de l'objet et de la scène pour s'assurer que les images générées correspondent étroitement aux images rendues de manière conventionnelle.

Cela soulève une question importante : comment gérer le décalage d'entrée ? Étant donné que la génération d'images prend du temps, chaque itération augmente le temps de réponse. Une image fluide avec une réponse lente aux actions du joueur peut avoir un impact important sur l'expérience de jeu. To address this, NVIDIA® has improved their Reflex 2 technology alongside DLSS to minimize latency.

En particulier, Frame Warp a été intégré au système. Cette technologie réduit la latence des jeux en mettant à jour les images rendues avec la dernière entrée de la souris juste avant l'affichage. Elle améliore à la fois la compétition multijoueurs et la réactivité des joueurs individuels.

Pour les créateurs de contenu

La série RTX™ 50 n'est pas seulement destinée aux jeux. Les créateurs de contenu vidéo trouveront une valeur significative dans ces nouveaux GPU. Le modèle phare RTX™ 5090 est équipé de 3 encodeurs et de 2 décodeurs, contre 2 encodeurs et 1 décodeur pour la RTX™ 4090. Ces composants ont été améliorés grâce à un développement collaboratif avec les leaders de l'industrie : Adobe, Blackmagic Design, ByteDance et Wondershare. As a result, the RTX™ 5090 renders video 60% faster than the RTX™ 4090 and four times faster than the RTX™ 3090.

Au-delà des améliorations de la vitesse brute, la qualité a également été améliorée. The 9th generation NVENC encoder delivers 5% better quality in HEVC and AV1 tasks. The AV1 Ultra Quality mode achieves better data compression while maintaining image quality, reducing file sizes by 5%. Cela signifie un rendu vidéo plus rapide sur la RTX™ 5090, et une réduction du temps entre l'édition et la production.

Conclusion

Avec un recul de six mois, les prévisions et les attentes des experts se sont révélées trop optimistes. À mesure que la date de sortie approchait, il est devenu évident que les nouveaux GPU offriraient plus que de simples unités de calcul supplémentaires. The key innovation would be new optimization and AI technologies enhancing existing frame rendering systems.

Au CES 2025, lors de la présentation de la série GPU 50, une nouvelle ère de l'IA a été dévoilée. Cette vision dépeint un monde où les assistants numériques et les robots gèrent des tâches complexes. Au cœur de ce monde se trouverait un écosystème combinant des supercalculateurs pour l'entraînement à l'IA, des accélérateurs d'inférence abordables pour les appareils grand public et des logiciels polyvalents fonctionnant à la fois localement et dans le nuage. Si l'étendue de cet avenir reste incertaine, une chose est sûre : nous sommes sur le point de transformer la science-fiction en réalité.

LeaderGPU remains committed to providing reliable access to these cutting-edge technologies. Order your first GPU server today and begin transforming your ideas into reality.

Voir aussi:

Avantages et inconvénients du partage du GPU

Thu, 23 Jan 2025 13:24:12 +0100

La loi de Moore est restée d'actualité pendant près d'un demi-siècle. Les puces des processeurs contiennent toujours plus de transistors et les technologies progressent chaque jour. L'évolution de la technologie s'accompagne de celle de notre approche de l'informatique. L'essor de certaines tâches informatiques a considérablement influencé le développement du matériel. Par exemple, les appareils conçus à l'origine pour le traitement graphique sont aujourd'hui des outils essentiels et abordables pour les réseaux neuronaux modernes.

La gestion des ressources informatiques s'est également transformée. Aujourd'hui, les services de masse utilisent rarement des ordinateurs centraux, comme c'était le cas dans les années 1970 et 1980. Ils préfèrent les services en nuage ou la construction de leur propre infrastructure. Cette évolution a modifié les demandes des clients, qui privilégient une mise à l'échelle rapide et à la demande, ainsi qu'une utilisation maximale des ressources informatiques allouées.

Les technologies de virtualisation et de conteneurisation sont apparues comme des solutions. Les applications sont désormais regroupées dans des conteneurs avec toutes les bibliothèques nécessaires, ce qui simplifie le déploiement et la mise à l'échelle. Cependant, la gestion manuelle est devenue impraticable lorsque le nombre de conteneurs a grimpé en flèche pour atteindre des milliers. Des orchestrateurs spécialisés comme Kubernetes assurent désormais une gestion et une mise à l'échelle efficaces. Ces outils sont devenus un élément essentiel de toute infrastructure informatique moderne.

Virtualisation des serveurs

Parallèlement, les technologies de virtualisation ont évolué, permettant la création d'environnements isolés au sein d'un même serveur physique. Les machines virtuelles se comportent de la même manière que les serveurs physiques ordinaires, ce qui permet d'utiliser des outils de gestion standard. Selon l'hyperviseur, une API spécialisée est souvent incluse, facilitant l'automatisation des procédures de routine.

Toutefois, cette flexibilité s'accompagne d'une sécurité réduite. Les attaquants ne ciblent plus les machines virtuelles individuelles, mais exploitent les vulnérabilités de l'hyperviseur. En prenant le contrôle d'un hyperviseur, les attaquants peuvent accéder à volonté à toutes les machines virtuelles associées. Malgré les améliorations constantes de la sécurité, les hyperviseurs modernes restent des cibles attrayantes.

La virtualisation traditionnelle répond à deux problèmes clés. Premier point : elle garantit l'isolement des machines virtuelles les unes par rapport aux autres. Les solutions "bare-metal" évitent ce problème car les clients louent des serveurs physiques entiers qu'ils contrôlent. Mais pour les machines virtuelles, l'isolation est basée sur un logiciel au niveau de l'hyperviseur. Une erreur de code ou un bogue aléatoire peut compromettre cette isolation, entraînant un risque de fuite ou de corruption des données.

Le deuxième problème concerne la gestion des ressources. S'il est possible de garantir l'allocation de ressources à des machines virtuelles spécifiques, la gestion d'un grand nombre de machines pose un dilemme. Les ressources peuvent être sous-utilisées, ce qui se traduit par une diminution du nombre de machines virtuelles par serveur physique. Ce scénario n'est pas rentable pour l'infrastructure et conduit inévitablement à des augmentations de prix.

Une autre solution consiste à utiliser des mécanismes de gestion automatique des ressources. Bien qu'une machine virtuelle se voie attribuer des caractéristiques déclarées spécifiques, en fait, seul le minimum requis est fourni dans ces limites. Si la machine a besoin de plus de temps processeur ou de mémoire vive, l'hyperviseur tentera de le lui fournir, mais ne peut le garantir. Cette situation est similaire à la surréservation dans les avions, lorsque les compagnies aériennes vendent plus de billets qu'il n'y a de places disponibles.

La logique est identique. Si les statistiques montrent qu'environ 10 % des passagers n'arrivent pas à temps pour leur vol, les compagnies aériennes peuvent vendre 10 % de billets en plus avec un risque minimal. Si tous les passagers arrivent, certains n'auront pas de place à bord. La compagnie aérienne devra faire face à des conséquences mineures sous la forme d'une indemnisation, mais elle continuera probablement à appliquer cette pratique.

De nombreux fournisseurs d'infrastructures emploient une stratégie similaire. Certains sont transparents à ce sujet, déclarant qu'ils ne garantissent pas une disponibilité constante des ressources informatiques mais offrent des prix considérablement réduits. D'autres utilisent des mécanismes similaires sans en faire la publicité. Ils font le pari que tous les clients n'utiliseront pas systématiquement 100 % des ressources de leur serveur et que, même si certains le font, ils seront minoritaires. Pendant ce temps, les ressources inutilisées génèrent des bénéfices.

Dans ce contexte, les solutions "bare-metal" présentent un avantage. Elles garantissent que les ressources allouées sont entièrement gérées par le client et ne sont pas partagées avec d'autres utilisateurs du fournisseur d'infrastructure. Cela élimine les scénarios dans lesquels une charge élevée de l'utilisateur d'un serveur voisin a un impact négatif sur les performances.

Virtualisation du GPU

La virtualisation classique est inévitablement confrontée au défi de l'émulation des dispositifs physiques. Pour réduire les frais généraux, des technologies spéciales ont été développées pour permettre aux machines virtuelles d'accéder directement aux périphériques physiques du serveur. Cette approche fonctionne bien dans de nombreux cas, mais lorsqu'elle est appliquée aux processeurs graphiques, elle crée des limitations immédiates. Par exemple, si un serveur dispose de 8 GPU, seules 8 machines virtuelles peuvent y accéder.

La technologie vGPU a été inventée pour pallier cette limitation. Elle divise un GPU en plusieurs GPU logiques, qui peuvent ensuite être assignés à des machines virtuelles. Cela permet à chaque machine virtuelle d'obtenir sa "part de gâteau", et leur nombre total n'est plus limité par le nombre de cartes vidéo installées sur le serveur.

Les GPU virtuels sont le plus souvent utilisés lors de la mise en place de VDI (Virtual Desktop Infrastructure) dans les domaines où les machines virtuelles ont besoin d'une accélération 3D. Par exemple, le poste de travail virtuel d'un concepteur ou d'un planificateur implique généralement un traitement graphique. La plupart des applications dans ces domaines effectuent des calculs à la fois sur le processeur central et sur le GPU. Cette approche hybride augmente considérablement la productivité et garantit une utilisation optimale des ressources informatiques disponibles.

Toutefois, cette technologie présente plusieurs inconvénients. Elle n'est pas supportée par tous les GPU et n'est disponible que dans le segment des serveurs. La prise en charge dépend également de la version installée du système d'exploitation et du pilote GPU. vGPU possède un mécanisme de licence distinct, ce qui augmente considérablement les coûts d'exploitation. En outre, ses composants logiciels peuvent potentiellement servir de vecteurs d'attaque.

Récemment, des informations ont été publiées sur huit vulnérabilités affectant tous les utilisateurs de GPU NVIDIA®. Six vulnérabilités ont été identifiées dans les pilotes de GPU et deux dans le logiciel vGPU. Ces problèmes ont été rapidement résolus, mais ils rappellent que les mécanismes d'isolation de ces systèmes ne sont pas sans faille. Une surveillance constante et l'installation opportune des mises à jour restent les principaux moyens de garantir la sécurité.

Lors de la mise en place d'une infrastructure destinée à traiter des données confidentielles et sensibles, toute virtualisation devient un facteur de risque potentiel. Dans ce cas, une approche "bare-metal" peut offrir une meilleure qualité et une meilleure sécurité.

Conclusion

La mise en place d'une infrastructure informatique nécessite toujours une évaluation des risques. Les questions clés à se poser sont les suivantes : Les données des clients sont-elles protégées en toute sécurité ? Les technologies choisies créent-elles des vecteurs d'attaque supplémentaires ? Comment isoler et éliminer les vulnérabilités potentielles ? Répondre à ces questions permet de faire des choix éclairés et de se prémunir contre des problèmes futurs.

Chez LeaderGPU, nous sommes parvenus à une conclusion claire : actuellement, la technologie bare-metal est supérieure pour assurer la sécurité des données des utilisateurs tout en servant d'excellente base pour construire un cloud bare-metal. Cette approche permet à nos clients de conserver leur flexibilité sans prendre les risques supplémentaires associés à la virtualisation des GPU.

Voir aussi:

Qu'est-ce que la distillation des connaissances ?

Thu, 23 Jan 2025 13:21:29 +0100

Les grands modèles linguistiques (LLM) font désormais partie intégrante de notre vie grâce à leurs capacités uniques. Ils comprennent le contexte et génèrent des textes cohérents et détaillés sur cette base. Ils peuvent traiter et répondre dans n'importe quelle langue tout en tenant compte des nuances culturelles de chacune d'entre elles.

Les LLM excellent dans la résolution de problèmes complexes, la programmation, les conversations, etc. Cette polyvalence provient du traitement de grandes quantités de données de formation, d'où le terme "large". Ces modèles peuvent contenir des dizaines ou des centaines de milliards de paramètres, ce qui les rend gourmands en ressources pour une utilisation quotidienne.

La formation est le processus le plus exigeant. Les modèles de réseaux neuronaux apprennent en traitant d'énormes ensembles de données, en ajustant leurs "poids" internes pour former des connexions stables entre les neurones. Ces connexions stockent des connaissances que le réseau neuronal formé peut ensuite utiliser sur des appareils finaux.

Toutefois, la plupart des terminaux ne disposent pas de la puissance de calcul nécessaire pour faire fonctionner ces modèles. Par exemple, l'exécution de la version complète de Llama 2 (70B paramètres) nécessite un GPU avec 48 Go de mémoire vidéo, un matériel dont peu d'utilisateurs disposent à la maison, et encore moins sur des appareils mobiles.

Par conséquent, la plupart des réseaux neuronaux modernes fonctionnent dans une infrastructure en nuage plutôt que sur des appareils portables, qui y accèdent par l'intermédiaire d'API. Néanmoins, les fabricants d'appareils progressent de deux manières : en équipant les appareils d'unités de calcul spécialisées telles que les NPU et en développant des méthodes pour améliorer les performances des modèles de réseaux neuronaux compacts.

Réduire la taille

Couper l'excédent

La quantification est la première méthode, et la plus efficace, de réduction de la taille des réseaux neuronaux. Les poids des réseaux neuronaux utilisent généralement des nombres à virgule flottante de 32 bits, mais il est possible de les réduire en modifiant ce format. L'utilisation de valeurs de 8 bits (ou même de valeurs binaires dans certains cas) peut décupler la taille du réseau, bien que la précision des réponses s'en trouve considérablement réduite.

L'élagage est une autre approche qui consiste à supprimer les connexions sans importance dans le réseau neuronal. Ce processus fonctionne à la fois pendant la formation et avec les réseaux terminés. Au-delà des simples connexions, l'élagage peut supprimer des neurones ou des couches entières. Cette réduction des paramètres et des connexions permet de diminuer les besoins en mémoire.

La décomposition matricielle ou tensorielle est la troisième technique courante de réduction de la taille. La décomposition d'une grande matrice en un produit de trois matrices plus petites permet de réduire le nombre total de paramètres tout en maintenant la qualité. La taille du réseau peut ainsi être réduite des dizaines de fois. La décomposition tensorielle offre des résultats encore meilleurs, bien qu'elle nécessite davantage d'hyperparamètres.

Bien que ces méthodes réduisent efficacement la taille, elles sont toutes confrontées au problème de la perte de qualité. Les modèles compressés de grande taille sont plus performants que leurs homologues plus petits non compressés, mais chaque compression risque de réduire la précision de la réponse. La distillation des connaissances représente une tentative intéressante d'équilibrer la qualité et la taille.

Essayons ensemble

La distillation des connaissances s'explique le mieux par l'analogie entre un étudiant et un enseignant. Tandis que les étudiants apprennent, les enseignants enseignent et mettent continuellement à jour leurs connaissances. Lorsque tous deux sont confrontés à de nouvelles connaissances, l'enseignant a un avantage, car il peut s'appuyer sur ses vastes connaissances dans d'autres domaines, alors que l'étudiant ne dispose pas encore de cette base.

Ce principe s'applique aux réseaux neuronaux. Lorsque l'on entraîne deux réseaux neuronaux du même type mais de tailles différentes sur des données identiques, le réseau le plus grand obtient généralement de meilleurs résultats. Sa plus grande capacité de "connaissance" lui permet d'obtenir des réponses plus précises que son homologue plus petit. Cela soulève une question intéressante : pourquoi ne pas entraîner le petit réseau non seulement sur l'ensemble des données, mais aussi sur les résultats plus précis du grand réseau ?

Ce processus est la distillation des connaissances : une forme d'apprentissage supervisé où un modèle plus petit apprend à reproduire les prédictions d'un modèle plus grand. Si cette technique permet de compenser la perte de qualité due à la réduction de la taille des réseaux neuronaux, elle nécessite des ressources informatiques et un temps de formation supplémentaires.

Logiciel et logique

Les fondements théoriques étant désormais clairs, examinons le processus d'un point de vue technique. Nous commencerons par les outils logiciels qui peuvent vous guider tout au long des étapes de formation et de distillation des connaissances.

Python, avec la bibliothèque TorchTune de l'écosystème PyTorch, offre l'approche la plus simple pour étudier et affiner de grands modèles de langage. Voici comment fonctionne l'application :

Deux modèles sont chargés : un modèle complet (enseignant) et un modèle réduit (élève). Au cours de chaque itération de formation, le modèle de l'enseignant génère des prédictions à haute température tandis que le modèle de l'étudiant traite l'ensemble de données pour faire ses propres prédictions.

Les valeurs de sortie brutes (logits) des deux modèles sont évaluées à l'aide d'une fonction de perte (une mesure numérique de l'écart d'une prédiction par rapport à la valeur correcte). Des ajustements de poids sont ensuite appliqués au modèle de l'élève par rétropropagation. Cela permet au petit modèle d'apprendre et de reproduire les prédictions du modèle de l'enseignant.

Le principal fichier de configuration dans le code de l'application est appelé "recette". Ce fichier stocke tous les paramètres et réglages de la distillation, ce qui rend les expériences reproductibles et permet aux chercheurs de suivre l'influence des différents paramètres sur le résultat final.

Lors de la sélection des valeurs des paramètres et des nombres d'itérations, il est essentiel de maintenir un équilibre. Un modèle trop distillé risque de perdre sa capacité à reconnaître les détails subtils et le contexte, et d'adopter par défaut des réponses toutes faites. Bien qu'il soit pratiquement impossible d'atteindre un équilibre parfait, un suivi attentif du processus de distillation peut améliorer considérablement la qualité de prédiction des modèles de réseaux neuronaux, même les plus modestes.

Il convient également de prêter attention au suivi pendant le processus de formation. Cela permettra d'identifier les problèmes à temps et de les corriger rapidement. Pour ce faire, vous pouvez utiliser l'outil TensorBoard. Il s'intègre parfaitement aux projets PyTorch et vous permet d'évaluer visuellement de nombreuses mesures, telles que la précision et les pertes. En outre, il vous permet de construire un graphique de modèle, de suivre l'utilisation de la mémoire et le temps d'exécution des opérations.

Conclusion

La distillation des connaissances est une méthode efficace pour optimiser les réseaux neuronaux afin d'améliorer les modèles compacts. Elle donne de meilleurs résultats lorsqu'il est essentiel d'équilibrer les performances et la qualité des réponses.

Bien que la distillation des connaissances nécessite un suivi attentif, ses résultats peuvent être remarquables. Les modèles deviennent beaucoup plus petits tout en maintenant la qualité de la prédiction, et ils fonctionnent mieux avec moins de ressources informatiques.

Lorsqu'elle est bien planifiée avec des paramètres appropriés, la distillation des connaissances est un outil essentiel pour créer des réseaux neuronaux compacts sans sacrifier la qualité.

Voir aussi:

AudioCraft par MetaAI : créer de la musique par description

Wed, 22 Jan 2025 15:51:35 +0100

Les réseaux neuronaux génératifs modernes deviennent de plus en plus intelligents. Ils écrivent des histoires, engagent des conversations avec les gens et créent des images ultra-réalistes. Aujourd'hui, ils peuvent produire de simples morceaux de musique sans faire appel à des artistes professionnels. Ce futur est devenu une réalité aujourd'hui. C'est normal, car les harmonies et les rythmes musicaux sont ancrés dans des principes mathématiques.

Meta a démontré son engagement dans le monde des logiciels libres. Ils ont mis à la disposition du public trois modèles de réseaux neuronaux qui permettent de créer des sons et de la musique à partir de descriptions textuelles :

MusicGen - génère de la musique à partir d'un texte.
AudioGen - génère de l'audio à partir d'un texte.
EnCodec - compresseur audio neuronal de haute qualité.

MusicGen a été entraîné sur 20 000 heures de musique. Vous pouvez l'utiliser localement via les serveurs dédiés de LeaderGPU en tant que plateforme.

Installation standard

Mettre à jour le dépôt de cache des paquets :

sudo apt update && sudo apt -y upgrade

Installer le gestionnaire de paquets Python, pip, et les bibliothèques ffmpeg :

sudo apt -y install python3-pip ffmpeg

Installez torch 2.0 ou une version plus récente à l'aide de pip :

pip install 'torch>=2.0'

La commande suivante installe automatiquement audiocraft et toutes les dépendances nécessaires :

pip install -U audiocraft

Ecrivons une application Python simple, utilisant le grand modèle MusicGen pré-entraîné avec 3.3B paramètres :

nano generate.py

from audiocraft.models import MusicGen
from audiocraft.data.audio import audio_write
model = MusicGen.get_pretrained("facebook/musicgen-large")
model.set_generation_params(duration=30)  # generate a 30 seconds sample.
descriptions = ["rock solo"]
wav = model.generate(descriptions)  # generates sample.
for idx, one_wav in enumerate(wav):
    # Will save under {idx}.wav, with loudness normalization at -14 db LUFS.
    audio_write(f'{idx}', one_wav.cpu(), model.sample_rate, strategy="loudness")

Exécuter l'application créée :

python3 generate.py

Après quelques secondes, le fichier généré (0.wav) apparaît dans le répertoire.

Café Vampir 3

Cloner un dépôt de projet :

git clone https://github.com/CoffeeVampir3/audiocraft-webui.git

Ouvrez le répertoire cloné :

cd audiocraft-webui

Exécutez la commande qui prépare votre système et installe tous les paquets nécessaires :

pip install -r requirements.txt

Ensuite, lancez le serveur Coffee Vampire 3 avec la commande suivante :

python3 webui.py

Coffee Vampire 3 utilise Flask comme framework. Par défaut, il fonctionne sur localhost avec le port 5000. Si vous souhaitez un accès à distance, veuillez utiliser la fonction de redirection de port dans votre client SSH. Sinon, vous pouvez organiser une connexion VPN au serveur.

Attention ! Il s'agit d'une action potentiellement dangereuse ; utilisez-la à vos propres risques :

nano webui.py

Descendez jusqu'à la fin et remplacez socketio.run(app) par socketio.run(app, host=’0.0.0.0’, port=5000)

Enregistrez le fichier et exécutez le serveur à l'aide de la commande ci-dessus. Cela permet d'accéder au serveur depuis l'internet public sans aucune authentification.

N'oubliez pas disable AdBlock software, car il peut bloquer le lecteur de musique sur le côté droit de la page web. Vous pouvez commencer par saisir l'invite et confirmer en cliquant sur le bouton Submit:

TTS Generation WebUI

Étape 1. Pilotes

Mettez à jour le dépôt de cache des paquets :

sudo apt update && sudo apt -y upgrade

Installer les pilotes NVIDIA® à l'aide de l'installateur automatique ou de notre guide Installer les pilotes NVIDIA® sous Linux:

sudo ubuntu-drivers autoinstall

Redémarrer le serveur :

sudo shutdown -r now

Étape 2. Docker

L'étape suivante consiste à installer Docker. Installons quelques paquets qui doivent être ajoutés au dépôt Docker :

sudo apt -y install apt-transport-https curl gnupg-agent ca-certificates software-properties-common

Téléchargez la clé GPG de Docker et stockez-la :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Ajouter le dépôt :

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Installer Docker CE (Community Edition) avec CLI et le runtime containerd:

sudo apt -y install docker-ce docker-ce-cli containerd.io

Ajouter l'utilisateur actuel au groupe docker :

sudo usermod -aG docker $USER

Appliquer les modifications sans procédure de déconnexion et de connexion :

newgrp docker

Étape 3. Passage du GPU

Activons le passthrough des GPU NVIDIA® dans Docker. La commande suivante lit la version actuelle du système d'exploitation dans la variable distribution, que nous utiliserons à l'étape suivante :

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)

Téléchargez la clé GPG du dépôt NVIDIA® et stockez-la :

curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -

Téléchargez la liste des dépôts NVIDIA® et stockez-la pour l'utiliser dans le gestionnaire de paquets APT standard :

curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

Mettez à jour le dépôt de cache des paquets et installez le kit d'outils GPU passthrough :

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit

Redémarrer le démon Docker :

sudo systemctl restart docker

Étape 4. L'interface Web

Télécharger l'archive du référentiel :

wget https://github.com/rsxdalv/tts-generation-webui/archive/refs/heads/main.zip

Décompressez-la :

unzip main.zip

Ouvrez le répertoire du projet :

cd tts-generation-webui-main

Commencer à construire l'image :

docker build -t rsxdalv/tts-generation-webui .

Exécuter le conteneur créé :

docker compose up -d

Vous pouvez maintenant ouvrir http://[server_ip]:7860, saisir votre invite, sélectionner le modèle nécessaire et cliquer sur le bouton Generate:

Le système télécharge automatiquement le modèle sélectionné lors de la première génération. Bon appétit !

Voir aussi:

Comment surveiller l'application LangFlow

Wed, 22 Jan 2025 15:14:55 +0100

Dans notre article Constructeur d'applications IA à code bas Langflow, nous avons exploré comment démarrer avec l'environnement de programmation visuel de ce constructeur d'applications IA à code bas. Il permet à tous, même à ceux qui n'ont pas de connaissances en programmation, de créer des applications alimentées par de grands modèles de réseaux neuronaux. Il peut s'agir de chatbots d'IA ou d'applications de traitement de documents capables d'analyser et de résumer du contenu.

Langflow utilise une approche par blocs de construction où les utilisateurs connectent des composants préfabriqués pour créer l'application souhaitée. Cependant, deux défis majeurs se posent souvent : le dépannage lorsque les réseaux neuronaux se comportent de manière inattendue et la gestion des coûts. Les réseaux neuronaux nécessitent des ressources informatiques considérables, ce qui rend essentiel le contrôle et la prévision des dépenses d'infrastructure.

LangWatch répond à ces deux défis. Cet outil spécialisé aide les développeurs de Langflow à surveiller les demandes des utilisateurs, à suivre les coûts et à détecter les anomalies, par exemple lorsque les applications sont utilisées de manière non intentionnelle.

Cet outil a été conçu à l'origine comme un service, mais il peut être déployé sur n'importe quel serveur, y compris localement. Il s'intègre à la plupart des fournisseurs de LLM, qu'ils soient basés sur le cloud ou sur site. Comme il s'agit d'un logiciel libre, LangWatch peut être adapté à presque tous les projets : ajout de nouvelles fonctionnalités ou connexion avec des systèmes internes.

LangWatch vous permet de créer des alertes lorsque des indicateurs spécifiques dépassent des seuils définis. Cela vous permet de détecter rapidement les augmentations inattendues des coûts des demandes ou les délais de réponse inhabituels. Une détection précoce permet d'éviter les dépenses imprévues et les attaques de service potentielles.

Pour les chercheurs en réseaux neuronaux, cette application permet à la fois de surveiller et d'optimiser les demandes courantes des utilisateurs. Elle fournit également des outils permettant d'évaluer la qualité de la réponse du modèle et d'effectuer les ajustements nécessaires.

Démarrage rapide

Préparation du système

Comme pour Langflow, la façon la plus simple d'exécuter l'application est de passer par un conteneur Docker. Avant d'installer LangWatch, vous devez installer Docker Engine sur votre serveur. Tout d'abord, mettez à jour votre cache de paquets et les paquets vers leurs dernières versions :

sudo apt update && sudo apt -y upgrade

Installez les paquets supplémentaires requis par Docker :

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Télécharger la clé GPG pour ajouter le dépôt officiel de Docker :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Ajoutez le dépôt à APT en utilisant la clé que vous avez téléchargée et installée précédemment :

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiser la liste des paquets :

sudo apt update

Pour s'assurer que Docker sera installé à partir du dépôt nouvellement ajouté et non à partir de celui du système, vous pouvez exécuter la commande suivante :

apt-cache policy docker-ce

Installer le moteur Docker :

sudo apt install docker-ce

Vérifiez que Docker a été installé avec succès et que le démon correspondant est en cours d'exécution et dans l'état active (running):

sudo systemctl status docker

● docker.service - Docker Application Container Engine
    Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
    Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
      Docs: https://docs.docker.com
  Main PID: 1842 (dockerd)
     Tasks: 29
    Memory: 1.8G
       CPU: 3min 15.715s
    CGroup: /system.slice/docker.service

Construire et exécuter

Une fois Docker Engine installé et lancé, vous pouvez télécharger le référentiel de l'application LangWatch :

git clone https://github.com/langwatch/langwatch

L'application comprend un exemple de fichier de configuration avec des variables d'environnement. Copiez ce fichier pour que l'utilitaire de construction d'image puisse le traiter :

cp langwatch/.env.example langwatch/.env

Vous êtes maintenant prêt pour le premier lancement :

sudo docker compose up --build

Le système va prendre un moment pour télécharger toutes les couches de conteneurs nécessaires à LangWatch. Une fois le téléchargement terminé, vous verrez un message de la console indiquant que l'application est disponible à l'adresse :

http://[LeaderGPU_IP_address]:3000

Accédez à cette page dans votre navigateur, où vous serez invité à créer un compte utilisateur :

Contrairement à Langflow, l'authentification est activée par défaut dans ce système. Après avoir ouvert une session, vous devrez configurer le système pour qu'il recueille les données de votre serveur Langflow.

Intégration de Langflow

LangWatch a besoin d'une source de données pour fonctionner. Le serveur écoute sur le port 3000 et utilise une API RESTful, qui authentifie les données entrantes grâce à une clé API générée automatiquement.

Pour activer le transfert de données, vous devez définir deux variables dans les fichiers de configuration de Langflow : LANGWATCH_ENDPOINT et LANGWATCH_API_KEY. Tout d'abord, établissez une connexion SSH à votre serveur Langflow (qui devrait être hors ligne pendant ce processus).

Naviguez jusqu'au répertoire contenant l'exemple de configuration pour Docker :

cd langflow/docker_example

Ouvrez le fichier de configuration pour l'éditer :

nano docker-compose.yml

Dans la section "environnement :", ajoutez les variables suivantes (sans crochets [] ni guillemets) :

- LANGWATCH_API_KEY= [YOUR_API_KEY]
- LANGWATCH_ENDPOINT=http://[IP_ADDRESS]:3000

Le fichier YML nécessite un formatage spécifique. Respectez ces deux règles essentielles :

Utilisez des espaces (2 ou 4) pour l'indentation, jamais de tabulations.
Maintenir une structure hiérarchique correcte avec une indentation cohérente.

Enregistrez le fichier avec Ctrl + O et quittez l'éditeur avec Ctrl + X, Langflow est maintenant prêt à être lancé :

sudo docker compose up

Après le lancement, vérifiez que tout fonctionne correctement. Créez un nouveau projet ou ouvrez un projet existant, puis lancez un dialogue via Playground. Langflow enverra automatiquement des données à LangWatch pour surveillance, que vous pourrez visualiser dans l'interface web.

Dans la section de vérification de l'intégration, une coche apparaît sur l'élément "Sync your first message". Cela indique que les données de Langflow sont envoyées avec succès vers LangWatch, confirmant que votre configuration est correcte. Examinons ce qui apparaît dans la section Messages:

La section Messages affiche les données entrées dans l'application, les paramètres utilisés pour la génération de la réponse et la réponse du réseau neuronal lui-même. Vous pouvez évaluer la qualité de la réponse et utiliser divers filtres pour trier les données, même avec des centaines ou des milliers de messages.

Après cette configuration initiale, explorez systématiquement les fonctionnalités de l'application. Dans la section Evaluations, vous pouvez configurer des algorithmes de vérification du dialogue pour la modération du dialogue ou la reconnaissance des données, tels que PII Detection. Cette fonction analyse les données saisies pour détecter les informations sensibles telles que les numéros de sécurité sociale ou les numéros de téléphone.

L'application propose des options locales et en nuage par l'intermédiaire de fournisseurs tels qu'Azure ou Cloudflare. Pour utiliser les fonctions en nuage, vous devez disposer d'un compte auprès de ces services, ainsi que des adresses de leurs points d'extrémité et des clés API. N'oubliez pas qu'il s'agit de fournisseurs tiers ; vérifiez donc directement le coût de leurs services.

Pour les options locales, l'application est dotée de fonctionnalités RAG (Retrieval-augmented generation) sophistiquées. Vous pouvez mesurer la précision et la pertinence du contenu généré par RAG et utiliser les statistiques recueillies pour optimiser le système RAG afin d'obtenir des réponses plus précises de la part du réseau neuronal.

Voir aussi:

Langflow, créateur d'applications d'IA à code réduit

Wed, 22 Jan 2025 15:11:30 +0100

Le développement de logiciels a évolué de manière spectaculaire ces dernières années. Les programmeurs modernes ont désormais accès à des centaines de langages et de cadres de programmation. Au-delà des approches impératives et déclaratives traditionnelles, une nouvelle méthode passionnante de création d'applications est en train d'émerger. Cette approche innovante exploite la puissance des réseaux neuronaux, ouvrant ainsi de fantastiques possibilités aux développeurs.

Les gens se sont habitués aux assistants IA dans les IDE qui aident à l'autocomplétion du code et aux réseaux neuronaux modernes qui génèrent facilement du code pour de simples jeux en Python. Cependant, de nouveaux outils hybrides émergent et pourraient révolutionner le paysage du développement. L'un de ces outils est Langflow.

Langflow a de multiples fonctions. Pour les développeurs professionnels, il offre un meilleur contrôle sur des systèmes complexes tels que les réseaux neuronaux. Pour les personnes peu familiarisées avec la programmation, il permet de créer des applications simples mais pratiques. Ces objectifs sont atteints par différents moyens, que nous allons explorer plus en détail.

Réseaux neuronaux

Le concept de réseau neuronal peut être simplifié pour les utilisateurs. Imaginez une boîte noire qui reçoit des données d'entrée et des paramètres influençant le résultat final. Cette boîte traite les données d'entrée à l'aide d'algorithmes complexes, souvent qualifiés de "magiques", et produit des données de sortie qui peuvent être présentées à l'utilisateur.

Le fonctionnement interne de cette boîte noire varie en fonction de la conception du réseau neuronal et des données d'entraînement. Il est essentiel de comprendre que les développeurs et les utilisateurs ne peuvent jamais obtenir des résultats sûrs à 100 %. Contrairement à la programmation traditionnelle où 2 + 2 est toujours égal à 4, un réseau neuronal peut donner cette réponse avec 99 % de certitude, tout en conservant une marge d'erreur.

Le contrôle du processus de "réflexion" d'un réseau neuronal est indirect. Nous ne pouvons ajuster que certains paramètres, comme la "température". Ce paramètre détermine le degré de créativité ou de contrainte du réseau neuronal dans son approche. Une valeur de température basse limite le réseau à une approche plus formelle et structurée des tâches et des solutions. À l'inverse, des valeurs de température élevées accordent au réseau une plus grande liberté, ce qui peut l'amener à s'appuyer sur des faits moins fiables, voire à créer des informations fictives.

Cet exemple illustre la manière dont les utilisateurs peuvent influencer le résultat final. Pour la programmation traditionnelle, cette incertitude constitue un défi important : des erreurs peuvent apparaître de manière inattendue et les résultats spécifiques deviennent imprévisibles. Cependant, cette imprévisibilité est avant tout un problème pour les ordinateurs, et non pour les humains qui peuvent s'adapter à des résultats variables et les interpréter.

Si les résultats d'un réseau neuronal sont destinés à un être humain, la formulation spécifique utilisée pour les décrire est généralement moins importante. Compte tenu du contexte, les gens peuvent interpréter correctement divers résultats du point de vue de la machine. Alors que des concepts tels que "valeur positive", "résultat obtenu" ou "décision positive" peuvent signifier à peu près la même chose pour une personne, la programmation traditionnelle aurait du mal à gérer cette flexibilité. Elle devrait tenir compte de toutes les variations possibles des réponses, ce qui est pratiquement impossible.

En revanche, si la suite du traitement est confiée à un autre réseau neuronal, celui-ci peut comprendre et traiter correctement le résultat obtenu. Sur cette base, il peut alors formuler sa propre conclusion avec un certain degré de confiance, comme nous l'avons mentionné plus haut.

Code bas

La plupart des langages de programmation impliquent l'écriture de code. Les programmeurs créent la logique de chaque partie d'une application dans leur esprit, puis la décrivent à l'aide d'expressions spécifiques au langage. Ce processus forme un algorithme : une séquence claire d'actions menant à un résultat spécifique et prédéterminé. Il s'agit d'une tâche complexe qui nécessite un effort mental important et une compréhension approfondie des capacités du langage.

Cependant, il n'est pas nécessaire de réinventer la roue. De nombreux problèmes rencontrés par les développeurs modernes ont déjà été résolus de diverses manières. Des extraits de code pertinents peuvent souvent être trouvés sur StackOverflow. La programmation moderne peut être comparée à l'assemblage d'un tout à partir de pièces de différents jeux de construction. Le système Lego offre un modèle réussi, ayant standardisé différents jeux de pièces pour assurer la compatibilité.

La méthode de programmation low-code suit un principe similaire. Différents éléments de code sont modifiés pour s'adapter parfaitement les uns aux autres et sont présentés aux développeurs sous forme de blocs prêts à l'emploi. Chaque bloc peut avoir des entrées et des sorties de données. La documentation spécifie la tâche que chaque type de bloc résout et le format dans lequel il accepte ou produit des données.

En connectant ces blocs dans une séquence spécifique, les développeurs peuvent former l'algorithme d'une application et visualiser clairement sa logique opérationnelle. L'exemple le plus connu de cette méthode de programmation est sans doute la méthode graphique de la tortue, couramment utilisée dans les établissements d'enseignement pour présenter les concepts de programmation et développer la pensée algorithmique.

L'essence de cette méthode est simple : il s'agit de dessiner des images sur l'écran à l'aide d'une tortue virtuelle qui laisse une trace en rampant sur la toile. En utilisant des blocs prêts à l'emploi, tels que le déplacement d'un nombre déterminé de pixels, la rotation à des angles spécifiques ou l'élévation et l'abaissement du stylo, les développeurs peuvent créer des programmes qui dessinent les images qu'ils souhaitent. La création d'applications à l'aide d'un constructeur à code bas est similaire aux graphiques de tortue, mais elle permet aux utilisateurs de résoudre un large éventail de problèmes, et pas seulement de dessiner sur un canevas.

C'est l'outil de programmation Node-RED d'IBM qui a le mieux mis en œuvre cette méthode. Il a été développé comme un moyen universel de garantir le fonctionnement conjoint de divers appareils, services en ligne et API. L'équivalent des extraits de code étaient des nœuds de la bibliothèque standard (palette).

Les capacités de Node-RED peuvent être étendues en installant des modules complémentaires ou en créant des nœuds personnalisés qui exécutent des actions de données spécifiques. Les développeurs placent les nœuds de la palette sur le bureau et établissent des relations entre eux. Ce processus crée la logique de l'application, la visualisation aidant à maintenir la clarté.

En ajoutant les réseaux neuronaux à ce concept, on obtient un système fascinant. Au lieu de traiter les données à l'aide de formules mathématiques spécifiques, vous pouvez les introduire dans un réseau neuronal et spécifier la sortie souhaitée. Bien que les données d'entrée puissent varier légèrement à chaque fois, les résultats peuvent être interprétés par des humains ou d'autres réseaux neuronaux.

Génération augmentée par récupération (RAG)

La précision des données dans les grands modèles linguistiques est une préoccupation urgente. Ces modèles reposent uniquement sur les connaissances acquises au cours de la formation, qui dépendent de la pertinence des ensembles de données utilisés. Par conséquent, les grands modèles linguistiques peuvent ne pas disposer de suffisamment de données pertinentes, ce qui peut conduire à des résultats erronés.

Pour résoudre ce problème, des méthodes de mise à jour des données sont nécessaires. Permettre aux réseaux neuronaux d'extraire le contexte de sources supplémentaires, telles que des sites web, peut améliorer de manière significative la qualité des réponses. C'est précisément ainsi que fonctionne la méthode RAG (Retrieval-Augmented Generation). Les données supplémentaires sont converties en représentations vectorielles et stockées dans une base de données.

En fonctionnement, les modèles de réseaux neuronaux peuvent convertir les demandes des utilisateurs en représentations vectorielles et les comparer à celles stockées dans la base de données. Lorsque des vecteurs similaires sont trouvés, les données sont extraites et utilisées pour former une réponse. Les bases de données vectorielles sont suffisamment rapides pour prendre en charge ce système en temps réel.

Pour que ce système fonctionne correctement, il faut établir une interaction entre l'utilisateur, le modèle de réseau neuronal, les sources de données externes et la base de données vectorielles. Langflow simplifie cette configuration grâce à sa composante visuelle - les utilisateurs construisent simplement des blocs standard et les "relient", créant ainsi un chemin pour le flux de données.

La première étape consiste à alimenter la base de données vectorielles avec les sources pertinentes. Il peut s'agir de fichiers provenant d'un ordinateur local ou de pages web provenant d'Internet. Voici un exemple simple de chargement de données dans la base de données :

Maintenant que nous disposons d'une base de données vectorielle en plus du LLM formé, nous pouvons l'incorporer dans le schéma général. Lorsqu'un utilisateur soumet une requête dans le chat, il forme simultanément une invite et interroge la base de données vectorielle. Si des vecteurs similaires sont trouvés, les données extraites sont analysées et ajoutées en tant que contexte à l'invite formée. Le système envoie ensuite une requête au réseau neuronal et transmet la réponse reçue à l'utilisateur dans le chat.

Bien que l'exemple mentionne des services en nuage tels qu'OpenAI et AstraDB, vous pouvez utiliser n'importe quel service compatible, y compris ceux déployés localement sur les serveurs LeaderGPU. Si vous ne trouvez pas l'intégration dont vous avez besoin dans la liste des blocs disponibles, vous pouvez l'écrire vous-même ou ajouter un bloc créé par quelqu'un d'autre.

Démarrage rapide

Préparation du système

La façon la plus simple de déployer Langflow est de le faire dans un conteneur Docker. Pour configurer le serveur, commencez par installer Docker Engine. Ensuite, mettez à jour le cache de paquets et les paquets avec leurs dernières versions :

sudo apt update && sudo apt -y upgrade

Installer les paquets supplémentaires requis par Docker :

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Télécharger la clé GPG pour ajouter le dépôt officiel de Docker :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Ajoutez le dépôt à APT en utilisant la clé que vous avez téléchargée et installée précédemment :

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiser la liste des paquets :

sudo apt update

Pour s'assurer que Docker sera installé à partir du dépôt nouvellement ajouté et non à partir de celui du système, vous pouvez exécuter la commande suivante :

apt-cache policy docker-ce

Installer le moteur Docker :

sudo apt install docker-ce

Vérifiez que Docker a été installé avec succès et que le démon correspondant est en cours d'exécution et dans l'état active (running):

sudo systemctl status docker

● docker.service - Docker Application Container Engine
  Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
  Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
    Docs: https://docs.docker.com
Main PID: 1842 (dockerd)
   Tasks: 29
  Memory: 1.8G
     CPU: 3min 15.715s
  CGroup: /system.slice/docker.service

Construire et exécuter

Tout est prêt pour construire et exécuter un conteneur Docker avec Langflow. Cependant, il y a une mise en garde : au moment de la rédaction de ce guide, la dernière version (taguée v1.1.0) a une erreur et ne démarre pas. Pour éviter ce problème, nous utiliserons la version précédente, v1.0.19.post2, qui fonctionne parfaitement dès son téléchargement.

L'approche la plus simple consiste à télécharger le dépôt du projet depuis GitHub :

git clone https://github.com/langflow-ai/langflow

Naviguez jusqu'au répertoire contenant l'exemple de configuration de déploiement :

cd langflow/docker_example

Vous devez maintenant faire deux choses. Tout d'abord, modifiez la balise release afin qu'une version fonctionnelle (au moment de la rédaction de ces instructions) soit construite. Deuxièmement, ajoutez une autorisation simple afin que personne ne puisse utiliser le système sans connaître le login et le mot de passe.

Ouvrez le fichier de configuration :

sudo nano docker-compose.yml

au lieu de la ligne suivante :

image: langflowai/langflow:latest

spécifier la version au lieu de la balise latest:

image: langflowai/langflow:v1.0.19.post2

Vous devez également ajouter trois variables à la section environment:

  - LANGFLOW_AUTO_LOGIN=false
  - LANGFLOW_SUPERUSER=admin
  - LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

La première variable désactive l'accès à l'interface web sans autorisation. La deuxième ajoute le nom d'utilisateur qui recevra les droits d'administrateur du système. La troisième ajoute le mot de passe correspondant.

Si vous prévoyez de stocker le fichier docker-compose.yml dans un système de contrôle de version, évitez d'écrire le mot de passe directement dans ce fichier. Créez plutôt un fichier distinct avec une extension .env dans le même répertoire et stockez-y la valeur de la variable.

LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

Dans le fichier docker-compose.yml, vous pouvez désormais faire référence à une variable au lieu de spécifier directement un mot de passe :

LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD}

Pour éviter d'exposer accidentellement le fichier *.env sur GitHub, n'oubliez pas de l'ajouter à .gitignore. Votre mot de passe sera ainsi raisonnablement à l'abri d'un accès non désiré.

Il ne reste plus qu'à construire notre conteneur et à l'exécuter :

sudo docker compose up

Ouvrez la page web à http://[LeaderGPU_IP_address]:7860, et vous verrez le formulaire d'autorisation :

Une fois que vous avez saisi votre login et votre mot de passe, le système vous donne accès à l'interface web où vous pouvez créer vos propres applications. Pour des conseils plus approfondis, nous vous suggérons de consulter la documentation officielle. Elle fournit des détails sur diverses variables d'environnement qui permettent de personnaliser facilement le système en fonction de vos besoins.

Voir aussi:

Easy Diffusion UI

Wed, 22 Jan 2025 12:13:37 +0100

Easy Diffusion UI est un logiciel open source disponible en téléchargement sur GitHub. Voici comment l'installer sur Ubuntu 22.04 LTS. Si vous venez de louer un serveur, installez les pilotes GPU et étendez votre répertoire personnel. Ensuite, téléchargez la dernière version d'Easy Diffusion UI :

wget https://github.com/cmdr2/stable-diffusion-ui/releases/latest/download/Easy-Diffusion-Linux.zip

Décompressez l'archive ZIP téléchargée :

unzip Easy-Diffusion-Linux.zip

Changer de répertoire pour easy-diffusion :

cd easy-diffusion

Démarrer l'installation :

./start.sh

Il s'agit d'une collection de scripts qui télécharge et installe automatiquement tous les composants nécessaires. Il télécharge également le modèle standard de diffusion stable au format SafeTensors. Une fois tous les téléchargements et installations terminés, l'interface utilisateur d'Easy Diffusion se lancera automatiquement.

Utilisation de

L'article précédent, Stable Diffusion WebUI, décrit une méthode pour accepter les connexions depuis l'internet public et fournit une autorisation simple de login et de mot de passe. Dans le cas présent, nous souhaitons démontrer une autre méthode universelle pour transférer des ports par le biais d'une connexion SSH. Nous utilisons PuTTY pour établir une connexion sécurisée avec le serveur distant. Vous trouverez plus d'informations à ce sujet dans notre guide Se connecter à un serveur Linux.

Pour choisir les ports à transférer, ouvrez Connection > SSH > Tunnels dans l'arbre d'options de gauche. Tapez 9000 dans le champ Source Port et 127.0.0.1:9000 dans le champ Destination. Cliquez ensuite sur le bouton Add:

Vous pouvez ensuite revenir à Session et l'enregistrer pour une utilisation ultérieure. Connectez-vous au serveur distant comme d'habitude. Désormais, toutes les données que vous envoyez ou recevez sur le port 9000 de l'adresse de bouclage 127.0.0.1 seront redirigées vers le serveur distant. Cette méthode crée un tunnel virtuel sécurisé qui existe aussi longtemps que la connexion.

Une fois que Easy Diffusion UI démarre et que le transfert de port est activé, vous pouvez ouvrir un navigateur web et naviguer jusqu'à l'adresse http://127.0.0.1:9000. Nous vous recommandons de télécharger et d'installer des modèles personnalisés, comme décrit dans cet article, plutôt que de vous fier uniquement au modèle standard pour générer des images. N'oubliez pas d'augmenter le nombre d'étapes d'inférence et d'ajuster la résolution d'image souhaitée (marquée par des astérisques).

L'un des principaux avantages de l'interface utilisateur d'Easy Diffusion est sa prise en charge de plusieurs GPU. Lorsque vous souhaitez créer un lot d'images, vous pouvez choisir le nombre d'images qui seront créées en parallèle. Par exemple, si vous avez une configuration à double GPU :

Vous pouvez afficher la charge du GPU pendant le processus de génération d'images. Établissez une autre connexion SSH et exécutez une seule commande :

watch -n 1 nvidia-smi

Easy Diffusion UI simplifie également la création d'invites en fournissant de nombreux exemples de modificateurs d'image. Vous pouvez les mélanger pour obtenir des résultats plus précis :

C'est une bonne idée d'explorer PromptBook d'OpenArt. Ce guide peut considérablement améliorer vos compétences en matière de création d'invites. Avec l'interface Easy Diffusion, une fois l'image générée, vous pouvez la télécharger, l'utiliser comme exemple pour générer l'image suivante ou la modifier en un seul clic :

L'utilisation la plus courante du bouton Upscale consiste à augmenter la résolution d'une image. Le réseau neuronal génératif utilise l'image originale comme base et ajoute des pixels supplémentaires, interpolant ainsi l'image source à la taille souhaitée.

Lors de la génération de visages, des problèmes peuvent survenir, tels que des yeux mal alignés, des tailles disproportionnées ou des parties mal formées. Heureusement, ces problèmes peuvent être résolus à l'aide du bouton Fix Faces. En outre, des invites négatives peuvent être utilisées pour empêcher la génération de visages incorrects.

Désinstaller

Tous les fichiers, scripts, bibliothèques et modèles sont stockés dans un seul répertoire. Si vous souhaitez supprimer Easy Diffusion UI de votre serveur, il vous suffit d'effacer ce répertoire ainsi que tout son contenu :

sudo rm -rf easy-diffusion

Voir aussi:

Stable Video Diffusion

Wed, 22 Jan 2025 11:53:04 +0100

Les réseaux neuronaux génératifs peuvent créer différents types de contenu. Stable Diffusion a été créé pour générer des images à partir d'une description textuelle. Cependant, il peut également être utilisé pour créer de la musique, des sons et même des vidéos. Aujourd'hui, nous allons vous montrer comment créer de courtes vidéos à partir d'une seule image en utilisant Stable Diffusion avec WebUI et ComfyUI.

Installer Stable Diffusion

Commençons par installer Stable Diffusion en suivant notre guide pas à pas. Après l'installation, veuillez interrompre l'exécution du script webui.sh en appuyant sur Ctrl + C et fermer la connexion SSH. Le système ne vous permet pas d'installer des extensions avec les options --listen (--share) activées. Cela signifie que vous devez mettre en place une redirection de port (7860 et 8189) de votre machine locale vers le serveur distant. Le premier port est nécessaire pour WebUI et le second pour ComfyUI.

Par exemple, dans PuTTY, vous devez ouvrir Connection >> SSH >> Tunnels et ajouter deux nouveaux ports transférés comme le montre la capture d'écran suivante :

Maintenant, vous pouvez vous reconnecter au serveur distant et exécuter ./webui.sh à nouveau.

Ouvrez cette URL dans votre navigateur :

http://127.0.0.1:7860

Naviguez jusqu'à Extensions >> Available, puis cliquez sur le bouton Load from::

Le système téléchargera le fichier JSON avec toutes les extensions disponibles. Tapez ComfyUI dans le champ de recherche et cliquez sur le bouton Install:

La page web sera rechargée et vous obtiendrez un nouvel onglet ComfyUI dans le panneau principal. Allez-y et cliquez sur Install ComfyUI:

Lorsque l'installation est terminée, interrompez à nouveau l'exécution du script webui.sh en appuyant sur Ctrl + C.

Installer le modèle de diffusion vidéo stable

Ouvrez le répertoire du modèle :

cd stable-diffusion-webui/models/Stable-diffusion/

Télécharger le modèle complet de diffusion vidéo stable :

curl -L https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt/resolve/main/svd_xt.safetensors?download=true --output svd_xt.safetensors

Retour au répertoire d'origine :

cd ~/

Et relancez le service Stable Diffusion :

./webui.sh

Téléchargez l'exemple de workflow de diffusion vidéo stable au format JSON. Effacez le flux de travail par défaut de ComfyUI en appuyant sur Clear, puis Load l'exemple téléchargé :

Assurez-vous que vous avez sélectionné le bon modèle dans le nœud Image Only Checkpoint Loader (img2vid model):

Cliquez sur le bouton choose file to upload dans le nœud Load Image et sélectionnez une image unique que le réseau neuronal génératif transformera en vidéo :

Essayez de générer une vidéo avec tous les paramètres par défaut en cliquant sur le bouton Queue Prompt:

Une fois le processus terminé, vous obtiendrez votre vidéo au format WEBP dans le nœud SaveAnimatedWEBP. Cliquez avec le bouton droit de la souris sur la vidéo générée et choisissez Save Image:

Voici le résultat final GIF.

Résolution des problèmes

Si vous obtenez un message d'erreur : ModuleNotFoundError: No module named 'utils.json_util'; 'utils' is not a package veuillez suivre les étapes suivantes :

Renommez le répertoire utils en utilities :

mv /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utils /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utilities

Modifier custom_node_manager.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/app/custom_node_manager.py

Remplacer cette ligne :

from utils.json_util import merge_json_recursive

par :

from utilities.json_util import merge_json_recursive

Sauvegardez le fichier (Ctrl + O) et quittez l'éditeur (Ctrl + X). Editez ensuite main.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/main.py

Remplacez cette ligne :

import utils.extra_config

par :

import utilities.extra_config

Sauvegardez le fichier, quittez l'éditeur et relancez le service de diffusion stable :

./webui.sh

Voir aussi:

PyTorch pour Windows

Wed, 22 Jan 2025 11:35:30 +0100

Avant de commencer à installer PyTorch, vous devez installer l'interpréteur Python et Microsoft Visual C++ Redistributable. Ouvrez un navigateur web et accédez à la page de téléchargement de Python. Trouvez la dernière version de Python 3 et cliquez sur le lien :

Faites ensuite défiler la page et cliquez sur Windows Installer (64-bit):

Ouvrez le fichier téléchargé pour procéder à l'installation :

Cochez la case Add python.exe to PATH et cliquez sur Install Now:

Attendez une minute pour que le processus d'installation se termine :

Vous pouvez optionnellement Disable path length limit si vous prévoyez d'utiliser des noms longs qui pourraient dépasser les limites de MAX_PATH:

Installer MS Visual C++

Ensuite, téléchargez Microsoft Visual C++ Redistributable en utilisant ce lien et cliquez sur le programme d'installation :

Vous devez cocher la case I agree to the license terms and conditions et cliquer sur le bouton Install:

Après quelques secondes, ce logiciel sera installé et vous pourrez Close l'installer :

Maintenant, tout est prêt pour l'installation de PyTorch. Cliquez sur le bouton Start et tapez cmd sur le clavier. Faites un clic droit sur Command Prompt et sélectionnez Run as administrator dans le menu contextuel :

Installer PyTorch

Exécutez la commande suivante :

pip install torch torchvision

Si vous souhaitez installer une version spécifique de PyTorch, vous pouvez la spécifier lors de l'installation :

pip install torch==1.9.0 torchvision==0.10.0

Une fois l'installation terminée, vérifions que PyTorch fonctionne correctement. Exécutez la commande suivante pour ouvrir l'interpréteur Python :

python

Tapez ces deux chaînes de caractères, en terminant votre saisie par la touche Enter:

import torch
print(torch.__version__)

Si vous obtenez un résultat comme celui-ci, cela signifie que PyTorch a été installé correctement :

2.0.1+cu117

Voir aussi:

PyTorch pour Linux

Wed, 22 Jan 2025 10:14:16 +0100

Les distributions Linux modernes dépendent fortement de la version installée de Python. Par conséquent, avant d'installer PyTorch, nous vous recommandons de créer un environnement virtuel à l'aide de notre guide pas à pas sur les utilitaires du système Linux.

Activez l'environnement virtuel créé et procédez à la mise à niveau par pip3 :

pip3 install --upgrade pip

Démarrer l'installation de PyTorch :

pip3 install torch torchvision

Si vous souhaitez installer une version spécifique de PyTorch, tapez simplement le numéro de version requis :

pip3 install torch==1.9.0 torchvision==0.10.0

Lorsque l'installation est terminée, vérifions que PyTorch a été installé correctement. Ouvrez l'interpréteur Python :

python3

Tapez ces deux chaînes de caractères, en terminant votre saisie par la touche Entrée :

import torch
print(torch.__version__)

Si vous obtenez un résultat comme celui-ci, cela signifie que PyTorch a été installé correctement :

2.0.1+cu117

Voir aussi:

Stable Diffusion: Riffusion

Tue, 21 Jan 2025 14:12:29 +0100

Dans nos articles précédents, nous avons exploré les capacités fascinantes de la diffusion stable pour générer des images captivantes. Cependant, il est important de noter que ce puissant réseau neuronal génératif a encore plus à offrir.

Riffusion est un modèle de diffusion stable pour la création et l'édition de musique. Avec Riffusion, vous pouvez générer un spectrogramme d'un segment musical désiré et le transformer sans effort en un extrait musical. Installons Riffusion sur un serveur LeaderGPU et essayons-le en action.

Conditions préalables

Commencez par mettre à jour le dépôt de cache des paquets et les paquets installés :

sudo apt update && sudo apt -y upgrade

N'oubliez pas d'installer les pilotes NVIDIA® à l'aide de la commande autoinstall ou manuellement, en suivant notre guide étape par étape :

sudo ubuntu-drivers autoinstall

Redémarrez le serveur :

sudo shutdown -r now

Pour créer un environnement virtuel, les développeurs suggèrent d'utiliser un outil appelé Anaconda. Vous pouvez également utiliser venv, dont nous avons parlé dans le tutoriel sur les utilitaires du système Linux. Téléchargez le script d'installation d'Anaconda à l'aide de curl :

curl --output anaconda.sh https://repo.anaconda.com/archive/Anaconda3-5.3.1-Linux-x86_64.sh

Rendez-le exécutable :

chmod +x anaconda.sh

et l'exécuter :

./anaconda.sh

Répondez OUI à toutes les questions, sauf à la dernière (installer Microsoft VSCode). Ensuite, reconnectez-vous à la console SSH et créez un nouvel environnement virtuel avec Python v3.9 :

conda create --name riffusion python=3.9

Activez le nouvel environnement virtuel :

conda activate riffusion

Si vous souhaitez utiliser des formats musicaux autres que wav, il est nécessaire d'installer également le jeu de bibliothèques FFmpeg :

conda install -c conda-forge ffmpeg

Installer Riffusion

Clonez le dépôt Riffusion :

git clone https://github.com/riffusion/riffusion.git

Ouvrir le répertoire téléchargé :

cd riffusion

Effectuons quelques modifications dans le fichier d'exigences. Cela permet d'éviter les erreurs de compatibilité avec Torch :

nano requirements.txt

Trouver et corriger les versions des paquets :

diffusers==0.9.0
torchaudio==2.0.1

Enregistrez les modifications et poursuivez la préparation de l'environnement virtuel. La commande suivante installe tous les paquets nécessaires :

python -m pip install -r requirements.txt

Enfin, vous pouvez ouvrir une "aire de jeu". Il s'agit d'une interface web simple qui vous permet d'en savoir plus sur les fonctionnalités de Riffusion :

python -m riffusion.streamlit.playground

Ouvrez votre navigateur préféré et entrez l'adresse http://[SERVER_IP]:8501/

Tester une aire de jeux

Vous pouvez maintenant créer de la musique à l'aide d'invites textuelles et en modifiant les autres paramètres :

Vous pouvez également faire des choses délicates, comme diviser l'audio en composants distincts. Par exemple, vous pouvez extraire la voix de Bohemian rhapsody de Queen :

N'oubliez pas qu'il ne s'agit là que d'un exemple de la manière dont Riffusion peut être utilisé. En créant votre propre application, vous pouvez obtenir des résultats bien plus captivants. Les puissants serveurs de LeaderGPU se chargeront des calculs.

Voir aussi:

Stable Diffusion: Générer des visages reproductibles

Tue, 21 Jan 2025 13:51:05 +0100

La répétabilité est l'aspect le plus important lors de la création de contenu graphique à l'aide de réseaux neuronaux génératifs. Cela est vrai quel que soit le type de contenu créé, qu'il s'agisse d'un personnage de cinéma ou de jeu, d'un paysage ou d'un environnement scénique. Le problème principal peut être formulé comme suit : "Comment puis-je répéter mon résultat ? Chaque fois que vous commencez à générer des images avec les mêmes invites positives et négatives, vous obtiendrez des résultats différents. Parfois, les différences sont mineures et acceptables, mais dans la plupart des cas, elles peuvent poser un problème.

La diffusion stable est apprise sur un vaste ensemble de données issues du monde réel, ce qui explique pourquoi la répétabilité n'est pas un point fort de ce modèle de réseau neuronal. Toutefois, cette règle ne s'applique pas aux photos de célébrités. Ces photos sont beaucoup plus fréquentes dans le monde réel et, par conséquent, dans l'ensemble de données sur lequel Stable Diffusion a été entraîné. Vous pouvez utiliser ces photos comme une "constante" ou un "point de départ" dans le processus de génération.

Méthode 1. "Secoué, pas remué"

Bien entendu, il n'est pas nécessaire de créer uniquement des images de célébrités, mais vous pouvez utiliser plusieurs invites pertinentes pour obtenir des résultats plus ou moins cohérents. Par exemple, nous pouvons prendre deux chanteuses grecques célèbres : Elena Paparizou et Marina Satti, et obtenir des résultats reproductibles :

Model: Realistic Vision v6.0 beta 1

Positive prompts:

Elena Paparizou, Marina Satti, fashion portrait, alone, solo, greek woman in beautiful clothes, natural skin, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Cela fonctionne avec n'importe quelle célébrité, car Stable Diffusion a essayé de reproduire les traits les plus saillants du visage. Ici, nous utilisons le même modèle et "secouons" deux stars hollywoodiennes (Dwayne Johnson et Danny Trejo) en un nouveau personnage synthétique.

Positive prompts:

Dwayne Johnson, Danny Trejo, fashion portrait, alone, solo, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Chaque fois que vous mélangez les mêmes célébrités, vous obtenez des résultats similaires. Examinons une autre méthode pour générer des personnages reproductibles.

Méthode 2. Ancre de nom

Les célébrités sont un bon début, mais examinons d'autres méthodes pour obtenir des résultats reproductibles. La réponse est très simple : nous pouvons utiliser plusieurs noms humains. Chaque nation possède des noms uniques, liés à des caractéristiques linguistiques. Par exemple, le nom grec Kostas peut se traduire par "travail" ou "effort", tandis que Nikos signifie "Victoire du peuple". Ces deux noms créent une image unique de la personne générée, ce qui aide les modèles de réseaux neuronaux à comprendre nos objectifs de création.

Positive prompts:

Portrait of [Kostas | Nikos] on a white background, greek man, short haircut, beard

Negative prompts:

woman, bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Générons de nombreuses images (80-100) pour la création ultérieure d'ensembles de données. L'invite principale a été choisie pour fournir des images pratiques qui peuvent être facilement éliminées de l'arrière-plan. Les invites négatives nous évitent d'inclure dans l'ensemble de données des images aléatoires présentant des distorsions, ainsi que des images de femmes.

Conseil : si vous recevez des images très différentes les unes des autres, essayez de modifier le paramètre CFG Scale de 7,5 à 15. Cela forcera le réseau neuronal à suivre les invites de manière plus formelle.

Vous pouvez sélectionner vos propres noms uniques à l'aide d'un générateur de noms simple, comme Behind the Name. Vous pouvez également utiliser la fonction ControlNet pour obtenir un meilleur contrôle.

Méthode 3. Enseigner l'apparence

Nous ne pouvons pas influencer directement le résultat final, mais nous observons que certains tokens (tels que les tokens d'images de célébrités) ont plus de poids que d'autres. Cela signifie que nous pouvons créer notre jeton "célébrité" conditionnel en créant une invite appropriée pour ce jeton et en entraînant le modèle sur ce jeton. C'est ainsi que fonctionne LoRA (Low-Rank Adaptation of Large Language Models). Vous pouvez utiliser notre guide étape par étape pour entraîner votre propre modèle LoRA sur la base d'un ensemble de données créé par vos soins.

Après avoir supprimé l'arrière-plan, nous obtenons des portraits clairs et les utilisons pour créer un modèle LoRA spécifique. Ce modèle permet de reproduire un visage avec quelques changements mineurs :

Maintenant, nous pouvons générer ce personnage dans différents lieux, créer des histoires et le placer dans différents rôles : du jardinier à l'homme d'affaires. Son visage sera toujours reconnaissable et reproductible :

Cette méthode n'est pas idéale, mais elle fonctionne parfaitement dans diverses situations. Vous n'avez pas besoin de préparer un ensemble de données à partir d'une personne réelle, et il peut être généré à distance :

Vous pouvez tenter de créer un tel personnage virtuel vous-même, sans l'aide d'un designer professionnel ou d'un spécialiste de la modélisation 3D. Tout ce dont vous avez besoin, ce sont des GPU rapides, que vous pouvez trouver dans les serveurs dédiés de LeaderGPU.

Voir aussi:

Stable Diffusion: LoRA selfie

Tue, 21 Jan 2025 13:44:25 +0100

Vous pouvez créer votre premier ensemble de données à l'aide d'un appareil photo simple et d'un arrière-plan relativement uniforme, tel qu'un mur blanc ou un rideau occultant monotone. Pour un échantillon de données, j'ai utilisé un appareil photo sans miroir Olympus OM-D EM5 Mark II avec des objectifs 14-42. Cet appareil photo peut être commandé à distance à partir de n'importe quel smartphone et dispose d'un mode de prise de vue en continu très rapide.

J'ai monté l'appareil photo sur un trépied et j'ai réglé la priorité de mise au point sur le visage. Ensuite, j'ai sélectionné le mode dans lequel l'appareil photo capture 10 images consécutives toutes les 3 secondes et j'ai lancé le processus. Pendant la prise de vue, j'ai lentement tourné la tête dans la direction sélectionnée et j'ai changé de direction toutes les 10 images :

Le résultat était d'environ 100 images avec un arrière-plan monotone :

L'étape suivante consiste à supprimer l'arrière-plan et à laisser le portrait sur un fond blanc.

Supprimer l'arrière-plan

Vous pouvez utiliser la fonction standard d'Adobe Photoshop Remove background et le traitement par lots. Stockons les actions que nous voulons appliquer à chaque image d'un ensemble de données. Ouvrez une image, cliquez sur l'icône du triangle, puis sur le symbole +:

Saisissez le nom de la nouvelle action, par exemple, Remove Background et cliquez sur Record:

Dans l'onglet Layers, trouvez le symbole du cadenas et cliquez dessus :

Cliquez ensuite sur le bouton Remove background dans le panneau flottant :

Cliquez avec le bouton droit de la souris sur Layer 0 et sélectionnez Flatten Image:

Toutes nos actions ont été enregistrées. Arrêtons ce processus :

Vous pouvez maintenant fermer le fichier ouvert sans enregistrer les modifications et sélectionner File >> Scripts >> Image Processor…

Sélectionnez les répertoires d'entrée et de sortie, choisissez l'action Remove Background créée à l'étape 4 et cliquez sur le bouton Run:

Soyez patient. Adobe Photoshop ouvrira chaque image dans le répertoire sélectionné, répétera les actions enregistrées (désactiver le verrouillage des calques, supprimer l'arrière-plan, aplatir l'image) et les enregistrera dans un autre répertoire sélectionné. Ce processus peut prendre quelques minutes, en fonction du nombre d'images.

Lorsque le processus est terminé, vous pouvez passer à l'étape suivante.

Téléchargement sur le serveur

Utilisez l'un des guides suivants (adaptés au système d'exploitation de votre PC) pour télécharger le répertoire dataset sur le serveur distant. Par exemple, placez-le dans le répertoire d'accueil de l'utilisateur par défaut, /home/usergpu:

Pré-installation

Mise à jour des paquets système existants :

sudo apt update && sudo apt -y upgrade

Installer deux paquets supplémentaires :

sudo apt install -y python3-tk python3.10-venv

Installons la version 11.8 de la boîte à outils CUDA®. Téléchargez le fichier pin spécifique :

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

La commande suivante place le fichier téléchargé dans le répertoire système, qui est contrôlé par le gestionnaire de paquets apt:

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

L'étape suivante consiste à télécharger le référentiel CUDA® principal :

wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Ensuite, procédez à l'installation du paquet à l'aide de l'utilitaire standard dpkg:

sudo dpkg -i cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Copiez le trousseau de clés GPG dans le répertoire système. Il pourra ainsi être utilisé par les utilitaires du système d'exploitation, y compris le gestionnaire de paquets apt :

sudo cp /var/cuda-repo-ubuntu2204-11-8-local/cuda-*-keyring.gpg /usr/share/keyrings/

Mettre à jour les dépôts de cache du système :

sudo apt-get update

Installer la boîte à outils CUDA® à l'aide d'apt :

sudo apt-get -y install cuda

Ajoutez CUDA® à PATH. Ouvrez le shell bash config :

nano ~/.bashrc

Ajoutez les lignes suivantes à la fin du fichier :

export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64\
                         ${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Enregistrez le fichier et redémarrez le serveur :

sudo shutdown -r now

Installer l'entraîneur

Copier le dépôt du projet Kohya sur le serveur :

git clone https://github.com/bmaltais/kohya_ss.git

Ouvrir le répertoire téléchargé :

cd kohya_ss

Rendez le script d'installation exécutable :

chmod +x ./setup.sh

Exécuter le script :

./setup.sh

Vous recevrez un message d'avertissement de l'utilitaire d'accélération. Résolvons le problème. Activez l'environnement virtuel du projet :

source venv/bin/activate

Installez le paquetage manquant :

pip install scipy

Et configurez manuellement l'utilitaire d'accélération :

accelerate config

Attention, l'activation d'un nombre impair de CPU provoquera une erreur. Par exemple, si j'ai 5 GPU, seuls 4 peuvent être utilisés avec ce logiciel. Sinon, une erreur se produira au démarrage du processus. Vous pouvez immédiatement vérifier la nouvelle configuration de l'utilitaire en appelant un test par défaut :

accelerate test

Si tout va bien, vous recevrez un message comme celui-ci :

Test is a success! You are ready for your distributed training!

deactivate

Maintenant, vous pouvez initier le serveur public du formateur avec l'interface graphique de Gradio et une simple authentification par login/mot de passe (changez l'utilisateur/mot de passe par le vôtre) :

./gui.sh --share --username user --password password

Vous recevrez deux chaînes de caractères :

Running on local URL: http://127.0.0.1:7860
Running on public URL: https://.gradio.live

Ouvrez votre navigateur web et entrez l'URL publique dans la barre d'adresse. Saisissez votre nom d'utilisateur et votre mot de passe dans les champs appropriés, puis cliquez sur Connexion :

Préparer le jeu de données

Commencez par créer un nouveau dossier dans lequel vous stockerez le modèle LoRA entraîné :

mkdir /home/usergpu/myloramodel

Ouvrez les onglets suivants : Utilities >> Captioning >> BLIP captioning. Remplissez les champs comme indiqué dans l'image et cliquez sur Caption images:

Le formateur téléchargera et exécutera un modèle de réseau neuronal spécifique (1,6 Gb) qui crée des invites textuelles pour chaque fichier image dans le répertoire sélectionné. Il sera exécuté sur un seul GPU et prendra environ une minute.

Passez à l'onglet LoRA >> Tools >> Dataset preparation >> Dreambooth/LoRA folder preparation, remplissez les trous et appuyez successivement sur Prepare training data et Copy info to Folders Tab:

Dans cet exemple, nous utilisons le nom nikolai comme Instance prompt et "person" comme Class prompt. Nous définissons également /home/usergpu/dataset comme Training Images et /home/usergpu/myloramodel comme Destination training directory.

Passez à nouveau à l'onglet LoRA >> Training >> Folders. Assurez-vous que les noms Image folder, Output folder et Logging folder sont correctement remplis. Si vous le souhaitez, vous pouvez remplacer Model output name par votre propre adresse. Enfin, cliquez sur le bouton Start training:

Le système commencera à télécharger des fichiers et des modèles supplémentaires (~10 GB). Ensuite, le processus d'apprentissage commencera. En fonction de la quantité d'images et des paramètres appliqués, cela peut prendre plusieurs heures. Une fois la formation terminée, vous pouvez télécharger le répertoire /home/usergpu/myloramodel sur votre ordinateur pour une utilisation ultérieure.

Testez votre LoRA

Nous avons préparé quelques articles sur Stable Diffusion et ses forks. Vous pouvez essayer d'installer Easy Diffusion avec notre guide Easy Diffusion UI. Une fois que le système a été installé et fonctionne, vous pouvez télécharger votre modèle LoRA au format SafeTensors directement sur /home/usergpu/easy-diffusion/models/lora

Mettez à jour la page web d'Easy Diffusion et sélectionnez votre modèle dans la liste déroulante :

Écrivons une simple invite, portrait of <nikolai> wearing a cowboy hat, et générons nos premières images. Ici, nous avons utilisé un modèle de diffusion stable personnalisé téléchargé sur civitai.com: Realistic Vision v6.0 B1:

Vous pouvez expérimenter avec des invites et des modèles, basés sur la diffusion stable, pour obtenir de meilleurs résultats. Nous vous souhaitons beaucoup de plaisir !

Voir aussi:

Stable Diffusion: Qu'est-ce que ControlNet ?

Tue, 21 Jan 2025 10:42:39 +0100

Les personnes qui découvrent les réseaux neuronaux génératifs pensent souvent à tort que le contrôle du résultat final est extrêmement difficile, en particulier lorsqu'il s'agit de modifier le résultat en changeant la formulation de l'invite. À l'heure actuelle, il existe une série d'outils connus sous le nom de ControlNet qui facilitent un contrôle relativement simple et efficace des résultats de la génération.

Dans cet article, nous allons montrer comment manipuler facilement la pose des personnages générés en utilisant des images préexistantes et des "squelettes" personnalisés, à l'aide d'un de ces outils, OpenPose.

Étape 1. Installer la diffusion stable

Veuillez utiliser notre guide pas à pas pour installer Stable Diffusion avec le modèle de base et l'interface WebUI. Ce guide est basé sur le script AUTOMATIC1111.

Etape 2. Installer l'extension ControlNet

Nous déconseillons fortement l'installation de l'extension ControlNet (sd-webui-controlnet) à partir du dépôt standard en raison de problèmes potentiels de fonctionnalité. L'un des problèmes majeurs que nous avons rencontrés lors de la préparation de ce guide est le blocage de l'interface web. Bien que l'image soit initialement générée avec succès, l'interface WebUI ne répond plus lorsque l'image est générée une seconde fois. Une solution alternative serait d'installer la même extension à partir d'une source externe.

Ouvrez l'interface WebUI et suivez les onglets : Extensions > Install from URL. Collez cette URL dans le champ approprié :

https://github.com/Mikubill/sd-webui-controlnet

Cliquez ensuite sur le bouton Install:

Lorsque le processus est terminé avec succès, le message suivant doit apparaître :

Installed into /home/usergpu/stable-diffusion-webui/extensions/sd-webui-controlnet. Use Installed tab to restart.

Redémarrons l'URL en cliquant sur le bouton Appliquer et redémarrer l'interface utilisateur dans l'onglet Installé :

Après le redémarrage de l'interface, le nouvel élément ControlNet apparaît avec de nombreuses options supplémentaires :

Étape 3. Télécharger OpenPose

Ajouter la clé HF

Générons et ajoutons une clé SSH que vous pourrez utiliser dans Hugging Face :

cd ~/.ssh && ssh-keygen

Lorsque la paire de clés est générée, vous pouvez afficher la clé publique dans l'émulateur de terminal :

cat id_rsa.pub

Copiez toutes les informations commençant par ssh-rsa et se terminant par usergpu@gpuserver, comme indiqué dans la capture d'écran suivante :

Ouvrez un navigateur web, tapez https://huggingface.co/ dans la barre d'adresse et appuyez sur Enter. Connectez-vous à votre compte HF et ouvrez les paramètres du profil. Choisissez ensuite SSH and GPG Keys et cliquez sur le bouton Add SSH Key:

Remplissez le Key name et collez le SSH Public key copié depuis le terminal. Sauvegardez la clé en appuyant sur Add key:

Maintenant, votre compte HF est lié à la clé SSH publique. La seconde partie (clé privée) est stockée sur le serveur. L'étape suivante consiste à installer une extension Git LFS (Large File Storage) spécifique, qui est utilisée pour télécharger des fichiers volumineux tels que des modèles de réseaux neuronaux.

Installer Git LFS

L'étape suivante consiste à installer une extension Git LFS (Large File Storage) spécifique, utilisée pour télécharger des fichiers volumineux tels que des modèles de réseaux neuronaux. Ouvrez votre répertoire personnel :

cd ~/

Téléchargez et exécutez le script shell. Ce script installe un nouveau dépôt tiers avec git-lfs :

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Vous pouvez maintenant l'installer à l'aide du gestionnaire de paquets standard :

sudo apt-get install git-lfs

Configurons git pour qu'il utilise notre pseudo HF :

git config --global user.name "John"

Et lié au compte email HF :

git config --global user.email "john.doe@example.com"

Télécharger le référentiel

Nous recommandons, si possible, d'utiliser un disque dur local pour télécharger et stocker les modèles. Pour en savoir plus, consultez notre guide " Partitionnement des disques sous Linux". Pour cet exemple, nous avons monté un disque SSD sur le point de montage /mnt/fastdisk. Il appartiendra à l'utilisateur par défaut :

sudo chown usergpu:usergpu /mnt/fastdisk

Ouvrez le répertoire :

cd /mnt/fastdisk

Clonez le dépôt ControlNet à partir de HuggingFace. Git-LFS précédemment installé remplacera automatiquement les pointeurs par de vrais fichiers :

git clone git@hf.co:lllyasviel/ControlNet-v1-1

Dans cet exemple, nous n'ajoutons qu'un seul modèle à l'interface Web de diffusion stable. Cependant, vous pouvez copier tous les modèles disponibles dans le référentiel (~18GB) :

cp /mnt/fastdisk/ControlNet-v1-1/control_v11p_sd15_openpose.pth /home/usergpu/stable-diffusion-webui/models/ControlNet/

Étape 4. Exécuter le processus de génération

Le modèle actuel fourni est assez basique et pourrait ne pas donner de résultats satisfaisants. Nous suggérons donc de le remplacer par un modèle personnalisé. Vous trouverez des indications sur la manière de procéder dans cet article : Modèles de diffusion stable : personnalisation et options. Pour cet exemple, nous avons téléchargé RealisticVision v6.0 B1.

Si vous souhaitez générer votre première image à l'aide d'OpenPose, ouvrez l'onglet ControlNet, choisissez OpenPose, cochez Enable et Allow Preview. Cliquez ensuite sur Upload pour ajouter une image contenant la pose souhaitée :

Vous pouvez demander au système de générer un aperçu de la pose en cliquant sur le bouton avec l'icône d'explosion :

A gauche, l'image originale est affichée. À droite, vous pouvez voir le "squelette" représentant la pose telle qu'elle a été reconnue par le modèle de réseau neuronal :

Vous pouvez maintenant taper l'invite principale, par exemple "dancing bear, by Pixar" ou "dancing fox, by Pixar" et cliquer sur le bouton Generate. Après quelques secondes, vous obtiendrez des résultats comme ceux-ci :

Le système tentera de générer une nouvelle image à partir du "squelette" obtenu à partir de l'image originale. Dans certains cas, la pose peut ne pas être exacte, mais cela peut être facilement corrigé en modifiant manuellement le "squelette".

Étape 5. Modification de la pose

Bien que cela puisse sembler magique, le modèle n'est pas parfait et des erreurs occasionnelles peuvent avoir un impact sur l'image finale. Pour éviter tout problème lors de la génération de l'image, vous avez la possibilité d'ajuster manuellement le "squelette" en cliquant sur le bouton Edit:

Dans l'éditeur fourni, vous pouvez facilement ajuster la pose par glisser-déposer, ou supprimer les points non désirés par un clic droit. Il suffit ensuite de cliquer sur le bouton Send pose to ControlNet pour que la nouvelle pose soit appliquée :

Au-delà d'OpenPose, ControlNet offre une variété d'outils pour personnaliser et perfectionner vos résultats. De plus, les serveurs dédiés fournis par LeaderGPU garantissent un processus rapide et pratique.

Voir aussi:

Fooocus : Repenser le SD et le MJ

Tue, 21 Jan 2025 10:36:52 +0100

L'avènement de Stable Diffusion et de MidJourney a révolutionné notre compréhension du potentiel des réseaux neuronaux génératifs. Ces outils ont dévoilé une nouvelle perspective sur le processus de création d'images et sur la mesure dans laquelle nous pouvons le manipuler. L'approche principale consiste à fournir au système des indications sur le résultat souhaité. Nous mettons essentiellement l'accent sur trois aspects importants : l'objet, le style et l'environnement.

Des invites supplémentaires fournissant des instructions plus spécifiques, telles que la composition souhaitée, le type d'appareil photo/objectif et la colorisation, sont également importantes, mais pas indispensables. Plus les instructions sont complètes, plus il est facile pour le réseau neuronal de les traiter. Le rôle d'un ingénieur rapide a même émergé dans l'espace professionnel. Toutefois, ce rôle peut être facilement remplacé par les mêmes réseaux neuronaux génératifs. En combinant la création d'images avec des compétences en matière de création de texte, nous pouvons générer des invites supplémentaires afin d'obtenir un résultat optimal.

C'est le concept fondamental de Fooocus. Il intègre le modèle XL Stable Diffusion et un générateur de messages basé sur GPT2, qui enrichit et détaille votre message simple. De plus, Fooocus est équipé de diverses améliorations et extensions. Ces fonctionnalités facilitent la génération d'images spectaculaires à travers une interface simple, dépourvue d'outils complexes. Entrons dans le vif du sujet et installons Fooocus sur un serveur dédié LeaderGPU.

Conditions préalables

Commencez par les prérequis de l'installation et redémarrez ensuite :

sudo apt update && sudo apt -y upgrade && sudo ubuntu-drivers autoinstall && sudo shutdown -r now

Télécharger le script shell qui installe Anaconda pour la gestion des environnements virtuels :

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

Définissez le drapeau d'exécution et fournissez l'accès aux données :

chmod a+x Anaconda3-2023.09-0-Linux-x86_64.sh

Exécuter le script d'installation :

./Anaconda3-2023.09-0-Linux-x86_64.sh

Une fois le processus terminé, nous vous recommandons de déconnecter la session SSH et de vous préparer à la redirection de port. Vous devez transférer le port 7865 du serveur distant vers une adresse de bouclage locale, 127.0.0.1:7865. Pour plus d'informations, veuillez vous référer à l'un de nos guides précédents : La diffusion vidéo stable. Ensuite, reconnectez-vous et procédez au clonage du dépôt du projet sur un GitHub.

Fooocus install

git clone https://github.com/lllyasviel/Fooocus.git

Changez de répertoire pour Fooocus :

cd Fooocus

Créer un environnement virtuel en utilisant Anaconda et la configuration YAML préparée par l'auteur du projet :

conda env create -f environment.yaml

Changeons notre environnement de base pour un environnement nouvellement créé :

conda activate fooocus

L'étape suivante consiste à installer les bibliothèques Python :

pip install -r requirements_versions.txt

Maintenant, tout est prêt à démarrer :

Fooocus start

python entry_with_update.py

Le démarrage initial peut prendre un certain temps, car l'application vérifie et télécharge tous les fichiers nécessaires au fonctionnement. Vous pouvez prendre une tasse de café pendant ce temps. Une fois le processus terminé, ouvrez votre navigateur et tapez l'URL suivante dans la barre d'adresse :

http://127.0.0.1:7865

Saisissez votre simple invite et cliquez sur le bouton Generate. Si vous voulez plus de contrôle, cochez Advanced et sélectionnez les options nécessaires :

La véritable magie se déroule en coulisses. Dès que vous cliquez sur le bouton Generate, votre message est transféré au modèle linguistique basé sur le GPT2. Ce modèle transforme votre bref message en un mélange de messages positifs et négatifs élaborés. Ce mélange est ensuite introduit dans le modèle Stable Diffusion XL, affiné pour émuler le style MidJourney. Par conséquent, même une brève invite peut générer des résultats impressionnants.

Bien sûr, il n'y a aucune restriction à la rédaction de vos propres messages-guides. Cependant, après plusieurs itérations, il devient évident que même en l'absence d'une telle possibilité, le contenu généré reste intriguant et diversifié.

Voir aussi:

Rendu à distance de Blender avec Flamenco

Tue, 21 Jan 2025 09:47:24 +0100

Lorsque le rendu de scènes lourdes dans Blender commence à prendre trop de temps à votre équipe, vous avez deux options : soit mettre à niveau l'ordinateur de chaque membre de l'équipe, soit sous-traiter le rendu à une ferme dédiée. De nombreuses entreprises proposent des solutions de rendu prêtes à l'emploi, mais si vous avez besoin d'un contrôle total sur l'infrastructure, ces solutions peuvent ne pas être l'option la plus fiable.

Une autre approche pourrait consister à créer une infrastructure hybride. Dans ce cas, le stockage des données et la gestion de la ferme de rendu sont conservés dans votre infrastructure existante. Le seul élément qui serait situé à l'extérieur serait les serveurs GPU loués sur lesquels le rendu serait effectué.

En général, l'infrastructure de la ferme de rendu pour Blender ressemble à ceci :

Ici, nous avons un nœud central Manager qui organise tous les processus. Il reçoit les tâches de rendu des utilisateurs via une adresse spécifique Blender Add-on et déplace tous les fichiers nécessaires vers Shared Storage. Ensuite, Manager distribue les tâches à Worker nodes. Ils reçoivent un travail contenant toutes les informations sur l'endroit où le travailleur peut trouver les fichiers à rendre et sur ce qu'il doit faire avec les résultats obtenus. Pour mettre en œuvre ce schéma, vous pouvez utiliser une application entièrement libre et gratuite appelée Flamenco. Dans ce guide, nous montrons comment préparer tous les nœuds, en particulier les nœuds Manager et Worker.

Le nœud Storage n'a pas d'exigences particulières. Il peut être utilisé avec n'importe quel système d'exploitation prenant en charge les protocoles SMB/CIFS ou NFS. La seule exigence est que le répertoire de stockage soit monté et accessible par le système d'exploitation. Dans votre infrastructure, il peut s'agir de n'importe quel dossier partagé accessible à tous les nœuds.

Chaque nœud a des adresses IP différentes et le serveur Wireguard VPN sera un point central qui les réunira en un seul réseau L2. Ce serveur, situé sur le périmètre externe, vous permet de travailler sans modifier la politique NAT existante.

Pour cet exemple, nous créons la configuration mixte suivante :

10.0.0.1 - Wireguard VPN server (serveur virtuel par n'importe quel fournisseur d'infrastructure) avec une IP externe ;
10.0.0.2 - Worker node (serveur dédié de LeaderGPU) avec une IP externe ;
10.0.0.3 - Manager node (serveur virtuel dans le réseau du bureau) situé derrière le NAT ;
10.0.0.4 - Storage node (serveur virtuel dans le réseau de bureau) situé derrière NAT ;
10.0.0.5 - User node (ordinateur portable du consommateur dans le réseau du bureau) situé derrière NAT.

Étape 1. Wireguard

Serveur VPN

Vous pouvez installer et configurer Wireguard manuellement, en utilisant un guide officiel et des exemples. Cependant, il existe une alternative plus simple : un script non officiel réalisé par un ingénieur logiciel parisien (Stanislas aka angristan).

Téléchargez le script depuis GitHub :

wget https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh

Rendez-le exécutable :

sudo chmod +x wireguard-install.sh

Exécuter :

sudo ./wireguard-install.sh

Suivez les instructions et définissez la plage d'adresses IP 10.0.0.1/24. Le système vous demandera de créer immédiatement un fichier de configuration pour le premier client. Selon le plan, ce client sera le nœud de travail avec le nom Worker et l'adresse 10.0.0.2. Lorsque le script est terminé, un fichier de configuration apparaît dans le répertoire racine : /root/wg0-client-Worker.conf.

Exécutez la commande suivante pour visualiser cette configuration :

cat /home/usergpu/wg0-client-Worker.conf

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0

Exécutez à nouveau le script d'installation pour créer un autre client. Ajoutez tous les futurs clients de cette manière, et enfin, vous pouvez vérifier que tous les fichiers de configuration ont été créés :

cd ~/

ls -l | grep wg0

-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Manager.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Storage.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-User.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:58 wg0-client-Worker.conf

Clients VPN

Les clients VPN comprennent tous les nœuds qui doivent être connectés à un réseau unique. Dans notre guide, il s'agit du nœud gestionnaire, du nœud de stockage, du nœud client (si vous utilisez Linux) et des nœuds de travail. Si le serveur VPN s'exécute sur un nœud de travail, il n'est pas nécessaire de le configurer en tant que client (cette étape peut être ignorée).

Mettez à jour le référentiel de cache des paquets, puis installez les paquets Wireguard et CIFS :

sudo apt update && sudo apt -y install wireguard cifs-utils

Élever les privilèges au niveau du superutilisateur :

sudo -i

Ouvrez le répertoire de configuration de Wireguard :

cd /etc/wireguard

Exécutez la commande umask afin que seul le superutilisateur ait accès aux fichiers de ce répertoire :

umask 077

Générer une clé privée et l'enregistrer dans un fichier :

wg genkey > private-key

Générer une clé publique à partir de la clé privée :

wg pubkey > public-key < private-key

Créer un fichier de configuration :

nano /etc/wireguard/wg0.conf

Collez votre propre configuration, créée pour ce client :

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [SERVER_IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0
PersistentKeepalive = 1

N'oubliez pas d'ajouter l'option PersistentKeepalive = 1 (où 1 signifie 1 seconde) sur chaque nœud situé derrière un NAT. Vous pouvez choisir cette période de manière expérimentale. La valeur recommandée par les auteurs de Wireguard est de 25. Sauvegardez le fichier et quittez, en utilisant le raccourci CTRL + X et la touche Y pour confirmer.

Si vous voulez laisser passer le trafic internet, mettez AllowedIPs à 0.0.0.0/0,::/0

Déconnectez-vous ensuite du compte root :

exit

Démarrez la connexion à l'aide de systemctl :

sudo systemctl start wg-quick@wg0.service

Vérifiez que tout est en ordre et que le service a bien démarré :

sudo systemctl status wg-quick@wg0.service

● wg-quick@wg0.service - WireGuard via wg-quick(8) for wg0
Loaded: loaded (/lib/systemd/system/wg-quick@.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2023-10-23 09:47:53 UTC; 1h 45min ago
  Docs: man:wg-quick(8)
        man:wg(8)
        https://www.wireguard.com/
        https://www.wireguard.com/quickstart/
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg-quick.8
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg.8
Process: 4128 ExecStart=/usr/bin/wg-quick up wg0 (code=exited, status=0/SUCCESS)
Main PID: 4128 (code=exited, status=0/SUCCESS)
  CPU: 76ms

Si vous rencontrez une erreur telle que "resolvconf : command not found" dans Ubuntu 22.04, créez simplement un lien symbolique :

sudo ln -s /usr/bin/resolvectl /usr/local/bin/resolvconf

Activez le nouveau service pour qu'il se connecte automatiquement pendant que le système d'exploitation démarre :

sudo systemctl enable wg-quick@wg0.service

Vous pouvez maintenant vérifier la connectivité en envoyant des paquets d'écho :

ping 10.0.0.1

PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=145 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=4 ttl=64 time=72.2 ms
--- 10.0.0.1 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 71.981/90.230/144.750/31.476 ms

Étape 2. Nœud NAS

Connectez-vous au serveur VPN en utilisant le guide de l'étape 1. Ensuite, installez les paquets Samba serveur et client :

sudo apt install samba samba-client

Sauvegardez votre configuration par défaut :

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

Créez un répertoire qui sera utilisé comme partage :

sudo mkdir /mnt/share

Créer un nouveau groupe d'utilisateurs qui aura accès au nouveau partage :

sudo groupadd smbusers

Ajouter un utilisateur existant au groupe créé :

sudo usermod -aG smbusers user

Définir un mot de passe pour cet utilisateur. Cette étape est nécessaire car le mot de passe du système et le mot de passe Samba sont des entités différentes :

sudo smbpasswd -a $USER

Supprimer la configuration par défaut :

sudo rm /etc/samba/smb.conf

et en créer une nouvelle :

sudo nano /etc/samba/smb.conf

[global]
workgroup = WORKGROUP
security = user
map to guest = bad user
wins support = no
dns proxy = no
[private]
path = /mnt/share
valid users = @smbusers
guest ok = no
browsable = yes
writable = yes

Sauvegardez le fichier et testez les nouveaux paramètres :

testparm -s

Redémarrez les deux services Samba :

sudo service smbd restart

sudo service nmbd restart

Enfin, donnez l'autorisation de partager le dossier :

sudo chown user:smbusers /mnt/share

Étape 3. Connexion du client Samba

Tous les nœuds de Flamenco utilisent un répertoire partagé situé dans /mnt/flamenco. Vous devez monter ce répertoire sur chaque noeud avant d'exécuter les scripts flamenco-client ou flamenco-manager. Dans cet exemple, nous utilisons un nœud de travail hébergé sur LeaderGPU avec le nom d'utilisateur usergpu. Veuillez remplacer ces détails par les vôtres s'ils diffèrent.

Créez un fichier caché dans lequel vous pouvez stocker les informations d'identification du partage SMB :

nano /home/usergpu/.smbcredentials

Tapez ces deux chaînes de caractères :

username=user # your Samba username
password=password # your Samba password

Enregistrez ce fichier et quittez. Ensuite, sécurisez ce fichier en modifiant les autorisations d'accès :

sudo chmod 600 /home/usergpu/.smbcredentials

Créez un nouveau répertoire qui peut être utilisé comme point de montage pour attacher le stockage distant :

sudo mkdir /mnt/flamenco

Et faire de l'utilisateur le propriétaire de ce répertoire :

sudo chown usergpu:users /mnt/flamenco

Il ne reste plus qu'à faire en sorte que le répertoire réseau soit monté automatiquement :

sudo nano /etc/systemd/system/mnt-flamenco.mount

[Unit]
Description=Mount Remote Storage
[Mount]
What=//10.0.0.4/private
Where=/mnt/flamenco
Type=cifs
Options=mfsymlinks,credentials=/home/usergpu/.smbcredentials,uid=usergpu,gid=users
[Install]
WantedBy=multi-user.target

Ajoutez deux lignes à votre configuration VPN dans la section [Interface]:

sudo -i

nano /etc/wireguard/wg0.conf

…
PostUp = ping 10.0.0.4 -c 4 && systemctl start mnt-flamenco.mount
PostDown = systemctl stop mnt-flamenco.mount
…

Redémarrez le serveur :

sudo shutdown -r now

Vérifiez que les services sont chargés et que le répertoire partagé est monté avec succès :

df -h

Filesystem          Size  Used Avail Use% Mounted on
tmpfs                35G  3.3M   35G   1% /run
/dev/sda2            99G   18G   77G  19% /
tmpfs               174G     0  174G   0% /dev/shm
tmpfs               5.0M     0  5.0M   0% /run/lock
tmpfs                35G  8.0K   35G   1% /run/user/1000
//10.0.0.4/private   40G  9.0G   31G  23% /mnt/flamenco

Étape 4. Nœud du gestionnaire

Établissez une connexion VPN en utilisant le guide de l'étape 1. Arrêtez le service VPN avant de continuer :

sudo systemctl stop wg-quick@wg0.service

Préparons-nous. Le montage automatique nécessite des utilitaires pour le protocole CIFS :

sudo apt -y install cifs-utils

La prochaine étape importante est l'installation de Blender. Vous pouvez le faire en utilisant le gestionnaire de paquets APT standard, mais cela installera probablement l'une des anciennes versions (inférieure à v3.6.4). Utilisons Snap pour installer la dernière version :

sudo snap install blender --classic

Vérifiez la version installée à l'aide de la commande suivante :

blender --version

Blender 4.4.3
build date: 2025-04-29
build time: 15:12:13
build commit date: 2025-04-29
build commit time: 14:09
build hash: 802179c51ccc
build branch: blender-v4.4-release
build platform: Linux
build type: Release
…

Si vous recevez un message d'erreur indiquant qu'il manque des bibliothèques, installez-les simplement. Toutes ces bibliothèques sont incluses dans le paquetage XOrg :

sudo apt -y install xorg

Télécharger l'application :

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Décompressez l'archive téléchargée :

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Allez dans le répertoire créé :

cd flamenco-3.7-linux-amd64/

Et démarrez Flamenco pour la première fois :

./flamenco-manager

Ouvrez l'adresse suivante dans votre navigateur web: http://10.0.0.3:8080/. Cliquez sur le bouton Let's go. Tapez /mnt/flamenco dans le champ requis, puis cliquez sur Next:

Flamenco tentera de localiser le fichier exécutable de Blender. Si vous avez installé Blender à partir de Snap, le chemin sera /snap/bin/blender. Vérifiez ce point et cliquez sur Next:

Vérifiez le résumé et cliquez sur Confirm:

Retournez dans la session SSH et utilisez le raccourci clavier Ctrl + C pour interrompre l'application. Le premier lancement génère le fichier de configuration flamenco-manager.yaml. Ajoutons quelques options aux sections variables et blenderArgs:

nano flamenco-manager.yaml

# Configuration file for Flamenco.
# For an explanation of the fields, refer to flamenco-manager-example.yaml
#
# NOTE: this file will be overwritten by Flamenco Manager's web-based configuration system.
#
# This file was written on 2023-10-17 12:41:28 +00:00 by Flamenco 3.7
_meta:
  version: 3
manager_name: Flamenco Manager
database: flamenco-manager.sqlite
listen: :8080
autodiscoverable: true
local_manager_storage_path: ./flamenco-manager-storage
shared_storage_path: /mnt/flamenco
shaman:
  enabled: true
  garbageCollect:
    period: 24h0m0s
    maxAge: 744h0m0s
    extraCheckoutPaths: []
task_timeout: 10m0s
worker_timeout: 1m0s
blocklist_threshold: 3
task_fail_after_softfail_count: 3
variables:
  blender:
    values:
    - platform: linux
      value: blender
    - platform: windows
      value: blender
    - platform: darwin
      value: blender
  storage:
    values:
    is_twoway: true
    values:
    - platform: linux
      value: /mnt/flamenco
    - platform: windows
      value: Z:\
    - platform: darwin
      value: /Volumes/shared/flamenco
  blenderArgs:
    values:
    - platform: all
      value: -b -y -E CYCLES -P gpurender.py

Le premier bloc additionnel décrit des variables bidirectionnelles supplémentaires, qui sont nécessaires pour les fermes multiplateformes. Cela résout le principal problème lié aux barres obliques et aux chemins d'accès. Sous Linux, nous utilisons le symbole de la barre oblique (/) comme séparateur, mais sous Windows, nous utilisons le symbole de la barre oblique inverse (\). Ici, nous créons la règle de remplacement pour toutes les alternatives disponibles : Linux, Windows et macOS (Darwin).

Lorsque vous montez un partage réseau sous Windows, vous devez choisir une lettre de lecteur. Par exemple, notre Storage est monté avec la lettre Z:. La règle de remplacement indique au système que pour la plateforme Windows, le chemin /mnt/flamenco sera situé à Z:\. Pour macOS, ce chemin sera /Volumes/shared/flamenco.

Regardez le deuxième bloc ajouté. Il indique à Blender d'utiliser le moteur de rendu Cycles et appelle un simple script Python, gpurender.py, lorsque Blender s'exécute. Il s'agit d'une astuce simple pour sélectionner le GPU au lieu du CPU. Il n'y a pas d'option standard pour faire cela directement. Vous ne pouvez pas invoquer blender --use-gpu ou quelque chose de similaire. Cependant, vous pouvez invoquer n'importe quel script Python externe en utilisant l'option -P. Cette commande demande à Worker de trouver un script dans le répertoire local et de l'exécuter lorsque la tâche assignée invoque l'exécutable de Blender.

Maintenant, nous pouvons déléguer le contrôle de l'application au sous-système init de systemd. Informons le système de l'emplacement du répertoire de travail, du fichier exécutable et des privilèges de l'utilisateur requis pour le lancement. Créez un nouveau fichier :

sudo nano /etc/systemd/system/flamenco-manager.service

Remplissez-le avec les chaînes suivantes :

[Unit]
Description=Flamenco Manager service
[Service]
User=user
WorkingDirectory=/home/user/flamenco-3.7-linux-amd64
ExecStart=/home/user/flamenco-3.7-linux-amd64/flamenco-manager
Restart=always
[Install]
WantedBy=multi-user.target

Enregistrez le fichier et quittez l'éditeur de texte nano.

sudo systemctl daemon-reload

sudo systemctl start flamenco-manager.service

sudo systemctl status flamenco-manager.service

● flamenco-manager.service - Flamenco Manager service
Loaded: loaded (/etc/systemd/system/flamenco-manager.service; disabled; vendor preset: enabled)
Active: active (running) since Tue 2023-10-17 11:03:50 UTC; 7s ago
Main PID: 3059 (flamenco-manage)
 Tasks: 7 (limit: 4558)
  Memory: 28.6M
     CPU: 240ms
CGroup: /system.slice/flamenco-manager.service
        └─3059 /home/user/flamenco-3.7-linux-amd64/flamenco-manager

Activer le démarrage automatique lorsque le système démarre :

sudo systemctl enable flamenco-manager.service

Étape 5. Nœud de travail

Connectez-vous au serveur VPN en utilisant le guide de l'étape 1 et montez le partage de l'étape 3. Arrêtez le service VPN avant de continuer :

sudo snap install blender --classic

Les fichiers *.blend modernes sont compressés avec l'algorithme Zstandard. Pour éviter les erreurs, il est essentiel d'intégrer la prise en charge de cet algorithme :

sudo apt -y install python3-zstd

Télécharger l'application :

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Décompressez l'archive téléchargée :

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Naviguez jusqu'au répertoire créé :

cd flamenco-3.7-linux-amd64/

Créer un script supplémentaire qui active le rendu GPU lors de l'exécution des jobs Flamenco :

nano gpurender.py

import bpy
def enable_gpus(device_type, use_cpus=False):
    preferences = bpy.context.preferences
    cycles_preferences = preferences.addons["cycles"].preferences
    cycles_preferences.refresh_devices()
    devices = cycles_preferences.devices
    if not devices:
        raise RuntimeError("Unsupported device type")
    activated_gpus = []
    for device in devices:
        if device.type == "CPU":
            device.use = use_cpus
        else:
            device.use = True
            activated_gpus.append(device.name)
            print('activated gpu', device.name)
    cycles_preferences.compute_device_type = device_type
    bpy.context.scene.cycles.device = "GPU"
    return activated_gpus
enable_gpus("CUDA")

Sauvegardez le fichier et quittez. Ensuite, créez un service séparé pour exécuter Flamenco à partir de systemd :

sudo nano /etc/systemd/system/flamenco-worker.service

[Unit]
Description=Flamenco Worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu/flamenco-3.7-linux-amd64
ExecStart=/home/usergpu/flamenco-3.7-linux-amd64/flamenco-worker
Restart=always
[Install]
WantedBy=multi-user.target

Rechargez la configuration et démarrez le nouveau service :

sudo systemctl daemon-reload

sudo systemctl start flamenco-worker.service

sudo systemctl status flamenco-worker.service

● flamenco-worker.service - Flamenco Worker service
Loaded: loaded (/etc/systemd/system/flamenco-worker.service; enabled; preset: enabled)
Active: active (running) since Tue 2023-10-17 13:56:18 EEST; 47s ago
Main PID: 636 (flamenco-worker)
 Tasks: 5 (limit: 23678)
Memory: 173.9M
   CPU: 302ms
CGroup: /system.slice/flamenco-worker.service
        └─636 /home/user/flamenco-3.7-linux-amd64/flamenco-worker

Activer le démarrage automatique lorsque le système démarre :

sudo systemctl enable flamenco-worker.service

Étape 6. Nœud utilisateur

Le nœud utilisateur peut être géré avec n'importe quel système d'exploitation. Dans ce guide, nous montrons comment configurer un nœud avec Windows 11 et les 4 composants nécessaires :

Connexion VPN
Répertoire distant monté
Blender installé
Module complémentaire Flamenco

Téléchargez et installez Wireguard depuis le site officiel. Créez un nouveau fichier texte et collez la configuration générée pour le client à l'étape 1. Renommez le fichier en flamenco.conf et ajoutez-le dans Wireguard en utilisant le bouton Add tunnel:

Connectez-vous à votre serveur en appuyant sur le bouton Activate:

Montons un répertoire distant. Cliquez avec le bouton droit de la souris sur This PC et sélectionnez Map network drive…

Choisissez Z: comme lettre de lecteur, tapez l'adresse du partage Samba \\10.0.0.4\private et n'oubliez pas de cocher Connect using different credentials. Cliquez ensuite sur Finish. Le système vous demandera d'entrer un nom d'utilisateur et un mot de passe pour le partage. Après cela, le répertoire réseau sera monté en tant que lecteur Z :.

Téléchargez et installez Blender à partir du site officiel. Ensuite, ouvrez l'URL http://10.0.0.3:8080/flamenco3-addon.zip et installez le module complémentaire Flamenco. Activez-le dans les préférences : Edit > Preferences > Add-ons. Cochez System: Flamenco 3, entrez l'URL du gestionnaire http://10.0.0.3:8080, et cliquez sur le bouton d'actualisation. Le système se connectera au nœud du gestionnaire et chargera automatiquement les paramètres de stockage :

Ouvrez le fichier à rendre. Dans l'onglet Scene, choisissez Cycles dans la liste déroulante Render Engine. N'oubliez pas d'enregistrer le fichier, car ces paramètres sont stockés directement dans le fichier *.blend :

Faites défiler la page vers le bas et trouvez la section Flamenco 3. Cliquez sur Fetch job types pour obtenir une liste des types disponibles. Sélectionnez Simple Blender Render dans la liste déroulante et définissez d'autres options, telles que le nombre d'images, la taille des blocs et le dossier de sortie. Enfin, cliquez sur Submit to Flamenco:

Le module complémentaire Flamenco crée une nouvelle tâche et télécharge un fichier blend vers le stockage partagé. Le système soumettra la tâche à un travailleur disponible et lancera le processus de rendu :

Si vous vérifiez la charge du GPU avec nvtop ou des utilitaires similaires, vous verrez que tous les GPU ont des tâches de calcul :

Vous trouverez le résultat dans un répertoire que vous avez sélectionné à l'étape précédente. Exemple ici (Ripple Dreams par James Redmond)

Voir aussi :

Photogrammétrie avec Meshroom

Tue, 21 Jan 2025 09:38:44 +0100

La photogrammétrie est une méthode qui consiste à transformer des objets physiques en modèles numériques tridimensionnels pouvant être édités à l'aide d'un logiciel 3D. Ce processus utilise généralement des appareils spécialisés appelés scanners 3D, qui se déclinent en deux types principaux : optique et laser.

Les scanners optiques utilisent souvent une ou plusieurs caméras numériques et un éclairage spécial pour illuminer uniformément l'objet pendant la numérisation. Cela permet de créer un modèle 3D. Les scanners laser, quant à eux, utilisent des faisceaux laser. Ces appareils émettent plusieurs faisceaux laser et mesurent le temps nécessaire à chaque faisceau pour rebondir sur l'objet. À l'aide de ces données et des informations fournies par les capteurs de position, le scanner calcule la distance entre chaque point de l'objet. Il en résulte un "nuage de points" qui constitue la base du modèle 3D.

Nuage de points

Pour construire le futur cadre d'un objet, le système doit connaître les coordonnées de chaque sommet dans l'espace tridimensionnel. L'ensemble des sommets est appelé nuage de points. Plus il y a de sommets, plus l'objet sera détaillé. La création d'un nuage de points est la première étape, et l'une des plus cruciales, de la recréation d'un modèle 3D à partir de photographies.

Il est important de noter que chaque sommet du nuage de points n'est initialement pas connecté à d'autres sommets. Cela permet un filtrage facile : conserver les points nécessaires et supprimer les autres, avant de commencer à recréer le maillage de l'objet.

Objets maillés

Un objet maillé est un type de modèle 3D constitué de primitives géométriques triangulaires, souvent appelées mailles ou polymés. Une fois que les points de l'objet sont formés, l'application peut composer indépendamment des primitives triangulaires à partir de ces points. En connectant ces primitives, il est possible de créer un modèle 3D de presque n'importe quelle forme. À ce stade, le modèle n'a pas de couleur et reste non peint.

L'étape suivante de texturation permet de résoudre ce problème.

La texturation

L'étape finale consiste à étirer la texture de l'image extraite des photos sur l'objet maillé préparé. La qualité des photos prises et leur résolution jouent ici un rôle essentiel. Si elle est faible, le résultat final ne sera pas du meilleur effet. En revanche, si un nombre suffisant de photos de bonne qualité ont été prises, vous obtiendrez un modèle 3D d'un objet réel entièrement prêt à l'emploi. Vous trouverez ci-dessous quelques conseils utiles sur la préparation des photos originales.

Réglages de l'appareil photo

Pour éviter toute déception lors de vos premières tentatives de création d'un modèle 3D à partir de photos, tenez compte de ces règles de base simples. Chacune de ces règles vous aidera à éviter les problèmes qui surviennent généralement au cours de la phase de création de l'objet maillé.

Tout d'abord, ne vous fiez pas aux réglages automatiques de votre appareil photo numérique. Les appareils photo modernes tentent d'équilibrer quatre paramètres clés de manière indépendante :

ISO,
la balance des blancs,
la vitesse d'obturation,
l'ouverture.

En mode automatique, même de légères modifications des conditions extérieures peuvent faire varier ces paramètres d'une image à l'autre. Ces variations peuvent entraîner des incohérences notables lors de l'étape de texturation.

Pour conserver des paramètres cohérents d'une image à l'autre, utilisez le mode Manual (M). L'ouverture est un paramètre crucial. En fonction de votre objectif, essayez d'obtenir une position où elle est presque fermée. Cela permet d'obtenir une profondeur de champ maximale : moins l'ouverture est grande, mieux c'est. Évitez toutefois les valeurs extrêmes. Si votre objectif peut être proche de f/22, vous obtiendrez de bons résultats en utilisant des valeurs comprises entre f/11 et f/20.

^{A gauche f/11, à droite f/22}

La fermeture du diaphragme crée toutefois un autre problème : le manque de lumière. Ce problème peut être résolu de deux manières : en augmentant la sensibilité ISO ou en allongeant la vitesse d'obturation. Les deux méthodes affectent le résultat final, mais de manière différente. L'augmentation de la sensibilité ISO à 6400 introduit du bruit numérique dans l'image, il est donc préférable d'utiliser les valeurs les plus basses possibles. Pour obtenir des résultats proches de l'idéal, il est logique de régler la sensibilité ISO sur 100. Cependant, cela signifie que le problème de l'éclairage insuffisant persiste :

^{A gauche ISO 100, à droite ISO 6400}

Le moyen le plus efficace d'augmenter la quantité de lumière passant par le capteur de l'appareil photo dans des conditions de faible éclairage est d'allonger la vitesse d'obturation. Plus l'obturateur reste ouvert longtemps, plus le nombre de photons atteignant le capteur est élevé, ce qui se traduit par une meilleure qualité d'image. Cette approche présente toutefois un défi : sans trépied, une vitesse d'obturation de 1/50 seconde ou plus peut rendre l'image floue. L'utilisation d'un trépied élimine ce problème.

La balance des blancs est le dernier paramètre crucial. Il est important de désactiver le réglage automatique et de choisir soit un profil prédéfini (tel que "Journée ensoleillée"), soit une valeur personnalisée en Kelvin. Par exemple, 5200K est un réglage courant. Les valeurs inférieures font pencher la teinte vers le jaune, tandis que les valeurs supérieures font pencher la teinte vers le bleu. Pour éviter des corrections de couleur fastidieuses lors du post-traitement, utilisez le même profil de balance des blancs pour toutes les photos d'une série.

^{Profils de balance des blancs. À gauche "Journée ensoleillée", à droite "Auto"}

En résumé, pour prendre des photos de haute qualité pour la photogrammétrie :

Utilisez un trépied lorsque la lumière est insuffisante.
Fermez le diaphragme presque au minimum.
Réglez la sensibilité ISO à sa valeur minimale.
Choisissez une vitesse d'obturation qui vous donne le résultat souhaité (ou utilisez l'indicateur d'exposition intégré à votre appareil photo).
Utilisez le même préréglage de balance des blancs.

Prendre des photos

Voyons maintenant combien de photos prendre et sous quels angles. Le type d'objet et son arrière-plan influencent considérablement le résultat final. Les objets sans surface brillante, transparente ou réfléchissante sont idéaux pour la photogrammétrie. Dans la pratique, les objets tels que les fenêtres et le verre doivent souvent être corrigés ultérieurement dans un éditeur 3D. Cependant, la technique générale de prise de vue reste la même.

Pour les petits objets placés sur une surface, imaginez une sphère autour de l'objet. Prenez des photos comme si votre appareil photo faisait trois fois le tour de l'objet : une fois par le bas, une fois par le milieu et une fois par le haut.

Il est essentiel que l'objet occupe au moins la moitié, et de préférence les trois quarts, de chaque image. Au lieu d'utiliser le zoom, essayez de vous rapprocher physiquement de l'objet. Lors de la création d'un point de nuage, le logiciel a besoin d'autant de pixels que possible.

Lors de la prise de vue, n'oubliez pas que le logiciel combine les images en un seul objet pour obtenir une géométrie correcte. Prenez au moins trois images de chaque angle. Une fois l'objet centré dans le cadre, divisez-le mentalement en trois parties égales. Prenez trois photos, chacune se concentrant sur un tiers de l'objet. Cela permet à l'application de calculer avec précision l'emplacement de chaque point dans l'espace 3D. Après avoir photographié l'objet sous tous les angles et côtés possibles, vous pouvez commencer à préparer le logiciel.

Installer Meshroom

Meshroom est une application gratuite et multiplateforme qui exécute de manière séquentielle toutes les étapes du traitement, en utilisant les ressources du processeur et du processeur graphique. Bien qu'il puisse fonctionner sur un ordinateur domestique standard, chaque étape peut prendre du temps. Pour les projets à grande échelle impliquant la reconstruction 3D de nombreux objets, comme la création d'une scène 3D impressionnante, la location d'un serveur GPU dédié peut être une solution pratique.

Considérons un serveur LeaderGPU avec la configuration suivante : 2 x NVIDIA® RTX™ 3090, 2 x Intel® Xeon® Silver 4210 (3.20 GHz), 128GB RAM. Nous utiliserons Windows Server 2022 comme système d'exploitation. Avant d'installer Meshroom, vous devez effectuer quelques opérations préliminaires :

Visitez le site officiel du projet pour télécharger Meshroom. Décompressez l'archive résultante pour trouver une application prête à l'emploi qui ne nécessite pas d'installation supplémentaire. Lancez Meshroom.exe pour commencer.

Télécharger les images

La fenêtre principale de l'application est divisée en deux parties : la partie supérieure et la partie inférieure. La partie supérieure contient la galerie d'images, la visionneuse d'images et la visionneuse 3D. La partie inférieure contient l'éditeur graphique et le gestionnaire de tâches. Pour commencer, faites glisser et déposez vos photos capturées dans la zone désignée. Les formats de fichiers compressés (par exemple, JPG) et RAW sont tous deux pris en charge. Il est recommandé d'utiliser les fichiers RAW car ils contiennent beaucoup plus de données pour chaque image.

Veuillez noter que vous disposez déjà par défaut d'un pipeline standard prêt à l'emploi, qui est affiché de manière schématique dans l'éditeur de graphiques. Il s'agit de l'une des commandes les plus importantes, qui permet de configurer tous les aspects du traitement de l'image à chaque étape. Vous pouvez exécuter manuellement chaque étape en cliquant avec le bouton droit de la souris et en sélectionnant Compute dans le menu déroulant.

Mais pour la première fois, vous pouvez simplement cliquer sur le bouton vert Start, et l'application fera tout pour vous. Elle vous invitera à sauvegarder le projet, afin de ne pas perdre accidentellement les résultats du calcul. Cliquez sur Save, indiquez un nom et un répertoire et enregistrez le projet :

Ensuite, l'application transfère toutes les étapes de traitement de l'éditeur graphique au gestionnaire des tâches, qui gère leur exécution dans un ordre spécifique. Pour vérifier l'état de chaque étape, sélectionnez le bloc correspondant dans l'éditeur de graphique et cliquez sur le bouton Log dans le coin inférieur droit de l'écran. Vous pouvez également voir en temps réel quelle étape est en cours de traitement :

Sur le côté droit, vous pouvez voir le nuage de points que vous avez construit. Le résultat final, généré à l'aide du pipeline standard, est disponible dans le répertoire :

[Your_Project_Path]\MeshroomCache\Texturing\[Random_Symbols]\texturedMesh.obj

Bien entendu, si vous fixez au préalable le chemin de sortie dans le nœud final du pipeline, l'objet se retrouvera sur le chemin que vous avez spécifié. Vous pouvez ensuite l'importer dans n'importe quel éditeur de texte pour corriger les surfaces, ajouter des sources de lumière et d'autres effets avant le rendu.

Intégration

Si le résultat initial est impressionnant, il doit souvent être affiné dans un éditeur 3D. Meshroom simplifie ce processus en vous permettant d'importer non seulement le modèle, mais aussi le nuage de points et les positions de la caméra dans des éditeurs tiers tels que Houdini ou Blender. Dans la section suivante, nous allons voir comment procéder.

Houdini

En fait, Meshroom est une interface conviviale pour le moteur AliceVision, qui gère toutes les opérations liées au calcul. Cette interface implémente le pipeline et le gestionnaire de tâches correspondants. Si vous utilisez Houdini, vous pouvez créer votre propre pipeline directement dans l'application et l'utiliser avec d'autres outils, sans avoir à lancer Meshroom séparément.

Pour commencer, il est préférable de télécharger et d'installer un lanceur dédié qui gérera les mises à jour et les plugins de Houdini. Ensuite, ajoutez le plugin SideFX Labs, qui offre de nombreux outils supplémentaires, dont des nœuds spécifiques pour AliceVision. Pour ce faire, cliquez sur le bouton +, puis sélectionnez Shelves:

Faites défiler la liste et sélectionnez SideFX Labs, puis cliquez sur le bouton Update Toolset:

Pour installer un plugin, procédez comme suit : Cliquez sur le bouton Start Launcher, accédez à la section Labs/Packages dans le menu de gauche et sélectionnez Install packages. Une fenêtre s'ouvrira dans laquelle vous pourrez choisir les paquets à installer :

Choisissez le paquet Production Build correspondant à votre version de Houdini et cliquez sur Install. Redémarrez ensuite l'application pour vous assurer que les nouvelles icônes d'effets apparaissent en haut :

Il est essentiel de noter que vous ne trouverez aucune mention d'AliceVision ou de Meshlab ici. Cela s'explique par le fait que le plugin correspondant ne fonctionne que dans le pipeline de contexte géométrique. Pour le vérifier, cliquez sur l'icône +, puis sélectionnez New Pane Tab Type et Network View:

Appuyez sur la touche Tab et ajoutez un nœud Geometry:

Double-cliquez pour ouvrir le nœud créé et tapez av sur votre clavier. Le système affiche instantanément une liste de nœuds disponibles commençant par les symboles Labs AV. Ces nœuds vous permettent de contrôler le moteur AliceVision et de l'intégrer dans vos propres pipelines :

Pour créer un pipeline approprié, reportez-vous à la documentation officielle du plugin. De plus, pensez à ajouter le répertoire AliceVision à la liste des variables d'environnement dans le fichier houdini.env. Pour une installation standard utilisant le launcher, ce fichier est typiquement situé dans le répertoire C:\Users\Administrator\Documents\houdini20.5\

Ouvrez le fichier houdini.env avec n'importe quel éditeur de texte et ajoutez la ligne suivante :

ALICEVISION_PATH = [path to alicevision directory in Meshroom folder]

Par exemple, si vous avez installé Meshroom dans le répertoire racine du disque D :, votre chemin pourrait ressembler à ceci :

ALICEVISION_PATH = D:\Meshroom\aliceVision

Enregistrez le fichier, puis redémarrez l'application Houdini.

Blender

Pour les utilisateurs de Blender, nous recommandons le plugin Meshroom2Blender. Bien qu'il fonctionne différemment du plugin Houdini, il vous permet d'exporter les nuages de points et les positions de caméra calculés par Meshroom vers Blender. Pour accéder au code du plugin, ouvrez le lien dans votre navigateur :

https://raw.githubusercontent.com/tibicen/meshroom2blender/master/view3d_point_cloud_visualizer.py

Enregistrez le code sous view3d_point_cloud_visualizer.py dans un répertoire approprié. Ensuite, ouvrez Blender et naviguez jusqu'à Edit - Preferences. De là, sélectionnez l'onglet Add-ons:

Cliquez sur la flèche vers le bas et sélectionnez Install from Disk:

Dans la nouvelle fenêtre ouverte, naviguez jusqu'au répertoire où vous avez sauvegardé le plugin. Sélectionnez le fichier du plugin et cliquez sur le bouton Install from Disk button:

Le plugin est maintenant installé. Il est recommandé de redémarrer l'application. Après le redémarrage, vous verrez l'élément Point Cloud Visualizer en mode visualisation. Le plugin vous demande de spécifier le chemin d'accès à un fichier avec l'extension .ply:

Par défaut, Meshroom ne génère pas ce type de fichier. Pour le créer, ouvrez le pipeline et ajoutez le noeud ConvertSfMFormat. Utilisez en entrée le SfMData du nœud StructureFromMotion. En sortie, spécifiez le Images Folder du nœud Texturing.

La dernière étape consiste à spécifier le format. Cliquez sur SfM File Format dans le nœud ConvertSfMFormat et sélectionnez ply dans la liste déroulante :

Cliquez avec le bouton droit de la souris sur le nœud créé et sélectionnez Compute:

Une fois le processus terminé, vous trouverez le fichier requis dans le répertoire :

[Your_Project_Path]\MeshroomCache\ConvertSfMFormat\[Random_Symbols]\sfm.ply

Vous pouvez le charger dans Blender de deux manières : via le plugin susmentionné ou via le processus d'importation standard File - Import - Stanford PLY (.ply):

Pour plus d'informations sur l'utilisation de ce plugin, nous vous suggérons de consulter le dépôt du projet ou une ressource web spécialisée.

Conclusion

La photogrammétrie est un vaste domaine de connaissances, dans lequel nous avons essayé de présenter seulement quelques techniques de base pour convertir des images 2D en un modèle 3D. Cette technique est utilisée dans de nombreuses industries, de l'architecture à la création de jeux vidéo.

Après avoir acquis une première expérience de la prise de vue d'un ensemble de données et de sa transformation cohérente en un modèle 3D, vous serez en mesure d'améliorer vos compétences et de transférer des objets physiques dans un espace 3D virtuel. Enfin, LeaderGPU vous aidera en termes de puissance de calcul, en réduisant le temps de calcul et en libérant votre poste de travail pour d'autres tâches, souvent plus prioritaires.

Voir aussi:

Open WebUI : Tout en un

Mon, 20 Jan 2025 15:21:46 +0100

Open WebUI a été développé à l'origine pour Ollama, dont nous avons parlé dans l'un de nos articles. Auparavant, il s'appelait Ollama WebUI, mais au fil du temps, l'accent a été mis sur l'universalité de l'application, et le nom a été changé en Open WebUI. Ce logiciel résout le problème clé du travail pratique avec de grands modèles de réseaux neuronaux placés localement ou sur des serveurs contrôlés par l'utilisateur.

Installation du logiciel

La méthode d'installation principale et préférée consiste à déployer un conteneur Docker. Cela vous permet de ne pas penser à la présence de dépendances ou d'autres composants qui garantissent le bon fonctionnement du logiciel. Cependant, vous pouvez installer Open WebUI en clonant le dépôt du projet depuis GitHub et en le construisant à partir du code source. Dans cet article, nous examinerons les deux options.

Avant de commencer, assurez-vous que les pilotes GPU sont installés sur le serveur. Notre instruction Installer les pilotes NVIDIA® sous Linux vous aidera à le faire.

Utilisation de Docker

Si vous venez de commander un serveur, vous ne disposerez pas du moteur Docker ni de l'ensemble des outils nécessaires pour transférer les GPU dans le conteneur. Nous ne recommandons pas d'installer Docker à partir du dépôt standard d'Ubuntu, car il peut être obsolète et ne pas prendre en charge toutes les options modernes. Il est préférable d'utiliser le script d'installation publié sur le site officiel :

curl -sSL https://get.docker.com/ | sh

En plus de Docker, vous devez installer le NVIDIA® Container Toolkit, donc activer le dépôt NVIDIA® :

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Mettez à jour votre cache de paquets et installez NVIDIA® Container Toolkit :

sudo apt update && sudo apt -y install nvidia-container-toolkit

Pour que la chaîne d'outils fonctionne, vous devez redémarrer le démon Docker :

sudo systemctl restart docker

Vous pouvez maintenant exécuter le conteneur souhaité. Notez que la commande suivante n'isole pas les conteneurs du réseau de l'hôte car plus tard, vous pourrez activer des options supplémentaires, telles que la génération d'images à l'aide de l'interface Web de Stable Diffusion. Cette commande téléchargera et exécutera automatiquement toutes les couches de l'image :

sudo docker run -d --network=host --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Utilisation de Git

Ubuntu 22.04

Tout d'abord, vous devez cloner le contenu du dépôt :

git clone https://github.com/open-webui/open-webui.git

Ouvrez le répertoire téléchargé :

cd open-webui/

Copiez l'exemple de configuration (vous pouvez le modifier si nécessaire), qui définira les variables d'environnement pour la construction :

cp -RPp .env.example .env

Installer le programme d'installation NVM, qui vous aidera à installer la version requise de Node.js sur le serveur :

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Ensuite, vous devez fermer et rouvrir la session SSH pour que la commande suivante fonctionne correctement.

Installer le gestionnaire de paquets Node :

sudo apt -y install npm

Installez la version 22 de Node.js (version actuelle au moment de la rédaction de cet article) :

npm install 22

Installer les dépendances nécessaires à la poursuite de l'assemblage :

npm install

Commençons la construction. Veuillez noter qu'il faut plus de 4 Go de RAM libre :

npm run build

Le frontend est prêt ; il est maintenant temps de préparer le backend. Allez dans le répertoire portant le même nom :

cd ./backend

Installez les paquets pip et ffmpeg :

sudo apt -y install python3-pip ffmpeg

Avant l'installation, vous devez ajouter un nouveau chemin à la variable d'environnement :

sudo nano ~/.bashrc

Ajoutez la ligne suivante à la fin du fichier :

export PATH="/home/usergpu/.local/bin:$PATH"

Mettons-le à jour avec la dernière version :

python3 -m pip install --upgrade pip

Vous pouvez maintenant installer les dépendances :

pip install -r requirements.txt -U

Installer Ollama :

curl -fsSL https://ollama.com/install.sh | sh

Tout est prêt pour lancer l'application :

bash start.sh

Ubuntu 24.04 / 24.10

Lors de l'installation d'OpenWebUI sur Ubuntu 24.04/24.10, vous serez confronté à un défi majeur : le système d'exploitation utilise Python 3.12 par défaut, alors qu'OpenWebUI ne supporte que la version 3.11. Vous ne pouvez pas simplement rétrograder Python, car cela casserait le système d'exploitation. Comme le paquetage python3.11 n'est pas disponible dans les dépôts standard, vous devrez créer un environnement virtuel pour utiliser la bonne version de Python.

La meilleure solution consiste à utiliser le système de gestion de paquets Conda. Conda fonctionne comme pip mais ajoute un support d'environnement virtuel similaire à venv. Comme vous n'avez besoin que de fonctionnalités de base, vous utiliserez Miniconda, une distribution légère. Téléchargez la dernière version sur GitHub :

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"

Exécutez le script :

bash Miniforge3-$(uname)-$(uname -m).sh

Créons un environnement virtuel nommé pyenv et spécifions la version 3.11 de Python :

conda create -n pyenv python=3.11

Activez l'environnement créé :

conda activate pyenv

Vous pouvez maintenant procéder à l'installation standard d'OpenWebUI pour Ubuntu 22.04. L'environnement virtuel garantit que tous les scripts d'installation se dérouleront sans problème et sans conflit de version de paquetage.

Modèles

Bibliothèque Ollama

Open WebUI vous permet de télécharger des modèles directement à partir de l'interface web, en spécifiant uniquement le nom au format model:size. Pour ce faire, naviguez jusqu'à http://192.168.88.20:8080/admin/settings et cliquez sur Connections. Cliquez ensuite sur l'icône de clé à molette en face de la chaîne http://localhost:11434. Après avoir consulté les noms des modèles de la bibliothèque, saisissez son nom et cliquez sur l'icône de téléchargement :

Le système téléchargera ensuite automatiquement le modèle requis, qui sera immédiatement disponible. En fonction de la taille sélectionnée, le téléchargement peut prendre plus ou moins de temps. Avant de procéder au téléchargement, assurez-vous qu'il y a suffisamment d'espace sur le disque dur. Pour plus d'informations, voir l'article Partitionnement du disque sous Linux.

Modèles personnalisés

Si vous devez intégrer un modèle de réseau neuronal qui ne se trouve pas dans la bibliothèque Ollama, vous pouvez utiliser la fonction expérimentale et charger n'importe quel modèle arbitraire au format GGUF. Pour ce faire, allez sur Settings - Admin Settings - Connections et cliquez sur l'icône de clé à molette en face de http://localhost:11434. Cliquez sur Show dans la section Experimental. Par défaut, le mode fichier est activé, ce qui vous permet de charger un fichier à partir de votre ordinateur local. Si vous cliquez sur File Mode, vous passez à URL Mode, qui vous permet de spécifier l'URL du fichier modèle, et le serveur le téléchargera automatiquement :

RAG

Outre une interface web pratique et fonctionnelle, Open WebUI permet d'étendre les capacités des différents modèles et d'assurer leur utilisation conjointe. Par exemple, il est facile de télécharger des documents pour former une base de données vectorielle RAG (Retrieval-augmented generation). Au cours du processus de génération d'une réponse à l'utilisateur, LLM pourra s'appuyer non seulement sur les données obtenues directement à la suite de la formation, mais aussi sur les données placées dans une base de données vectorielles similaire.

Les documents

Par défaut, Open WebUI recherche dans le répertoire /data/docs les fichiers qui peuvent être placés dans l'espace vectoriel de la base de données et effectue la transformation en utilisant le modèle intégré all-MiniLM-L6-v2. Ce n'est pas le seul modèle adapté à cette tâche, il est donc judicieux d'essayer d'autres options, par exemple dans cette liste.

Les documents texte, dépourvus de balises et d'autres caractères spéciaux, sont les mieux adaptés à RAG. Bien sûr, vous pouvez télécharger des documents tels quels, mais cela peut affecter considérablement la précision des réponses générées. Par exemple, si vous disposez d'une base de connaissances au format Markdown, vous pouvez d'abord la débarrasser de son formatage, puis la télécharger dans /data/docs.

Recherche sur le web

Outre les documents locaux, il est possible de demander au modèle de réseau neuronal d'utiliser n'importe quel site web comme source de données. Cela lui permettra de répondre à des questions en utilisant non seulement les données sur lesquelles il a été formé, mais aussi des données hébergées sur des sites web spécifiés par l'utilisateur.

En fait, il s'agit d'un type de RAG, qui reçoit des pages HTML en entrée et les transforme ensuite d'une manière spéciale, en les plaçant dans une base de données vectorielle. La recherche dans une telle base de données sera très rapide ; par conséquent, le modèle de réseau neuronal sera en mesure de générer rapidement une réponse sur la base de ses résultats. Open WebUI prend en charge différents moteurs de recherche, mais ne peut en utiliser qu'un seul à la fois, ce qui est spécifié dans les paramètres.

Pour inclure les résultats de la recherche Web dans les réponses du réseau neuronal, cliquez sur + (symbole plus) et faites glisser le commutateur Recherche Web :

Génération d'images

Le point fort d'Open WebUI est que ce logiciel permet de combiner plusieurs réseaux neuronaux aux tâches différentes pour résoudre un seul problème. Par exemple, Llama 3.1 mène parfaitement un dialogue avec l'utilisateur en plusieurs langues, mais ses réponses seront exclusivement textuelles. Il ne peut pas générer d'images, il n'y a donc aucun moyen d'illustrer ses réponses.

Stable Diffusion, dont nous avons souvent parlé, est à l'opposé : ce réseau neuronal génère parfaitement des images, mais ne peut pas du tout travailler avec des textes. Les développeurs d'Open WebUI ont essayé de combiner les points forts des deux réseaux neuronaux dans un seul dialogue et ont mis en œuvre le schéma de travail suivant.

Lorsque vous menez un dialogue dans Open WebUI, un bouton spécial apparaît à côté de chaque réponse du réseau neuronal. En cliquant dessus, vous obtiendrez une illustration de cette réponse directement dans le dialogue :

Pour ce faire, il faut appeler l'API WebUI de Stable Diffusion et, pour l'instant, une connexion avec les versions d'Automatic1111 et une connexion à ComfyUI sont disponibles. Vous pouvez également générer des images via le réseau neuronal Dall-E, mais il ne peut pas être déployé localement - il s'agit d'un service payant de génération d'images dont le code source est fermé.

Cette fonctionnalité ne fonctionnera que si, en plus d'Open WebUI avec Ollama, Stable Diffusion WebUI est installé sur le serveur. Vous pouvez trouver les instructions d'installation ici. La seule chose qui mérite d'être mentionnée est que lors de l'exécution du script ./webui.sh, vous devrez spécifier une clé supplémentaire pour activer l'API :

./webui.sh --listen --api --gradio-auth user:password

Un autre problème peut survenir en raison d'un manque de mémoire vidéo. Si vous rencontrez ce problème, vous pouvez utiliser deux clés utiles : --medvram et --lowvram. Vous éviterez ainsi l'erreur "Out-of-memory" au démarrage de la génération.

Voir aussi:

Comment fonctionne Ollama ?

Mon, 20 Jan 2025 15:16:02 +0100

Ollama est un outil permettant d'exécuter localement de grands modèles de réseaux neuronaux. L'utilisation des services publics est souvent perçue par les entreprises comme un risque potentiel de fuite de données confidentielles et sensibles. Par conséquent, le déploiement de LLM sur un serveur contrôlé vous permet de gérer de manière indépendante les données qui y sont placées tout en utilisant les forces de LLM.

Cela permet également d'éviter la situation désagréable du verrouillage du fournisseur, où tout service public peut unilatéralement cesser de fournir des services. Bien entendu, l'objectif initial est de permettre l'utilisation de réseaux neuronaux génératifs dans des lieux où l'accès à l'internet est absent ou difficile (par exemple, dans un avion).

L'idée était de simplifier le lancement, le contrôle et le réglage fin des LLM. Au lieu d'instructions complexes en plusieurs étapes, Ollama vous permet d'exécuter une simple commande et de recevoir le résultat final après un certain temps. Il sera présenté simultanément sous la forme d'un modèle de réseau neuronal local, avec lequel vous pouvez communiquer à l'aide d'une interface web et d'une API pour une intégration facile dans d'autres applications.

Pour de nombreux développeurs, cet outil est devenu très utile, car dans la plupart des cas, il était possible d'intégrer Ollama à l'IDE utilisé et de recevoir des recommandations ou du code prêt à l'emploi écrit directement pendant que l'on travaillait sur l'application.

À l'origine, Ollama était destiné uniquement aux ordinateurs équipés du système d'exploitation macOS, mais il a ensuite été porté sur Linux et Windows. Une version spéciale a également été publiée pour travailler dans des environnements conteneurisés tels que Docker. Actuellement, il fonctionne aussi bien sur les ordinateurs de bureau que sur les serveurs dédiés dotés d'un GPU. Ollama permet de passer d'un modèle à l'autre dès la sortie de la boîte et de maximiser toutes les ressources disponibles. Bien entendu, ces modèles ne sont pas aussi performants sur un ordinateur de bureau classique, mais ils fonctionnent de manière tout à fait adéquate.

Comment installer Ollama

Ollama peut être installé de deux manières : sans utiliser la conteneurisation, en utilisant un script d'installation, et en tant que conteneur Docker prêt à l'emploi. La première méthode facilite la gestion des composants du système et des modèles installés, mais est moins tolérante aux pannes. La seconde méthode est plus tolérante aux pannes, mais son utilisation nécessite de prendre en compte tous les aspects inhérents aux conteneurs : une gestion un peu plus complexe et une approche différente du stockage des données.

Quelle que soit la méthode choisie, plusieurs étapes supplémentaires sont nécessaires pour préparer le système d'exploitation.

Les prérequis

Mettre à jour le dépôt de cache des paquets et les paquets installés :

sudo apt update && sudo apt -y upgrade

Installer tous les pilotes GPU nécessaires à l'aide de la fonction d'installation automatique :

sudo ubuntu-drivers autoinstall

Redémarrer le serveur :

sudo shutdown -r now

Installation par script

Le script suivant détecte l'architecture du système d'exploitation actuel et installe la version appropriée d'Ollama :

curl -fsSL https://ollama.com/install.sh | sh

Pendant l'opération, le script créera un utilisateur ollama distinct, sous lequel le démon correspondant sera lancé. Incidemment, le même script fonctionne bien dans WSL2, permettant l'installation de la version Linux d'Ollama sur Windows Server.

Installation via Docker

Il existe plusieurs méthodes pour installer Docker Engine sur un serveur. La plus simple consiste à utiliser un script spécifique qui installe la version actuelle de Docker. Cette approche est efficace pour Ubuntu Linux, de la version 20.04 (LTS) à la dernière version, Ubuntu 24.04 (LTS) :

curl -sSL https://get.docker.com/ | sh

Pour que les conteneurs Docker interagissent correctement avec le GPU, une boîte à outils supplémentaire doit être installée. Comme il n'est pas disponible dans les dépôts de base d'Ubuntu, vous devez d'abord ajouter un dépôt tiers à l'aide de la commande suivante :

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Mettre à jour le dépôt de cache de paquets :

sudo apt update

Et installez le paquet nvidia-container-toolkit:

sudo apt install nvidia-container-toolkit

N'oubliez pas de redémarrer le daemon docker via systemctl :

sudo systemctl restart docker

Il est temps de télécharger et d'exécuter Ollama avec l'interface web Open-WebUI :

sudo docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Ouvrez le navigateur web et naviguez vers http://[server-ip]:3000:

Télécharger et exécuter les modèles

En ligne de commande

Il suffit d'exécuter la commande suivante :

ollama run llama3

Via l'interface WebUI

Ouvrez Settings > Models, tapez le nom du modèle nécessaire, par exemple, llama3 et cliquez sur le bouton avec le symbole de téléchargement :

Le modèle sera téléchargé et installé automatiquement. Une fois le téléchargement terminé, fermez la fenêtre de configuration et sélectionnez le modèle téléchargé. Vous pourrez alors entamer un dialogue avec lui :

Intégration du VSCode

Si vous avez installé Ollama en utilisant le script d'installation, vous pouvez lancer n'importe quel modèle supporté presque instantanément. Dans l'exemple suivant, nous lancerons le modèle par défaut attendu par l'extension Ollama Autocoder (openhermes2.5-mistral:7b-q4_K_M) :

ollama run openhermes2.5-mistral:7b-q4_K_M

Par défaut, Ollama permet de travailler à travers une API, autorisant uniquement les connexions à partir de l'hôte local. Par conséquent, avant d'installer et d'utiliser l'extension pour Visual Studio Code, une redirection de port est nécessaire. Plus précisément, vous devez rediriger le port distant 11434 vers votre ordinateur local. Vous trouverez un exemple de cette procédure dans notre article sur Easy Diffusion WebUI.

Tapez Ollama Autocoder dans un champ de recherche, puis cliquez sur Install:

Après l'installation de l'extension, un nouvel élément intitulé Autocomplete with Ollama sera disponible dans la palette de commandes. Commencez à coder et lancez cette commande.

L'extension se connectera au serveur LeaderGPU en utilisant la redirection de port et dans quelques secondes, le code généré s'affichera sur votre écran :

Vous pouvez assigner cette commande à un raccourci clavier. Vous pouvez assigner cette commande à un raccourci clavier. Utilisez-la chaque fois que vous souhaitez compléter votre code avec un fragment généré. Ce n'est qu'un exemple des extensions VSCode disponibles. Le principe du transfert de port d'un serveur distant vers un ordinateur local vous permet de mettre en place un seul serveur avec un LLM en cours d'exécution pour toute une équipe de développeurs. Cette garantie empêche les entreprises tierces ou les pirates d'utiliser le code envoyé.

Voir aussi:

PrivateGPT : L'IA pour les documents

Mon, 20 Jan 2025 12:01:00 +0100

Les grands modèles linguistiques ont beaucoup évolué ces dernières années et sont devenus des outils efficaces pour de nombreuses tâches. Le seul problème lié à leur utilisation est que la plupart des produits basés sur ces modèles utilisent des services prêts à l'emploi d'entreprises tierces. Cette utilisation peut entraîner la fuite de données sensibles, c'est pourquoi de nombreuses entreprises évitent de télécharger des documents internes dans des services LLM publics.

Un projet comme PrivateGPT pourrait être une solution. Il est initialement conçu pour un usage entièrement local. Sa force réside dans le fait que vous pouvez soumettre divers documents en entrée, et le réseau neuronal les lira pour vous et fournira ses propres commentaires en réponse à vos demandes. Par exemple, vous pouvez lui faire parvenir des textes volumineux et lui demander de tirer des conclusions sur la base de la demande de l'utilisateur. Cela vous permet d'économiser considérablement du temps sur la relecture.

C'est particulièrement vrai dans des domaines professionnels comme la médecine. Par exemple, un médecin peut poser un diagnostic et demander au réseau neuronal de le confirmer sur la base de l'ensemble des documents téléchargés. Cela permet d'obtenir un avis indépendant supplémentaire et de réduire ainsi le nombre d'erreurs médicales. Comme les demandes et les documents ne quittent pas le serveur, on peut être sûr que les données reçues n'apparaîtront pas dans le domaine public.

Aujourd'hui, nous allons vous montrer comment déployer un réseau neuronal sur des serveurs dédiés LeaderGPU avec le système d'exploitation Ubuntu 22.04 LTS en seulement 20 minutes.

Préparation du système

Commencez par mettre à jour vos paquets vers la dernière version :

sudo apt update && sudo apt -y upgrade

Installez maintenant des paquets supplémentaires, des bibliothèques et le pilote graphique NVIDIA®. Tous ces éléments seront nécessaires pour construire le logiciel et l'exécuter sur le GPU :

sudo apt -y install build-essential git gcc cmake make openssl libssl-dev libbz2-dev libreadline-dev libsqlite3-dev zlib1g-dev libncursesw5-dev libgdbm-dev libc6-dev zlib1g-dev libsqlite3-dev tk-dev libssl-dev openssl libffi-dev lzma liblzma-dev libbz2-dev

Installation de CUDA® 12.4

En plus du pilote, vous devez installer le kit d'outils NVIDIA® CUDA®. Ces instructions ont été testées sur CUDA® 12.4, mais tout devrait également fonctionner sur CUDA® 12.2. Cependant, gardez à l'esprit que vous devrez indiquer la version installée lorsque vous spécifierez le chemin d'accès aux fichiers exécutables.

Exécutez la commande suivante de manière séquentielle :

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo dpkg -i cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo cp /var/cuda-repo-ubuntu2204-12-4-local/cuda-*-keyring.gpg /usr/share/keyrings/

sudo apt-get update && sudo apt-get -y install cuda-toolkit-12-4

Vous trouverez plus d'informations sur l'installation de CUDA® dans notre base de connaissances. Redémarrez le serveur :

sudo shutdown -r now

PyEnv install

Il est temps d'installer un simple utilitaire de contrôle de version Python appelé PyEnv. Il s'agit d'une version améliorée du projet similaire pour Ruby (rbenv), configuré pour fonctionner avec Python. Il peut être installé avec un script d'une ligne :

curl https://pyenv.run | bash

Vous devez maintenant ajouter quelques variables à la fin du fichier script, qui est exécuté lors de la connexion. Les trois premières lignes sont responsables du bon fonctionnement de PyEnv, et la quatrième est nécessaire pour Poetry, qui sera installé plus tard :

nano .bashrc

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
export PATH="/home/usergpu/.local/bin:$PATH"

Appliquez les réglages que vous avez effectués :

source .bashrc

Installer la version 3.11 de Python :

pyenv install 3.11

Créer un environnement virtuel pour Python 3.11 :

pyenv local 3.11

Installation de Poetry

La prochaine pièce du puzzle est Poetry. Il s'agit d'un analogue de pip pour la gestion des dépendances dans les projets Python. L'auteur de Poetry était fatigué d'avoir constamment affaire à différentes méthodes de configuration, telles que setup.cfg, requirements.txt, MANIFEST.ini, et d'autres. C'est ce qui a motivé le développement d'un nouvel outil qui utilise un fichier pyproject.toml, qui stocke toutes les informations de base sur un projet, et pas seulement une liste de dépendances.

Installer la poésie :

curl -sSL https://install.python-poetry.org | python3 -

PrivateGPT install

Maintenant que tout est prêt, vous pouvez cloner le dépôt PrivateGPT :

git clone https://github.com/imartinez/privateGPT

Allez sur le dépôt téléchargé :

cd privateGPT

Exécuter l'installation des dépendances à l'aide de Poetry tout en activant les composants supplémentaires :

ui - ajoute une interface web de gestion basée sur Gradio à l'application dorsale ;
embedding-huggingface - permet d'intégrer des modèles téléchargés depuis HuggingFace;
llms-llama-cpp - ajoute la prise en charge de l'inférence directe des modèles au format GGUF ;
vector-stores-qdrant - ajoute la base de données vectorielle qdrant.

poetry install --extras "ui embeddings-huggingface llms-llama-cpp vector-stores-qdrant"

Définissez votre jeton d'accès à Hugging Face. Pour plus d'informations, veuillez lire cet article:

export HF_TOKEN="YOUR_HUGGING_FACE_ACCESS_TOKEN"

Maintenant, exécutez le script d'installation, qui téléchargera automatiquement le modèle et les poids (Meta Llama 3.1 8B Instruct par défaut) :

poetry run python scripts/setup

La commande suivante recompile llms-llama-cpp séparément pour activer la prise en charge de NVIDIA® CUDA®, afin de décharger les charges de travail sur le GPU :

CUDACXX=/usr/local/cuda-12/bin/nvcc CMAKE_ARGS="-DGGML_CUDA=on -DCMAKE_CUDA_ARCHITECTURES=native" FORCE_CMAKE=1 pip install llama-cpp-python --no-cache-dir --force-reinstall --upgrade

Si vous obtenez une erreur du type nvcc fatal : Unsupported gpu architecture 'compute_', indiquez simplement l'architecture exacte du GPU que vous utilisez. Par exemple : DCMAKE_CUDA_ARCHITECTURES=86 pour NVIDIA® RTX™ 3090.

La dernière étape avant de commencer est d'installer le support pour les appels asynchrones (async/await) :

pip install asyncio

PrivateGPT run

Exécute PrivateGPT à l'aide d'une seule commande :

make run

Ouvrez votre navigateur web et allez à la page http://[LeaderGPU_server_IP_address]:8001

Voir aussi:

Qwen 2 vs Llama 3

Mon, 20 Jan 2025 11:27:11 +0100

Les grands modèles de langage (LLM) ont eu un impact considérable sur notre vie. Malgré la compréhension de leur structure interne, ces modèles restent un point d'attention pour les scientifiques qui les comparent souvent à une "boîte noire". Le résultat final dépend non seulement de la conception du LLM, mais aussi de son entraînement et des données utilisées pour l'entraînement.

Alors que les scientifiques trouvent des opportunités de recherche, les utilisateurs finaux sont principalement intéressés par deux choses : la vitesse et la qualité. Ces critères jouent un rôle crucial dans le processus de sélection. Pour comparer avec précision deux LLM, de nombreux facteurs apparemment sans rapport doivent être normalisés.

L'équipement utilisé pour les interférences et l'environnement logiciel, y compris le système d'exploitation, les versions des pilotes et les progiciels, ont l'impact le plus important. Il est essentiel de sélectionner une version du LLM qui fonctionne sur différents équipements et de choisir une mesure de vitesse facilement compréhensible.

Nous avons choisi le nombre de jetons par seconde (jetons/s) comme mesure. Il est important de noter qu'un jeton ≠ un mot. Le LLM décompose les mots en éléments plus simples, typiques d'une langue spécifique, appelés "tokens".

La prévisibilité statistique du caractère suivant varie d'une langue à l'autre, de sorte que la tokenisation diffère. Par exemple, en anglais, environ 100 jetons sont dérivés de chaque 75 mots. Dans les langues utilisant l'alphabet cyrillique, le nombre de jetons par mot peut être plus élevé. Ainsi, 75 mots dans une langue cyrillique, comme le russe, peuvent correspondre à 120-150 tokens.

Vous pouvez vérifier cela en utilisant l'outil Tokenizer d'OpenAI. Il montre combien de tokens un fragment de texte est décomposé, ce qui fait du nombre de tokens par seconde un bon indicateur de la vitesse et des performances d'un LLM en matière de traitement du langage naturel.

Chaque test a été réalisé sur le système d'exploitation Ubuntu 22.04 LTS avec les pilotes NVIDIA® version 535.183.01 et la boîte à outils NVIDIA® CUDA® 12.5 installée. Des questions ont été formulées pour évaluer la qualité et la vitesse du LLM. La vitesse de traitement de chaque réponse a été enregistrée et contribuera à la valeur moyenne pour chaque configuration testée.

Nous avons commencé à tester différents GPU, des modèles les plus récents aux plus anciens. Une condition essentielle pour le test était de mesurer les performances d'un seul GPU, même si plusieurs étaient présents dans la configuration du serveur. En effet, les performances d'une configuration avec plusieurs GPU dépendent de facteurs supplémentaires tels que la présence d'une interconnexion à grande vitesse entre eux (NVLink).

Outre la vitesse, nous avons également tenté d'évaluer la qualité des réponses sur une échelle de 5 points, où 5 représente le meilleur résultat. Ces informations sont fournies ici à des fins de compréhension générale uniquement. À chaque fois, nous poserons les mêmes questions au réseau neuronal et tenterons de discerner avec quelle précision chacun d'entre eux comprend ce que l'utilisateur attend de lui.

Qwen 2

Récemment, une équipe de développeurs du groupe Alibaba a présenté la deuxième version de son réseau neuronal génératif Qwen. Il comprend 27 langues et est bien optimisé pour elles. Qwen 2 est disponible en différentes tailles afin de faciliter son déploiement sur n'importe quel appareil (des systèmes embarqués à ressources très limitées aux serveurs dédiés équipés de GPU) :

0.5B : adapté à l'IoT et aux systèmes embarqués ;
1.5B : une version étendue pour les systèmes embarqués, utilisée lorsque les capacités de 0.5B ne suffisent pas ;
7B : modèle de taille moyenne, bien adapté au traitement du langage naturel ;
57B : grand modèle haute performance adapté aux applications exigeantes ;
72B : le modèle ultime Qwen 2, conçu pour résoudre les problèmes les plus complexes et traiter de grands volumes de données.

Les versions 0.5B et 1.5B ont été entraînées sur des ensembles de données avec une longueur de contexte de 32K. Les versions 7B et 72B ont déjà été entraînées sur le contexte de 128K. Le modèle de compromis 57B a été entraîné sur des ensembles de données avec une longueur de contexte de 64K. Les créateurs positionnent Qwen 2 comme un analogue de Llama 3 capable de résoudre les mêmes problèmes, mais beaucoup plus rapidement.

Llama 3

La troisième version du réseau neuronal génératif de la famille MetaAI Llama a été introduite en avril 2024. Contrairement à Qwen 2, elle n'a été publiée qu'en deux versions : 8B et 70B. Ces modèles se positionnent comme un outil universel permettant de résoudre de nombreux problèmes dans des cas variés. Ils poursuivent la tendance au multilinguisme et à la multimodalité, tout en devenant plus rapides que les versions précédentes et en supportant une plus grande longueur de contexte.

Les créateurs de Llama 3 ont essayé d'affiner les modèles afin de réduire le pourcentage d'hallucinations statistiques et d'augmenter la variété des réponses. Llama 3 est donc tout à fait capable de donner des conseils pratiques, d'aider à rédiger une lettre d'affaires ou de spéculer sur un sujet spécifié par l'utilisateur. Les ensembles de données sur lesquels les modèles de Llama 3 ont été entraînés avaient une longueur de contexte de 128K et plus de 5% comprenaient des données en 30 langues. Toutefois, comme l'indique le communiqué de presse, les performances de génération en anglais seront nettement plus élevées que dans toute autre langue.

Comparaison

NVIDIA® RTX™ A6000

Commençons nos mesures de vitesse avec le GPU NVIDIA® RTX™ A6000, basé sur l'architecture Ampere (à ne pas confondre avec la NVIDIA® RTX™ A6000 Ada). Cette carte a des caractéristiques très modestes, mais en même temps, elle dispose de 48 Go de VRAM, ce qui lui permet de fonctionner avec des modèles de réseaux neuronaux assez importants. Malheureusement, la faible vitesse d'horloge et la bande passante sont les raisons de la faible vitesse d'inférence des LLM textuels.

Immédiatement après le lancement, le réseau neuronal Qwen 2 a commencé à surpasser Llama 3. En répondant aux mêmes questions, la différence de vitesse moyenne était de 24 % en faveur de Qwen 2. La vitesse de génération des réponses était de l'ordre de 11 à 16 tokens par seconde. C'est 2 à 3 fois plus rapide que d'essayer d'exécuter la génération même sur un CPU puissant, mais dans notre classement, c'est le résultat le plus modeste.

NVIDIA® RTX™ 3090

Le prochain GPU est également construit sur l'architecture Ampere, a 2 fois moins de mémoire vidéo, mais en même temps, il fonctionne à une fréquence plus élevée (19500 MHz contre 16000 Mhz). La bande passante de la mémoire vidéo est également plus élevée (936,2 Go/s contre 768 Go/s). Ces deux facteurs augmentent considérablement les performances de la RTX™ 3090, même si l'on tient compte du fait qu'elle possède 256 cœurs CUDA® de moins.

Ici, vous pouvez clairement voir que Qwen 2 est beaucoup plus rapide (jusqu'à 23%) que Llama 3 en effectuant les mêmes tâches. En ce qui concerne la qualité de la génération, le support multilingue de Qwen 3 est vraiment digne d'éloges, et le modèle répond toujours dans la même langue que celle dans laquelle la question a été posée. Avec Llama 3, à cet égard, il arrive souvent que le modèle comprenne la question elle-même, mais préfère formuler des réponses en anglais.

NVIDIA® RTX™ 4090

Voyons maintenant le plus intéressant : voyons comment la NVIDIA® RTX™ 4090, construite sur l'architecture Ada Lovelace, du nom de la mathématicienne anglaise Augusta Ada King, comtesse de Lovelace, s'acquitte de la même tâche. Elle est devenue célèbre pour avoir été la première programmeuse de l'histoire de l'humanité, et à l'époque où elle a écrit son premier programme, il n'existait pas d'ordinateur assemblé capable de l'exécuter. Cependant, il a été reconnu que l'algorithme décrit par Ada pour calculer les nombres de Bernoulli était le premier programme au monde écrit pour être joué sur un ordinateur.

Le graphique montre clairement que la RTX™ 4090 a fait face à l'inférence des deux modèles presque deux fois plus vite. Il est intéressant de noter que dans l'une des itérations, le Llama 3 a réussi à surpasser le Qwen 2 de 1,2%. Toutefois, si l'on tient compte des autres itérations, le Qwen 2 a conservé sa position de leader, restant 7 % plus rapide que le Llama 3. Dans toutes les itérations, la qualité des réponses des deux réseaux neuronaux était élevée, avec un nombre minimum d'hallucinations. Le seul défaut est que, dans de rares cas, un ou deux caractères chinois ont été mélangés aux réponses, ce qui n'a en rien affecté le sens général.

NVIDIA® RTX™ A40

La prochaine carte NVIDIA® RTX™ A40, sur laquelle nous avons effectué des tests similaires, est à nouveau construite sur l'architecture Ampere et dispose de 48 Go de mémoire vidéo sur la carte mère. Par rapport à la RTX™ 3090, cette mémoire est légèrement plus rapide (20000 MHz contre 19500 MHz), mais sa bande passante est plus faible (695,8 Go/s contre 936,2 Go/s). Cette situation est compensée par le plus grand nombre de cœurs CUDA® (10752 contre 10496), ce qui permet à la RTX™ A40 d'être légèrement plus performante que la RTX™ 3090.

En ce qui concerne la comparaison de la vitesse des modèles, Qwen 2 devance également Llama 3 dans toutes les itérations. Lorsqu'il fonctionne sur la RTX™ A40, la différence de vitesse est d'environ 15% avec les mêmes réponses. Dans certaines tâches, Qwen 2 a donné un peu plus d'informations importantes, tandis que Llama 3 a été aussi précis que possible et a donné des exemples. Malgré cela, tout doit être revérifié, car parfois les deux modèles commencent à produire des réponses controversées.

NVIDIA® L20

Le dernier participant à notre test est le NVIDIA® L20. Ce GPU est construit comme la RTX™ 4090, sur l'architecture Ada Lovelace. Il s'agit d'un modèle assez récent, présenté à l'automne 2023. Il embarque 48 Go de mémoire vidéo et 11776 cœurs CUDA®. La bande passante mémoire est inférieure à celle de la RTX™ 4090 (864 Go/s contre 936,2 Go/s), tout comme la fréquence effective. Les scores d'inférence NVIDIA® L20 des deux modèles seront donc plus proches de 3090 que de 4090.

Le test final n'a pas apporté de surprises. Qwen 2 s'est avéré plus rapide que Llama 3 dans toutes les itérations.

Conclusion

Regroupons tous les résultats collectés dans un seul graphique. Qwen 2 a été plus rapide que Llama 3 de 7% à 24% selon le GPU utilisé. Sur la base de ces résultats, nous pouvons clairement conclure que si vous avez besoin d'obtenir une inférence rapide à partir de modèles tels que Qwen 2 ou Llama 3 sur des configurations mono-GPU, alors le leader incontesté sera la RTX™ 3090. Une alternative possible pourrait être l'A40 ou la L20. Mais il ne vaut pas la peine d'exécuter l'inférence de ces modèles sur des cartes Ampere de la génération A6000.

Nous n'avons délibérément pas mentionné les cartes avec une plus petite quantité de mémoire vidéo, par exemple la NVIDIA® RTX™ 2080Ti, dans les tests, car il n'est pas possible d'y adapter les modèles 7B ou 8B mentionnés ci-dessus sans quantification. Malheureusement, le modèle 1,5B Qwen 2 n'a pas de réponses de haute qualité et ne peut pas servir de remplacement complet pour le 7B.

Voir aussi:

Votre propre Qwen utilisant HF

Mon, 20 Jan 2025 09:43:46 +0100

Les grands modèles de réseaux neuronaux, avec leurs capacités extraordinaires, sont fermement ancrés dans nos vies. Reconnaissant qu'il s'agit d'une opportunité de développement futur, les grandes entreprises ont commencé à développer leurs propres versions de ces modèles. Le géant chinois Alibaba n'est pas resté inactif. Il a créé son propre modèle, QWen (Tongyi Qianwen), qui est devenu la base de nombreux autres modèles de réseaux neuronaux.

Conditions préalables

Mettre à jour le cache et les paquets

Mettons à jour le cache des paquets et mettons à niveau votre système d'exploitation avant de commencer à configurer Qwen. Nous devons également ajouter les paquets d'installation Python (PIP), s'ils ne sont pas déjà présents dans le système. Veuillez noter que pour ce guide, nous utilisons Ubuntu 22.04 LTS comme système d'exploitation :

sudo apt update && sudo apt -y upgrade && sudo apt install python3-pip

Installer les pilotes NVIDIA®

Vous pouvez utiliser l'utilitaire automatisé qui est inclus par défaut dans les distributions Ubuntu :

sudo ubuntu-drivers autoinstall

Vous pouvez également installer les pilotes NVIDIA® manuellement à l'aide de notre guide étape par étape. N'oubliez pas de redémarrer le serveur :

sudo shutdown -r now

Interface web de génération de texte

Cloner le dépôt

Ouvrez le répertoire de travail sur le SSD :

cd /mnt/fastdisk

Cloner le référentiel du projet :

git clone https://github.com/oobabooga/text-generation-webui.git

Installer les exigences

Ouvrir le répertoire téléchargé :

cd text-generation-webui

Vérifier et installer tous les composants manquants :

pip install -r requirements.txt

Ajouter une clé SSH à HF

Avant de commencer, vous devez configurer la redirection de port (port distant 7860 vers 127.0.0.1:7860) dans votre client SSH. Vous trouverez des informations complémentaires dans l'article suivant : Se connecter à un serveur Linux.

Mettre à jour le dépôt de cache des paquets et les paquets installés :

sudo apt update && sudo apt -y upgrade

Générer et ajouter une clé SSH que vous pouvez utiliser dans Hugging Face :

cd ~/.ssh && ssh-keygen

Lorsque la paire de clés est générée, vous pouvez afficher la clé publique dans l'émulateur de terminal :

cat id_rsa.pub

Copiez toutes les informations commençant par ssh-rsa et se terminant par usergpu@gpuserver comme indiqué dans la capture d'écran suivante :

Remplissez le Key name et collez le SSH Public key copié depuis le terminal. Sauvegardez la clé en appuyant sur Add key:

cd ~/

Téléchargez et exécutez le script shell. Ce script installe un nouveau dépôt tiers avec git-lfs :

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Vous pouvez maintenant l'installer à l'aide du gestionnaire de paquets standard :

sudo apt-get install git-lfs

Configurons git pour qu'il utilise notre pseudo HF :

git config --global user.name "John"

Et lié au compte email HF :

git config --global user.email "john.doe@example.com"

Télécharger le modèle

L'étape suivante consiste à télécharger le modèle en utilisant la technique de clonage de référentiel couramment utilisée par les développeurs de logiciels. La seule différence est que le Git-LFS précédemment installé traitera automatiquement les fichiers pointeurs marqués et téléchargera tout le contenu. Ouvrez le répertoire nécessaire (/mnt/fastdisk dans notre exemple) :

cd /mnt/fastdisk

Cette commande peut prendre un certain temps :

git clone git@hf.co:Qwen/Qwen1.5-32B-Chat-GGUF

Exécuter le modèle

Exécuter un script qui démarrera le serveur web et spécifiera /mnt/fastdisk comme répertoire de travail avec les modèles. Ce script peut télécharger des composants supplémentaires lors du premier lancement.

./start_linux.sh --model-dir /mnt/fastdisk

Ouvrez votre navigateur web et sélectionnez le site llama.cpp dans la liste déroulante Model loader:

Veillez à définir le paramètre n-gpu-layers. C'est lui qui est responsable du pourcentage de calculs qui sera déchargé sur le GPU. Si vous laissez le chiffre à 0, tous les calculs seront effectués sur le CPU, ce qui est assez lent. Une fois tous les paramètres définis, cliquez sur le bouton Load. Ensuite, allez dans l'onglet Chat et sélectionnez Instruct mode. Vous pouvez maintenant saisir n'importe quel message et recevoir une réponse :

Le traitement sera effectué par défaut sur tous les GPU disponibles, en tenant compte des paramètres spécifiés précédemment :

Voir aussi:

Votre propre Vicuna sous Linux

Mon, 20 Jan 2025 09:25:01 +0100

Cet article vous guidera à travers le processus de déploiement d'une alternative LLaMA de base sur un serveur LeaderGPU. Pour ce faire, nous utiliserons le projet FastChat et le modèle Vicuna disponible gratuitement.

Le modèle que nous utiliserons est basé sur l'architecture LLaMA de Meta mais a été optimisé pour un déploiement efficace sur du matériel grand public. Cette configuration offre un bon équilibre entre les performances et les besoins en ressources, ce qui la rend adaptée aux environnements de test et de production.

Préinstallation

Préparons l'installation de FastChat en mettant à jour le dépôt de cache des paquets :

sudo apt update && sudo apt -y upgrade

Installez automatiquement les pilotes NVIDIA® à l'aide de la commande suivante :

sudo ubuntu-drivers autoinstall

Vous pouvez également installer ces pilotes manuellement à l'aide de notre guide étape par étape. Redémarrez ensuite le serveur :

sudo shutdown -r now

L'étape suivante consiste à installer PIP (Package Installer for Python) :

sudo apt install python3-pip

Installer FastChat

Depuis PyPi

Il y a deux façons d'installer FastChat. Vous pouvez l'installer directement depuis PyPi :

pip3 install "fschat[model_worker,webui]"

Depuis GitHub

Alternativement, vous pouvez cloner le dépôt FastChat depuis GitHub et l'installer :

git clone https://github.com/lm-sys/FastChat.git

cd FastChat

N'oubliez pas de mettre à jour PIP avant de continuer :

pip3 install --upgrade pip

pip3 install -e ".[model_worker,webui]"

Lancer FastChat

Premier départ

Pour assurer un lancement initial réussi, il est recommandé d'appeler manuellement FastChat directement depuis la ligne de commande :

python3 -m fastchat.serve.cli --model-path lmsys/vicuna-7b-v1.5

Cette action récupère et télécharge automatiquement le modèle désigné de votre choix, qui doit être spécifié en utilisant le paramètre --model-path. Le 7b représente un modèle avec 7 milliards de paramètres. Il s'agit du modèle le plus léger, adapté aux GPU dotés de 16 Go de mémoire vidéo. Des liens vers des modèles avec un plus grand nombre de paramètres peuvent être trouvés dans le fichier Readme du projet.

Vous avez maintenant la possibilité d'engager une conversation avec le chatbot directement dans l'interface de ligne de commande ou de configurer une interface Web. Elle contient trois composants :

Le contrôleur
Travailleurs
Serveur web Gradio

Mise en place des services

Transformons chaque composant en un service systemd séparé. Créez 3 fichiers séparés avec le contenu suivant :

sudo nano /etc/systemd/system/vicuna-controller.service

[Unit]
Description=Vicuna controller service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.controller
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-worker.service

[Unit]
Description=Vicuna worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.model_worker --model-path lmsys/vicuna-7b-v1.5
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-webserver.service

[Unit]
Description=Vicuna web server
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.gradio_web_server
Restart=always
[Install]
WantedBy=multi-user.target

Systemd met généralement à jour sa base de données de démons au cours du processus de démarrage du système. Cependant, vous pouvez le faire manuellement à l'aide de la commande suivante :

sudo systemctl daemon-reload

Ajoutons maintenant trois nouveaux services au démarrage et lançons-les immédiatement à l'aide de l'option --now:

sudo systemctl enable vicuna-controller.service --now && sudo systemctl enable vicuna-worker.service --now && sudo systemctl enable vicuna-webserver.service --now

Cependant, si vous tentez d'ouvrir une interface web à l'adresse http://[IP_ADDRESS]:7860, vous tomberez sur une interface totalement inutilisable, sans aucun modèle disponible. Pour résoudre ce problème, arrêtez le service d'interface web :

sudo systemctl stop vicuna-webserver.service

Exécutez le service web manuellement :

python3 -m fastchat.serve.gradio_web_server

Ajouter une authentification

Cette action appelle un autre script, qui va enregistrer le modèle précédemment téléchargé dans une base de données interne de Gradio. Attendez quelques secondes et interrompez le processus en utilisant le raccourci Ctrl + C. Nous allons également nous occuper de la sécurité et activer un mécanisme d'authentification simple pour accéder à l'interface web. Ouvrez le fichier suivant si vous avez installé FastChat depuis PyPI :

sudo nano /home/usergpu/.local/lib/python3.10/site-packages/fastchat/serve/gradio_web_server.py

sudo nano /home/usergpu/FastChat/fastchat/serve/gradio_web_server.py

Faites défiler l'écran jusqu'à la fin. Trouvez cette ligne :

auth=auth,

Modifiez-la en définissant le nom d'utilisateur ou le mot de passe de votre choix :

auth=(“username”,”password”),

Sauvegardez le fichier et quittez en utilisant le raccourci Ctrl + X. Enfin, démarrez l'interface web :

sudo systemctl start vicuna-webserver.service

Ouvrez http://[IP_ADDRESS]:7860 dans votre navigateur et profitez de FastChat avec Vicuna :

Voir aussi:

Votre propre LLaMa 2 sous Linux

Mon, 20 Jan 2025 09:13:25 +0100

Étape 1. Préparer le système d'exploitation

Mise à jour du cache et des paquets

Mettons à jour le cache des paquets et mettons à niveau votre système d'exploitation avant de commencer à configurer LLaMa 2. Veuillez noter que pour ce guide, nous utilisons Ubuntu 22.04 LTS comme système d'exploitation :

sudo apt update && sudo apt -y upgrade

Nous devons également ajouter Python Installer Packages (PIP), s'il n'est pas déjà présent dans le système :

sudo apt install python3-pip

Installer les pilotes NVIDIA®

Vous pouvez utiliser l'utilitaire automatisé qui est inclus par défaut dans les distributions Ubuntu :

sudo ubuntu-drivers autoinstall

Vous pouvez également installer les pilotes NVIDIA® manuellement à l'aide de notre guide étape par étape. N'oubliez pas de redémarrer le serveur :

sudo shutdown -r now

Étape 2. Obtenir des modèles de MetaAI

Demande officielle

Ouvrez l'adresse suivante dans votre navigateur : https://ai.meta.com/resources/models-and-libraries/llama-downloads/

Remplissez tous les champs nécessaires, lisez les conditions d'utilisation et cliquez sur le bouton Agree and Continue. Après quelques minutes (heures, jours), vous recevrez une URL de téléchargement spéciale, qui vous autorise à télécharger des modèles pendant une période de 24 heures.

Cloner le dépôt

Avant de télécharger, vérifiez l'espace de stockage disponible :

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs            38G  3.3M   38G   1% /run
/dev/sda2        99G   24G   70G  26% /
tmpfs           189G     0  189G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/nvme0n1    1.8T   26G  1.7T   2% /mnt/fastdisk
tmpfs            38G  8.0K   38G   1% /run/user/1000

Si vous avez des disques locaux non montés, veuillez suivre les instructions de la section Partitionnement des disques sous Linux. Ceci est important car les modèles téléchargés peuvent être très volumineux et vous devez planifier leur emplacement de stockage à l'avance. Dans cet exemple, nous avons un disque SSD local monté dans le répertoire /mnt/fastdisk. Ouvrons-le :

cd /mnt/fastdisk

Créer une copie du référentiel LLaMa original :

git clone https://github.com/facebookresearch/llama

Si vous rencontrez une erreur de permission, accordez simplement les permissions à l'utilisateurergpu :

sudo chown -R usergpu:usergpu /mnt/fastdisk/

Téléchargement par script

Ouvrez le répertoire téléchargé :

cd llama

Exécuter le script :

./download.sh

Passer l'URL fournie par MetaAI et sélectionner tous les modèles nécessaires. Nous recommandons de télécharger tous les modèles disponibles afin d'éviter de redemander l'autorisation. Toutefois, si vous avez besoin d'un modèle spécifique, ne téléchargez que celui-ci.

Test rapide via l'application d'exemple

Pour commencer, nous pouvons vérifier s'il manque des composants. Si des bibliothèques ou des applications sont manquantes, le gestionnaire de paquets les installera automatiquement :

pip install -e .

L'étape suivante consiste à ajouter de nouveaux binaires à PATH :

export PATH=/home/usergpu/.local/bin:$PATH

Exécutez l'exemple de démonstration :

torchrun --nproc_per_node 1 /mnt/fastdisk/llama/example_chat_completion.py --ckpt_dir /mnt/fastdisk/llama-2-7b-chat/ --tokenizer_path /mnt/fastdisk/llama/tokenizer.model --max_seq_len 512 --max_batch_size 6

L'application créera un processus de calcul sur le premier GPU et simulera un dialogue simple avec des demandes typiques, en générant des réponses à l'aide de LLaMa 2.

Étape 3. Obtenir llama.cpp

LLaMa C++ est un projet créé par le physicien bulgare et développeur de logiciels Georgi Gerganov. Il comporte de nombreux utilitaires qui facilitent l'utilisation de ce modèle de réseau neuronal. Toutes les parties de llama.cpp sont des logiciels libres et sont distribuées sous la licence MIT.

Cloner le dépôt

Ouvrez le répertoire de travail sur le SSD :

cd /mnt/fastdisk

Cloner le référentiel du projet :

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

Compiler les applications

Ouvrez le répertoire cloné :

cd llama.cpp

Lancez le processus de compilation à l'aide de la commande suivante :

make

Étape 4. Obtenir text-generation-webui

Cloner le dépôt

Ouvrez le répertoire de travail sur le SSD :

cd /mnt/fastdisk

Cloner le référentiel du projet :

git clone https://github.com/oobabooga/text-generation-webui.git

Installer les exigences

Ouvrir le répertoire téléchargé :

cd text-generation-webui

Vérifier et installer tous les composants manquants :

pip install -r requirements.txt

Étape 5. Convertir PTH en GGUF

Formats courants

PTH (Python TorcH) - Un format consolidé. Il s'agit essentiellement d'une archive ZIP standard avec un dictionnaire d'états PyTorch sérialisé. Cependant, ce format a des alternatives plus rapides telles que GGML et GGUF.

GGML (Georgi Gerganov’s Machine Learning) - Il s'agit d'un format de fichier créé par Georgi Gerganov, l'auteur de llama.cpp. Il est basé sur une bibliothèque du même nom, écrite en C++, qui a considérablement augmenté les performances des grands modèles de langage. Il a été remplacé par le format moderne GGUF.

GGUF (Georgi Gerganov’s Unified Format) - Il s'agit d'un format de fichier largement utilisé pour les LLM, pris en charge par diverses applications. Il offre une flexibilité, une évolutivité et une compatibilité accrues pour la plupart des cas d'utilisation.

llama.cpp convert.py script

Modifie les paramètres du modèle avant de le convertir :

nano /mnt/fastdisk/llama-2-7b-chat/params.json

Corrigez "vocab_size": -1 en "vocab_size": 32000. Sauvegardez le fichier et quittez. Ouvrez ensuite le répertoire llama.cpp :

cd /mnt/fastdisk/llama.cpp

Exécutez le script qui convertira le modèle au format GGUF :

python3 convert.py /mnt/fastdisk/llama-2-7b-chat/ --vocab-dir /mnt/fastdisk/llama

Si toutes les étapes précédentes sont correctes, vous recevrez un message comme celui-ci :

Wrote /mnt/fastdisk/llama-2-7b-chat/ggml-model-f16.gguf

Étape 6. WebUI

Comment démarrer l'interface WebUI

Ouvrez le répertoire :

cd /mnt/fastdisk/text-generation-webui/

Exécuter le script de démarrage avec quelques paramètres utiles :

--model-dir indique le chemin d'accès correct aux modèles
--share crée un lien public temporaire (si vous ne voulez pas transmettre un port via SSH)
--gradio-auth ajoute une autorisation avec un login et un mot de passe (remplacez user:password par le vôtre)

./start_linux.sh --model-dir /mnt/fastdisk/llama-2-7b-chat/ --share --gradio-auth user:password

Après un lancement réussi, vous recevrez un lien local et un lien de partage temporaire pour l'accès :

Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://e9a61c21593a7b251f.gradio.live

Ce lien de partage expire dans 72 heures.

Charger le modèle

Autorisez-vous dans l'interface WebUI en utilisant le nom d'utilisateur et le mot de passe sélectionnés et suivez ces 5 étapes simples :

Naviguez jusqu'à l'onglet Model.
Sélectionnez ggml-model-f16.gguf dans le menu déroulant.
Choisissez le nombre de couches que vous souhaitez calculer sur le GPU (n-gpu-layers).
Choisissez le nombre de threads que vous souhaitez démarrer (threads).
Cliquez sur le bouton Load.

Démarrer le dialogue

Changez l'onglet en Chat, tapez votre invite et cliquez sur Generate:

Voir aussi:

Llama 3 utilisant Hugging Face

Mon, 20 Jan 2025 09:05:10 +0100

Le 18 avril 2024, le dernier modèle linguistique majeur de MetaAI, Llama 3, a été publié. Deux versions ont été présentées aux utilisateurs : 8B et 70B. La première version contient plus de 15 000 tokens et a été entraînée sur des données valables jusqu'en mars 2023. La seconde version, plus volumineuse, a été entraînée sur des données valables jusqu'en décembre 2023.

Étape 1. Préparer le système d'exploitation

Mise à jour du cache et des paquets

Mettons à jour le cache des paquets et mettons à niveau votre système d'exploitation avant de commencer à installer LLaMa 3. Veuillez noter que pour ce guide, nous utilisons Ubuntu 22.04 LTS comme système d'exploitation :

sudo apt update && sudo apt -y upgrade

Nous devons également ajouter Python Installer Packages (PIP), s'il n'est pas déjà présent dans le système :

sudo apt install python3-pip

Installer les pilotes NVIDIA®

Vous pouvez utiliser l'utilitaire automatisé qui est inclus par défaut dans les distributions Ubuntu :

sudo ubuntu-drivers autoinstall

Vous pouvez également installer les pilotes NVIDIA® manuellement. N'oubliez pas de redémarrer le serveur :

sudo shutdown -r now

Étape 2. Obtenir le modèle

Connectez-vous à Hugging Face en utilisant votre nom d'utilisateur et votre mot de passe. Allez sur la page correspondant à la version LLM souhaitée : Meta-Llama-3-8B ou Meta-Llama-3-70B. Au moment de la publication de cet article, l'accès au modèle est fourni sur une base individuelle. Remplissez un court formulaire et cliquez sur le bouton Submit:

Demande d'accès à HF

Vous recevrez ensuite un message indiquant que votre demande a été soumise :

Vous obtiendrez l'accès après 30-40 minutes et en serez informé par e-mail.

Ajouter une clé SSH à HF

Générez et ajoutez une clé SSH que vous pourrez utiliser dans Hugging Face :

cd ~/.ssh && ssh-keygen

Lorsque la paire de clés est générée, vous pouvez afficher la clé publique dans l'émulateur de terminal :

cat id_rsa.pub

Copiez toutes les informations commençant par ssh-rsa et se terminant par usergpu@gpuserver, comme indiqué dans la capture d'écran suivante :

Ouvrez les paramètres du profil de Hugging Face. Choisissez ensuite SSH and GPG Keys et cliquez sur le bouton Ajouter une clé SSH :

Remplissez le Key name et collez le SSH Public key copié depuis le terminal. Enregistrez la clé en appuyant sur Add key:

cd ~/

Téléchargez et exécutez le script shell. Ce script installe un nouveau dépôt tiers avec git-lfs :

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Vous pouvez maintenant l'installer à l'aide du gestionnaire de paquets standard :

sudo apt-get install git-lfs

Configurons git pour qu'il utilise notre pseudo HF :

git config --global user.name "John"

Et lié au compte email HF :

git config --global user.email "john.doe@example.com"

Télécharger le modèle

Ouvrir le répertoire cible :

cd /mnt/fastdisk

Et commencez à télécharger le référentiel. Pour cet exemple, nous avons choisi la version 8B :

git clone git@hf.co:meta-llama/Meta-Llama-3-8B

Ce processus prend jusqu'à 5 minutes. Vous pouvez le surveiller en exécutant la commande suivante dans une autre console SSH :

watch -n 0.5 df -h

Vous verrez alors que l'espace libre sur le disque monté se réduit, ce qui garantit que le téléchargement progresse et que les données sont sauvegardées. L'état est actualisé toutes les demi-secondes. Pour arrêter manuellement la visualisation, appuyez sur le raccourci Ctrl + C.

Vous pouvez également installer btop et surveiller le processus à l'aide de cet utilitaire :

sudo apt -y install btop && btop

Pour quitter l'utilitaire btop, appuyez sur la touche Esc et sélectionnez Quit.

Étape 3. Exécuter le modèle

Ouvrez le répertoire :

cd /mnt/fastdisk

Télécharger le dépôt Llama 3 :

git clone https://github.com/meta-llama/llama3

Changez de répertoire :

cd llama3

Exécuter l'exemple :

torchrun --nproc_per_node 1 example_text_completion.py \
--ckpt_dir /mnt/fastdisk/Meta-Llama-3-8B/original \
--tokenizer_path /mnt/fastdisk/Meta-Llama-3-8B/original/tokenizer.model \
--max_seq_len 128 \
--max_batch_size 4

Vous pouvez maintenant utiliser Llama 3 dans vos applications.

Voir aussi:

StarCoder : votre assistant de codage local

Fri, 17 Jan 2025 14:52:58 +0100

Microsoft CoPilot a révolutionné le domaine du développement logiciel. Cet assistant IA aide grandement les développeurs à effectuer diverses tâches de codage, leur facilitant ainsi la vie. Cependant, l'un des inconvénients est qu'il ne s'agit pas d'une application autonome, mais plutôt d'un service basé sur le cloud. Cela signifie que les utilisateurs doivent accepter les conditions générales du service et payer un abonnement.

Heureusement, le monde des logiciels libres nous offre de nombreuses alternatives. Au moment de la rédaction de cet article, l'alternative la plus notable à CoPilot est StarCoder, développé par le projet BigCode. StarCoder est un modèle de réseau neuronal étendu avec 15,5 milliards de paramètres, entraîné sur plus de 80 langages de programmation.

Ce modèle est distribué sur Hugging Face (HF) à l'aide d'un modèle gated sous l'accord de licence BigCode OpenRAIL-M v1. Vous pouvez télécharger et utiliser ce modèle gratuitement, mais vous devez avoir un compte HF avec une clé SSH associée. Avant de pouvoir télécharger, vous devez suivre quelques étapes supplémentaires.

Ajouter une clé SSH à HF

Avant de commencer, vous devez configurer le transfert de port (port distant 7860 vers 127.0.0.1:7860) dans votre client SSH. Vous trouverez des informations supplémentaires dans les articles suivants :

Mettre à jour le dépôt de cache des paquets et les paquets installés :

sudo apt update && sudo apt -y upgrade

Installons le gestionnaire de paquets du système Python (PIP) :

sudo apt install python3-pip

Générer et ajouter une clé SSH que vous pouvez utiliser dans Hugging Face :

cd ~/.ssh && ssh-keygen

Lorsque la paire de clés est générée, vous pouvez afficher la clé publique dans l'émulateur de terminal :

cat id_rsa.pub

Copiez toutes les informations commençant par ssh-rsa et se terminant par usergpu@gpuserver comme indiqué dans la capture d'écran suivante :

Remplissez le Key name et collez le SSH Public key copié depuis le terminal. Sauvegardez la clé en appuyant sur Add key:

cd ~/

Téléchargez et exécutez le script shell. Ce script installe un nouveau dépôt tiers avec git-lfs :

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Vous pouvez maintenant l'installer à l'aide du gestionnaire de paquets standard :

sudo apt-get install git-lfs

Configurons git pour qu'il utilise notre pseudo HF :

git config --global user.name "John"

Et lié au compte email HF :

git config --global user.email "john.doe@example.com"

Télécharger le modèle

Veuillez noter que StarCoder au format binaire peut prendre beaucoup d'espace disque (>75 GB). N'oubliez pas de vous référer à cet article pour vous assurer que vous utilisez la bonne partition montée.

Tout est prêt pour le téléchargement du modèle. Ouvrez le répertoire cible :

cd /mnt/fastdisk

et commencez à télécharger le référentiel :

git clone git@hf.co:bigcode/starcoder

Ce processus peut prendre jusqu'à 15 minutes. Soyez patient. Vous pouvez surveiller ce processus en exécutant la commande suivante dans une autre console SSH :

watch -n 0.5 df -h

Exécuter le modèle complet avec l'interface WebUI

Clonez le dépôt du projet :

git clone https://github.com/oobabooga/text-generation-webui.git

Ouvrir le répertoire téléchargé :

cd text-generation-webui

Exécuter le script de démarrage :

./start_linux.sh --model-dir /mnt/fastdisk

Le script vérifiera la présence des dépendances nécessaires sur le serveur. Toute dépendance manquante sera installée automatiquement. Lorsque l'application démarre, ouvrez votre navigateur web et tapez l'adresse suivante :

http://127.0.0.1:7860

Ouvrez l'onglet Model et sélectionnez le modèle téléchargé starcoder dans la liste déroulante. Cliquez sur la liste Model loader et choisissez Transformers. Réglez le curseur de mémoire maximale du GPU pour chaque GPU installé. Ce paramètre est très important, car s'il est fixé à 0, l'utilisation de la VRAM est limitée et le modèle ne peut pas se charger correctement. Vous devez également définir l'utilisation maximale de la mémoire vive. Cliquez maintenant sur le bouton Load et attendez la fin du processus de chargement :

Passez à l'onglet Chat et testez la conversation avec le modèle. Veuillez noter que Starcoder n'est pas destiné à des dialogues comme ChatGPT. Cependant, il peut être utile pour vérifier les erreurs dans le code et suggérer des solutions.

Si vous souhaitez obtenir un modèle de dialogue complet, vous pouvez essayer deux autres modèles : starchat-alpha et starchat-beta. Ces modèles ont été mis au point pour conduire un dialogue comme le fait ChatGPT. Les commandes suivantes permettent de télécharger et d'exécuter ces modèles :

Pour starchat-alpha :

git clone git@hf.co:HuggingFaceH4/starchat-alpha

Pour starchat-beta :

git clone git@hf.co:HuggingFaceH4/starchat-beta

La procédure de chargement est la même que celle décrite ci-dessus. Vous trouverez également une implémentation C++ de starcoder, qui sera efficace pour l'inférence CPU.

Voir aussi:

Modèles de Stable Diffusion: personnalisation et options

Mon, 25 Nov 2024 13:30:16 +0100

Le tuning est un excellent moyen d'améliorer chaque voiture ou gadget. Les réseaux neuronaux génératifs peuvent également être réglés. Aujourd'hui, nous ne souhaitons pas approfondir la structure de la diffusion stable, mais nous voulons obtenir de meilleurs résultats qu'avec une configuration standard.

Il existe deux moyens simples d'y parvenir : l'installation de modèles personnalisés et l'utilisation des options d'optimisation standard. Dans cet article, nous verrons comment installer de nouveaux modèles dans Stable Diffusion et quelles options nous permettent d'utiliser le matériel plus efficacement.

Si vous souhaitez partager des photos amusantes de chats mignons ou de plats succulents, vous les publiez généralement sur Instagram. Si vous développez des applications et souhaitez mettre le code à la disposition de tous, vous le publiez sur GitHub. Mais si vous entraînez un modèle d'IA graphique et que vous souhaitez le partager, vous devriez vous intéresser à CivitAI. Il s'agit d'une vaste plateforme permettant de partager les connaissances et les résultats avec les membres de la communauté.

Avant de commencer le téléchargement, vous devez changer le répertoire de travail. Tous les modèles d'IA dans Stable Diffusion sont placés dans le répertoire "models":Avant de commencer le téléchargement, vous devez changer le répertoire de travail. Tous les modèles d'IA de Stable Diffusion sont placés dans le répertoire "models" :

cd stable-diffusion-webui/models/Stable-diffusion

Vérifions quels sont les modèles fournis par défaut :

ls -a

'Put Stable Diffusion checkpoints here.txt'
v1-5-pruned-emaonly.safetensors

Il n'y a qu'un seul modèle avec le nom "v1-5-pruned-emaonly" et l'extension "safetensors". Ce modèle est un bon point de départ, mais nous avons cinq modèles plus intéressants. Nous allons les télécharger et les comparer avec le modèle standard.

Invitations à la diffusion stable

Pour montrer visuellement la différence entre les deux modèles, nous avons créé des messages-guides simples :

princess, magic, fairy tales, portrait, 85mm, colorful

Pour de nombreux modèles, la représentation précise de la géométrie et des traits du visage peut constituer un défi important. Pour y remédier, ajoutez des invites négatives pour vous assurer que les images sont générées sans ces caractéristiques :

poorly rendered face, poorly drawn face, poor facial details, poorly drawn hands, poorly rendered hands, low resolution, bad composition, mutated body parts, blurry image, disfigured, oversaturated, bad anatomy, deformed body features

Définissez la valeur maximale des pas d'échantillonnage (150) pour obtenir plus de détails dans le résultat.

Modèle standard

Le modèle standard donne de bons résultats dans ce type de tâches. Cependant, certains détails ne sont pas tout à fait exacts. Par exemple, il y a un problème avec les yeux : ils sont clairement disproportionnés :

Si vous regardez le diadème, il est également tordu et asymétrique. Le reste des détails est bien exécuté et correspond aux indications données. L'arrière-plan est flou parce que nous avons choisi l'option "85 mm". Il s'agit d'une longueur focale très couramment utilisée pour les portraits dans la photographie professionnelle.

Vision réaliste

Ce modèle est idéal pour les portraits. L'image apparaît comme si elle avait été prise avec un objectif de qualité ayant la longueur focale spécifiée. Les proportions du visage et du corps sont exactes, la robe est parfaitement ajustée et le diadème sur la tête est esthétiquement plaisant :

À propos, l'auteur recommande d'utiliser le modèle suivant pour les questions négatives :

deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.4), text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck

Mais même avec nos questions simples, le résultat est excellent.

Téléchargez le modèle ici : Vision réaliste

Délibérée

Un autre modèle étonnant pour ce type d'usage. Ici aussi, les détails sont bien élaborés, mais soyez prudent et surveillez le nombre de doigts. Il s'agit d'un problème très courant avec les réseaux neuronaux : ils peuvent souvent dessiner des doigts supplémentaires, voire des membres entiers.

La création de lignes visuelles est l'une des techniques cinématographiques préférées. Ainsi, ce modèle a également choisi de dessiner une personne sur fond de sentier forestier.

Téléchargez le modèle ici : Délibéré

OpenJourney

Parmi les réseaux neuronaux génératifs, Midjourney (MJ) a fait l'objet d'une attention particulière. MJ a été un pionnier dans ce domaine et est souvent cité en exemple. Les images qu'il crée ont un style unique. OpenJourney s'inspire du style MJ et est une diffusion stable convenablement réglée.

Les images générées ressemblent à un dessin animé. Elles sont vibrantes et lumineuses. Pour de meilleurs résultats, ajoutez l'invite de style mdjrny-v4

Téléchargez le modèle ici : OpenJourney

Tout

Ce modèle crée des images à la manière d'un dessinateur professionnel de manga (personne qui dessine des bandes dessinées). Ainsi, nous avons obtenu une princesse de style anime.

Ce modèle est entraîné sur des images d'une résolution de 768x768. Vous pouvez définir cette résolution pour obtenir de meilleurs résultats que la résolution standard de 512x512.

Téléchargez le modèle ici : Tout

Entreprise Memphis

Ce style d'images a connu une grande popularité au début des années 2020 et a été largement utilisé comme style d'entreprise dans différentes sociétés de haute technologie. Malgré les critiques, on le retrouve souvent dans les présentations et les sites web.

La princesse s'est avérée être minimaliste, mais assez jolie. Les détails que le modèle a placés sur l'arrière-plan sont particulièrement amusants.

Téléchargez le modèle ici : Corporate Memphis

Options de diffusion stable

La diffusion stable consomme beaucoup de ressources, c'est pourquoi de nombreuses options ont été développées. La plus populaire d'entre elles est --xformers. Cette option active deux mécanismes d'optimisation. Le premier réduit la consommation de mémoire et le second est utilisé pour augmenter la vitesse.

Si vous essayez d'ajouter --xformers sans étapes supplémentaires, vous obtiendrez une erreur indiquant que les paquets(torch et torchvision) sont compilés pour différentes versions de CUDA®. Pour résoudre ce problème, nous devons entrer dans l'environnement virtuel Python (venv) qui est utilisé pour Stable Diffusion. Ensuite, installez les paquets pour la version souhaitée de CUDA® (v1.18).

Tout d'abord, nous devons mettre à jour le cache des paquets apt et installer le programme d'installation des paquets pour Python (pip). L'étape suivante consiste à activer Python venv avec le script activate:

source stable-diffusion-webui/venv/bin/activate

Après cela, l'invite de la ligne de commande devient (venv) username@hostname:~$. Installons les paquets torch et torchvision avec CUDA® 11.8 :

pip install torch==2.0.0+cu118 torchvision==0.15.1+cu118 --index-url https://download.pytorch.org/whl/cu118

Ce processus peut prendre plusieurs minutes car les paquets sont assez volumineux. Vous aurez juste le temps de vous servir un café. Enfin, vous pouvez désactiver l'environnement virtuel et démarrer Stable Diffusion avec l'option --xformers (remplacez [user] et [password] par vos propres valeurs) :

deactivate

./webui --xformers --listen --gradio-auth [user]:[password]

L'alternative la plus rapide à --xformers est --opt-sdp-no-mem-attention, qui consomme plus de mémoire mais fonctionne un peu plus rapidement. Vous pouvez utiliser cette option sans étapes supplémentaires.

Conclusion

Aujourd'hui, nous avons examiné les capacités de la diffusion stable lorsqu'elle est combinée à d'autres modèles ajoutés et à des options d'optimisation. N'oubliez pas qu'en augmentant ou en diminuant le nombre d'étapes d'échantillonnage, vous pouvez ajuster le niveau de détail de l'image finale.

Bien entendu, il ne s'agit là que d'une petite partie de ce que vous pouvez faire avec un tel réseau neuronal génératif. Commandez donc un serveur GPU dès maintenant et commencez à expérimenter. De nombreuses autres découvertes et opportunités vous attendent. Des cartes vidéo rapides et puissantes vous aideront à gagner du temps et à générer des images intéressantes.

Voir aussi :

Stable Diffusion WebUI

Mon, 25 Nov 2024 13:24:45 +0100

Les réseaux neuronaux génératifs semblent magiques. Ils répondent à des questions, créent des images et écrivent même du code dans différents langages de programmation. Le succès de ces réseaux repose sur deux éléments : des modèles pré-entraînés et des accélérateurs matériels. Il est certes possible d'utiliser les cœurs de l'unité centrale pour cette charge de travail, mais ce serait comme une course d'escargots. La génération d'une petite image peut prendre beaucoup de temps - des dizaines de minutes. Générer la même image sur un GPU prendrait des centaines de fois moins de temps.

Le premier secret réside dans le nombre de cœurs. Les cœurs de l'unité centrale sont universels et peuvent traiter des instructions complexes. Cependant, les processeurs de serveurs conventionnels ont un maximum de 64 cœurs. Même dans les systèmes multiprocesseurs, le nombre de cœurs dépasse rarement 256. Les cœurs des GPU sont plus simples, ce qui permet d'en placer beaucoup plus sur la puce. Par exemple, une NVIDIA® RTX™ 4090 possède 16 384 cœurs.

Le deuxième secret réside dans le fait que la charge de travail peut être divisée en plusieurs tâches simples, qui peuvent être exécutées en parallèle sur des cœurs GPU dédiés. Cette astuce permet d'accélérer considérablement le traitement des données. Aujourd'hui, nous allons voir comment cela fonctionne et déployer un réseau neuronal génératif Stable Diffusion Web UI sur l'infrastructure LeaderGPU. Prenons l"exemple d'un serveur équipé d'une NVIDIA® RTX™ 4090 qui possède 16 384 cœurs de GPU. Comme système d'exploitation, nous avons sélectionné la version LTS actuelle Ubuntu 22.04 et choisi l'option "Installer les pilotes NVIDIA® et CUDA® 11.8".

Préparation du système

Avant de commencer, prenons en compte la mémoire. Stable Diffusion est un gros système qui peut occuper jusqu'à 13G sur votre disque dur. Le disque virtuel standard dans une installation LeaderGPU est de 100G. Le système d'exploitation occupe 25G. Si nous déployons Stable Diffusion sans étendre la partition home, nous allons épuiser toute la mémoire libre et rencontrer une erreur "No space left on device". C'est une bonne idée d'étendre notre répertoire personnel.

Étendre le répertoire personnel

Tout d'abord, nous devons vérifier tous les disques disponibles.

sudo fdisk -l

Disk /dev/sda: 447.13 GiB, 480103981056 bytes, 937703088 sectors
Disk model: INTEL SSDSC2KB48
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

Disk /dev/sdb: 50 GiB, 53687091200 bytes, 104857600 sectors
Disk model: VIRTUAL-DISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 9D4C1F0C-D4A7-406E-AECB-BF57E4726437

Ensuite, nous devons créer une nouvelle partition Linux sur notre disque SSD physique, /dev/sda :

sudo fdisk /dev/sda

Appuyez sur les touches suivantes, une par une : g → n → Enter → Enter → Enter → w. Il en résultera une nouvelle partition /dev/sda1 sans système de fichiers. Maintenant, créez un système de fichiers ext4 sur cette partition :

sudo mkfs.ext4 /dev/sda1

Lorsque le processus est terminé, nous passons à l'étape suivante.

Attention ! Veuillez procéder à l'opération suivante avec le plus grand soin. Toute erreur commise lors de la modification du fichier fstab peut empêcher votre serveur de démarrer normalement et peut nécessiter une réinitialisation complète du système d'exploitation.

sudo blkid

/dev/sdb2: UUID="6b17e542-0934-4dba-99ca-a00bd260c247" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="70030755-75d8-4339-a4e0-26a97f1d1c5d"
/dev/loop1: TYPE="squashfs"
/dev/sdb1: PARTUUID="63ff1714-bd29-4062-be04-21af32423c0a"
/dev/loop4: TYPE="squashfs"
/dev/loop0: TYPE="squashfs"
/dev/sda1: UUID="fb2ba455-2b8d-4da0-8719-ce327d0026bc" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="6e0108df-b000-5848-8328-b187daf37a4f"
/dev/loop5: TYPE="squashfs"
/dev/loop3: TYPE="squashfs"

Copiez UUID (fb2ba455-2b8d-4da0-8719-ce327d0026bc dans l'exemple) de la partition /dev/sda1. Ensuite, nous allons demander au système de monter automatiquement ce lecteur par son UUID au moment du démarrage :

sudo nano /etc/fstab

Saisissez cette ligne avant /swap.img... string :

/dev/disk/by-uuid/ /home/usergpu ext4 defaults defaults

Exemple :

# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
#                
# / was on /dev/sdb2 during curtin installation
/dev/disk/by-uuid/6b17e542-0934-4dba-99ca-a00bd260c247 / ext4 defaults,_netdev 0 1
/dev/disk/by-uuid/fb2ba455-2b8d-4da0-8719-ce327d0026bc /home/usergpu ext4 defaults defaults
/swap.img       none    swap    sw      0       0

Quittez avec le raccourci clavier Ctrl + X et confirmez l'enregistrement du fichier en appuyant sur Enter. Les nouveaux paramètres seront appliqués au prochain démarrage du système. Redémarrons le serveur :

sudo shutdown -r now

Après le redémarrage, nous pouvons vérifier tous les répertoires montés à l'aide de la commande suivante :

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs           6.3G  1.7M  6.3G   1% /run
/dev/sdb2        49G   23G   24G  50% /
tmpfs            32G     0   32G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/sda1       440G   28K  417G   1% /home/usergpu
tmpfs           6.3G  4.0K  6.3G   1% /run/user/1000

Superbe ! Mais maintenant, nous n'avons plus le droit d'écrire quelque chose dans notre répertoire personnel parce qu'il a été modifié par le fichier de configuration fstab. Il est temps de récupérer la propriété du répertoire :

sudo chown -R usergpu /home/usergpu

Bon travail ! Passons à l'étape suivante.

Installer les paquets de base

Mettez à jour le cache logiciel à partir des dépôts officiels d'Ubuntu et mettez à niveau certains paquets :

sudo apt update && sudo apt -y upgrade

Le système a informé qu'un nouveau noyau a été installé et qu'il sera opérationnel après le redémarrage du système. Sélectionnez deux fois OK.

Ensuite, nous devons résoudre les dépendances, qui nécessitent Stable Diffusion. Le premier paquet ajoute la fonctionnalité d'environnement virtuel Python :

sudo apt install python3-venv

Le deuxième paquet ajoute une implémentation de la fonction malloc() du langage de programmation C, personnalisée par Google. Elle évite l'erreur “Cannot locate TCMalloc” et améliore l'utilisation de la mémoire du processeur.

sudo apt install -y --no-install-recommends google-perftools

Enfin, redémarrez le serveur :

sudo shutdown -r now

Diffusion stable automatique 1111 : script d'installation

La façon la plus simple d'installer Stable Diffusion avec WebUI est d'utiliser le script écrit par l'utilisateur GitHub AUTOMATIC1111. Ce script télécharge et installe ces deux parties tout en résolvant toutes les dépendances nécessaires.

Téléchargeons le script :

wget https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh

Ensuite, donnons-lui l'accès aux données de modification et exécutons-le comme un programme :

chmod a+x webui.sh

Exécuter le script téléchargé :

./webui.sh

Ce processus peut prendre quelques minutes. Tout est prêt pour créer des images parfaites avec Stable Diffusion.

Résolution des problèmes

Si vous rencontrez l'erreur "Torch is not able to use GPU", vous pouvez la corriger en réinstallant via apt :

sudo apt -y install nvidia-driver-535

Vous devez redémarrer le système d'exploitation pour activer le pilote :

sudo shutdown -r now

Générer

Le script d'installation ./webui.sh a une autre fonction. Il sert simultanément la partie serveur de Stable Diffusion et WebUI. Cependant, si vous l'utilisez sans arguments, le serveur sera disponible en tant que démon local à l'adresse http://127.0.0.1:7860. Ce problème peut être résolu de deux manières : la redirection de port à travers un tunnel SSH ou l'autorisation de connexions à partir d'IP externes.

La seconde méthode est plus simple : il suffit d'ajouter l'option --listen pour se connecter à l'interface web à l'adresse http://[YOUR_LEADERGPU_SERVER_IP_ADDRESS]:7860. Cependant, cette méthode n'est pas du tout sûre, car tous les utilisateurs d'Internet y auront accès. Pour éviter toute utilisation non autorisée, ajoutez l'option --gradio-auth à côté du nom d'utilisateur et du mot de passe, séparés par deux points :

./webui.sh --listen --gradio-auth user:password

Le script télécharge les modèles de base et les dépendances nécessaires pour la première fois :

Vous pouvez apprécier le résultat. Il vous suffit de saisir quelques invites, de les séparer par des virgules et de cliquer sur le bouton Générer. Après quelques secondes, une image générée par le réseau neuronal s'affiche.

Conclusion

Nous sommes passés d'un serveur LeaderGPU vide avec seulement un système d'exploitation préinstallé à une instance prête à l'emploi avec Stable Diffusion et une interface WebUI. La prochaine fois, nous en apprendrons plus sur l'optimisation des performances logicielles et sur la manière d'améliorer correctement votre instance Stable Diffusion avec de nouvelles versions de pilotes et de paquets.

Voir aussi :