# Établissement d'un "Lawyer GPT" pour votre blog - Partie 2: Installation de GPU CUDA en CM SK5 ## Introduction Bienvenue à la partie 2! [Partie 1](/blog/building-a-lawyer-gpt-for-your-blog-part1), nous avons énoncé la vision de construire un assistant à l’écriture qui utilise votre blog comme base de connaissances. > NOTE: C'est une partie des expériences que j'ai réalisées avec l'A.I. M SK1 rédaction assistée) + ma propre éditionMST4 La même voixM ST5 le même pragmatismeM st6 quelques doigts plus rapidesMst7 **À propos de mon matériel**: IMSC1m utilisant un NVIDIA RTX A4000 (16GB VRAMM SK4 AMD Ryzen 9 \9950XMST7 et SSK8GB DDRMSSK9 RAMMS. Mais vous n’avez pas à utiliser ce type de GPU. Cette partie peut sembler fondamentale si vous connaissez déjà ' [CUDA](https://developer.nvidia.com/cuda-toolkit), mais je m'en fière - Je'ai gaspillé des heures en débugging des erreurs mystérieuses qui remontaient à des malentendus de versionMSC3 variables environnementales manquantesM SK4 ou incorrectes [Numéro du dossier :](https://developer.nvidia.com/cudnn) installations. NousM SK1Nous le ferons dès le départ. [TOC] ## Pourquoi l'accélération des GPU est importante Avant de se plonger dans l’installation, laissez-nous comprendre pourquoi nous avons besoin d’une accélération GPU. ### CPU vs GPU pour les charges de travail d'AI ```mermaid graph LR A[AI Workload] --> B{Type?} B -->|Matrix Operations| C[GPU: 100x+ faster] B -->|Sequential Logic| D[CPU: Better] C --> E[Embedding Generation] C --> F[LLM Inference] C --> G[Vector Search] D --> H[Application Logic] D --> I[File I/O] class C gpu class E,F,G aiTasks classDef gpu stroke:#333,stroke-width:4px classDef aiTasks stroke:#333 ``` **Pourquoi les GPU dominent l'AI**: 1. **Parallèle** - Les GPU ont des milliers de noyaux par rapport aux CPUs 2. **Opérations de matrice** - L’AI est essentiellement mathématique de matrices , dont les GPUs excellent 3. **largeur de bande de mémoire** - Les GPUs déplacent les données beaucoup plus rapidement 4. **Matériel spécialisé** - Les carottes de tensor accélèrent les opérations spécifiques d’AI- **Exemple du monde réel-** ( sur mon matérielM SK1 Gérer des embeddings pour un post de blog: - **Processus central (Ryzen 9 9950XM SK3**: ~5 secondes par poste - **GPU (AM SK1 16GB)**: ~0.3 secondes par poste Que 's 16x plus rapidesM SK2 et qu’il s’accroît lorsqu’on traite des centaines de postes **Rendement sur d'autres GPU** (approximateM SK1 - **RTX 4090** (24GB):Le plus rapideM SK2 ~0.2s par poste - **RTX 3060** (12GBM SK1 ~0.5s par poste - **GTX 1070 Ti** (8GBM SK1 ~0.8s par poste - Il est encore beaucoup plus rapide que le CPU! ## Comprendre votre matériel Avant d’installer quelque chose, laissez-leur comprendre avec quoi nous travaillons. ### Mon GPU: NVIDIA RTX A4000 C'est mon GPU spécifique - une carte de poste de travail professionnelle avec: - **16GB GDDR6 VRAM** - C'est suffisant pour les modèles de paramètres 7BM SK2B - **6144 Noyaux CUDA** - Puissance de traitement parallèle - **256 Noyaux de tensor** - Opérations d'AI accélérées - **Capacité de calcul CUDA 8.6** - Important pour la compatibilité ### Options GPU courantes Voici ce que les différents GPUs peuvent gérer' | GPU | VRAM |-----|------|----------------|----------| | RTX | RTX | RTX 3060 | ≥12GB MSC4 \7B MSC6 Budget SMC7friendly SMC8 | RTX 4060 Ti MSC2 MSC3GB SMC4 | | 5 | B | 6 |B | 7 | Valeur élevée | 8 | | AM SK1 ( mine) | | 4 | 5 | GB | 6 | 7 | 8 | 9 | GPU de travail | 10 | | GTX ### Qu'en est-il d'Intel/AMD NPUs? Vous avez peut-être déjà entendu parler des puces Intel Core Ultra ou AMD Ryzen AI avec des unités de traitement neuronal -in NPUs **Pouvez-vous les utiliser plutôt que NVIDIA?** **Réponse courte**: N'est pas encore recommandé pour ce cas d'utilisation. **État actuel (late 2025)**: - **DirectML a atteint sa maturité**: [ONNX Runtime DirectML](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html) le fournisseur d’exécution est maintenant en production- prêt - **Amélioration de l'appui du NPU**: IntelM SK1s Core Ultra (Meteor Lake/Lunar LakeMSC4 et AMDMSC5s Ryzen AI peut faire des inferences via DirectML - **Limites relatives au format du modèle**: Les NPU fonctionnent le mieux avec les modèles ONNXM SK1 Les modèles GGUF ( utilisés pour les LLM) demeurent cibles CUDAMSC4CPU principalement - **Rendement de LLM**: Pour les grands modèles linguistiques, Les NPU sont actuellement plus lentes que les GPU dispersés et souvent plus lentement que les CPU modernes - **Le meilleur pour**: Modèles de petite taille , sur-détermination des instrumentsM SK3 pile à batterieMSC4 scénarios électriques **Pourquoi nous utilisons encore NVIDIA CUDA**: 1. **La maturité des écosystèmes**: CUDA a 15+ années d’optimisation pour les LLM 2. **LLamaSharp**: Utilise llama.cpp qui cible CUDA /CPUM SK3 non DirectMLMSC4NPU 3. **Rendement**: Une gamme moyenne de GPU NVIDIA surpasse encore significativement les NPU pour notre charge de travail 4. **Soutien communautaire**: Beaucoup de ressources et d’analyses de problèmes disponibles **Si vous avez un CPU équipé d'un NPU-**: - Pour la génération d'embedding (Part 3), vous pouvez utiliser DirectML avec ONNX Runtime - pourrait fonctionner raisonnablement bien - Pour l'inférence LLM (Part 6), rester avec le mode CPU ou obtenir un GPU discret - Suivi de llama.cpp DirectML backend (expérimental à partir du nov. **Perspectives futures**: Les NPUs s'améliorent rapidement . D'ici le début de l'année, ils pourraient devenir viables pour la détermination LLM M SK3 surtout pour les modèles plus petits (1BM SK5 Paramètres B MSC6 Intel MST7 Arrow Lake et AMD M ST8 Suivant M st 9 Gen XDNA S ST10 promettent d'importantes améliorations du rendement AI S S ST11 Cette série se concentre sur **NVIDIA CUDA** parce qu’il offre la meilleure performance aujourd’hui, mais les concepts d’architecture se traduiront en NPU à mesure que l’écosystème mature! ### Vérifiez votre GPU Première , vérifiez que Windows voit votre GPU: ```bash # PowerShell wmic path win32_VideoController get name ``` Vous devriez voir quelque chose comme: ``` Name NVIDIA RTX A4000 ``` Ou utiliser le panneau de commande NVIDIA → Renseignements sur le système → onglet d'affichage. ### Aperçu de l'architecture Voici'comme fonctionne le stade de logiciels: ```mermaid graph TB A[Your C# Application] --> B[ONNX Runtime / LLamaSharp] B --> C[CUDA Toolkit] C --> D[cuDNN Libraries] D --> E[NVIDIA Driver] E --> F[GPU Hardware] G[TensorRT] -.Optional.-> D class A,F endpoints class C,D,E install classDef endpoints stroke:#333,stroke-width:4px classDef install stroke:#333,stroke-width:2px subgraph "What We'll Install" C D E end ``` **Répartition des couches**: - **Utilisateur NVIDIA** - Communication GPU de niveau faible- - **Trousse d'outils CUDA** - APIs pour la programmation GPU - **Numéro du dossier :** - Bibliothèque du réseau neuronal profond (noyaux optimisés) - **OnNX Runtime / LLamaSharp** - cadres ML de niveau élevé- - **Votre demande** - Notre code CM SK1 ## Carte routière d'installation C'est là que nous installerons les choses. ```mermaid graph LR A[1. NVIDIA Driver] --> B[2. CUDA Toolkit] B --> C[3. cuDNN] C --> D[4. Verify Install] D --> E[5. Test from C#] class A,B,C,D,E steps classDef steps stroke:#333,stroke-width:2px ``` ## Étape 1: Conducteur NVIDIA ### Vérifier le conducteur actuel Ouvrir PowerShell: ```bash nvidia-smi ``` Vous devriez voir une sortie comme: ``` +-----------------------------------------------------------------------------+ | NVIDIA-SMI 546.33 Driver Version: 546.33 CUDA Version: 12.3 | |-------------------------------+----------------------+----------------------+ | GPU Name TCC/WDDM | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. | |===============================+======================+======================| | 0 NVIDIA RTX A4000 WDDM | 00000000:01:00.0 Off | Off | | 41% 32C P8 10W / 140W | 345MiB / 16376MiB | 0% Default | +-------------------------------+----------------------+----------------------+ ``` **Renseignements clés**: - `Driver Version`: devrait être 545.xx ou plus récent - `CUDA Version`: Il s'agit de la version MAX CUDA supportée, et non de ce qui est installéM SK2s - `Memory-Usage`: Utilisation courante / total VRAM ### Mise à jour du conducteur si nécessaire Si `nvidia-smi` ne fonctionne pas, ou votre chauffeur est vieux 1. Envoyer à [Téléchargement de drivers NVIDIA](https://www.nvidia.com/Download/index.aspx) 2. Choisir: - Type de produit: **RTX/Quadro** - Série de produits: **RTX Axxxx Series** - Produit: **RTX A4000** - Système d'exploitation: **Windows 11** (ou votre version) - Type de téléchargement: **Utilisateur de Studio** (plus stable que Game ReadyM SK1 3. Installer et redémarrer 4. Vérifier de nouveau avec `nvidia-smi` ## Étape 2: Trousse d'outils CUDA CUDA fournit l'interface de programmation pour accélération GPU. ### Selection de la version **Critique**: Nous avons besoin [CUDA](https://developer.nvidia.com/cuda-toolkit) 12.x pour les modèles modernesM SK1 Spécifiquement: - **CUDA 12.1+** - Bon équilibre entre la compatibilité et les fonctionnalités au moment de l’écriture - **12.x** - Vérifiez la compatibilité avec vos bibliothèques - **NON CUDA 11.x** - Faits manquants dont les nouveaux modèles ont besoin ### Télécharger & Installer 1. Envoyer à [Archives de la trousse d'outils CUDA](https://developer.nvidia.com/cuda-toolkit-archive) 2. Sélectionner **Trousse d'outils CUDA 12.1** (ou 12.3 si vous êtes adventueux 3. Choisissez: **Windows → xM SK1 → | | 11 \ → exécution** 4. Télécharger (~3GB) ### Options d'installation Lancer l'installateur. Lorsque l'on lui demande de le faire: ``` Installation Type: Custom (Advanced) Select Components: ✅ CUDA Toolkit ✅ CUDA Documentation ✅ CUDA Samples ✅ CUDA Visual Studio Integration ❌ GeForce Experience (not needed) ❌ NVIDIA Driver (already installed) ``` **Pourquoi Custom?**: Nous ne voulons pas downgrader notre pilote ou installer un logiciel de jeux. ### Voie d'installation Le chemin par défaut est fine: ``` C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1 ``` Mais notez ce qui suit : - nous ' devrons l’utiliser pour les variables environnementales! ### Établir les variables environnementales L'installateur fixe habituellement ces valeurs, mais vérifie: **Vérifier dans PowerShell**: ```powershell $env:CUDA_PATH # Should show: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1 $env:PATH -split ';' | Select-String CUDA # Should show CUDA bin and libnvvp paths ``` **Si vous manquez, ajouter manuellement**: 1. Ouverture **Variables environnementales**: - A droite-cliquer `This PC` → Propriétés → Établissements avancés du système → Variables environnementales 2. Sous **Variables du système**, vérifierM SK1ajouter: - `CUDA_PATH` = `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1` - `CUDA_PATH_V12_1` = `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1` 3. À l'intérieur `Path` variable, s’assurer qu’elles existent: ``` C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp ``` 4. **Restartez votre terminal** pour que les changements prennent effet ### Vérifier l'installation de CUDA ```powershell # Check CUDA compiler nvcc --version # Should output: # nvcc: NVIDIA (R) Cuda compiler driver # Copyright (c) 2005-2023 NVIDIA Corporation # Built on Tue_Feb__7_19:32:13_Pacific_Standard_Time_2023 # Cuda compilation tools, release 12.1, V12.1.66 ``` ```powershell # Check path resolves where.exe nvcc # Should show: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\nvcc.exe ``` ## Étape 3: cuDNN (CUDA Bibliothèque du Réseau neuronal profond cuDNN offre une mise en œuvre optimisée des opérations d’apprentissage approfondi. ### Version Compatibilité **Critique**: [Numéro du dossier :](https://developer.nvidia.com/cudnn) version doit correspondre à la version CUDA! Pour **CUDA 12.x**, nous avons besoin **8.9+** pour le CUDA 12.x (au moment de la rédaction, 8.9.7 ou plus tardM SK4 ### Télécharger cuDNN 1. Envoyer à [Archives de cuDNN](https://developer.nvidia.com/rdp/cudnn-archive) 2. Vous 'Vous aurez besoin d'un compte de développeur NVIDIA. 3. Trouver: **Télécharger cuDNN v8.9.7 M SK1décembre 5th, ≥2023), pour CUDA 12.x** 4. Choisir: **Installateur local pour Windows (Zip)** 5. Télécharger (~800MB) ### Extraire et installer cuDNN cuDNN est simplement un ensemble de fichiers que vous copiez dans votre installation CUDA. **Extraire le ZIP**, vous 'vous verrezM SK2 ``` cudnn-windows-x86_64-8.9.7.29_cuda12-archive\ bin\ cudnn64_8.dll cudnn_adv_infer64_8.dll cudnn_adv_train64_8.dll ... (more DLLs) include\ cudnn.h ... (header files) lib\ x64\ cudnn.lib ... (lib files) ``` **Copie des fichiers à l'installation CUDA**: ```powershell # Assuming you extracted to Downloads and CUDA is in default location # Run PowerShell as Administrator $cudnnPath = "$env:USERPROFILE\Downloads\cudnn-windows-x86_64-8.9.7.29_cuda12-archive" $cudaPath = "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1" # Copy DLLs Copy-Item "$cudnnPath\bin\*.dll" -Destination "$cudaPath\bin\" # Copy headers Copy-Item "$cudnnPath\include\*.h" -Destination "$cudaPath\include\" # Copy libs Copy-Item "$cudnnPath\lib\x64\*.lib" -Destination "$cudaPath\lib\x64\" ``` **Ou le faire manuellement.**: 1. Copie de tous les fichiers `bin\` à `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\` 2. Copie de tous les fichiers `include\` à `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\` 3. Copie de tous les fichiers `lib\x64\` à `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\` ### Vérifier l'installation de cuDNN ```powershell # Check DLLs exist Test-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\cudnn64_8.dll" # Should return: True # List all cuDNN DLLs Get-ChildItem "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\cudnn*.dll" ``` ## Étape 4: Verification complète Nous devons veiller à ce que tout fonctionne ensemble. ### Évaluation du matériel ```powershell nvidia-smi ``` Il faut montrer votre GPU sans erreurs. ### Examen de la CUDA ```powershell nvcc --version ``` Il faut afficher CUDA 12.1 (ou quelle que soit la version que vous avez installée. ### Vérifier les variables du système ```powershell # All these should return paths $env:CUDA_PATH $env:CUDA_PATH_V12_1 # Check PATH includes CUDA bin $env:PATH -split ';' | Select-String CUDA ``` ### Examen des échantillons de CUDA (Optionnel mais recommandé) La trousse d’outils CUDA comprend des programmes échantillonnés. Let's compiler et exécuter un **Naviger aux échantillons**: ```powershell cd "C:\ProgramData\NVIDIA Corporation\CUDA Samples\v12.1" ``` **Trouver un appareil**: ```powershell cd "1_Utilities\deviceQuery" ``` **Compiler** (exige un studio visuel): ```powershell # If you have VS 2022 "C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\MSBuild.exe" deviceQuery_vs2022.vcxproj /p:Configuration=Release /p:Platform=x64 ``` **Faites-le courir**: ```powershell .\x64\Release\deviceQuery.exe ``` Vous devriez voir une sortie comme: ``` CUDA Device Query (Runtime API) version (CUDART static linking) Detected 1 CUDA Capable device(s) Device 0: "NVIDIA RTX A4000" CUDA Driver Version / Runtime Version 12.3 / 12.1 CUDA Capability Major/Minor version number: 8.6 Total amount of global memory: 16376 MBytes (17174683648 bytes) (048) Multiprocessors, (128) CUDA Cores/MP: 6144 CUDA Cores GPU Max Clock rate: 1560 MHz (1.56 GHz) Memory Clock rate: 7001 Mhz Memory Bus Width: 256-bit L2 Cache Size: 4194304 bytes ... Result = PASS ``` **La ligne clé**: `Result = PASS` Si vous voyez ce qui suit, votre GPU + CUDA + le stack cuDNN est en train de fonctionner ## Étape 5: Essai à partir de CM SK1 Maintenant, la partie amusante - permet aux 's d’utiliser en fait le CUDA de C#! ### Créer un projet d'essai ```bash mkdir CudaTest cd CudaTest dotnet new console -n CudaTest cd CudaTest ``` ### Ajouter ONNX Runtime avec CUDA [Le temps de fonctionnement d'ONNX](https://onnxruntime.ai/) est la façon la plus facile d'utiliser CUDA à partir de C#. ```bash dotnet add package Microsoft.ML.OnnxRuntime.Gpu # Latest version ``` **Pourquoi ce paquet?** - `Microsoft.ML.OnnxRuntime` - CPU seulement - `Microsoft.ML.OnnxRuntime.Gpu` - Comprend le soutien CUDA ### Code d'essai: Détection GPU Créer `Program.cs`: ```csharp using Microsoft.ML.OnnxRuntime; using System; using System.Linq; namespace CudaTest { class Program { static void Main(string[] args) { Console.WriteLine("=== CUDA Test from C# ===\n"); // Test 1: Can we create a CUDA execution provider? Console.WriteLine("Test 1: CUDA Execution Provider"); try { var cudaProviderOptions = new OrtCUDAProviderOptions(); var sessionOptions = new SessionOptions(); sessionOptions.AppendExecutionProvider_CUDA(cudaProviderOptions); Console.WriteLine("✅ CUDA execution provider created successfully"); Console.WriteLine($" Device ID: {cudaProviderOptions.DeviceId}"); } catch (Exception ex) { Console.WriteLine($"❌ Failed to create CUDA provider: {ex.Message}"); return; } // Test 2: Check available providers Console.WriteLine("\nTest 2: Available Execution Providers"); var providers = OrtEnv.Instance().GetAvailableProviders(); foreach (var provider in providers) { Console.WriteLine($" - {provider}"); } if (providers.Contains("CUDAExecutionProvider")) { Console.WriteLine("✅ CUDA provider is available"); } else { Console.WriteLine("❌ CUDA provider NOT available"); } // Test 3: Get CUDA device count and info Console.WriteLine("\nTest 3: CUDA Device Information"); try { // ONNX Runtime doesn't expose deviceQuery directly, // but we can test by trying to create a session var opts = new SessionOptions(); opts.AppendExecutionProvider_CUDA(0); // Device 0 Console.WriteLine("✅ Successfully configured for CUDA device 0"); Console.WriteLine(" (Full device info requires native CUDA calls)"); } catch (Exception ex) { Console.WriteLine($"❌ CUDA device configuration failed: {ex.Message}"); } Console.WriteLine("\n=== Test Complete ==="); } } } ``` **Répartition des codes**: 1. **Options de l'ortCUDAProvider** - Configure l'exécution de CUDA - `DeviceId` - Quel GPU utiliser (0 pour le premier GPU) - Peut fixer des limites de mémoire, niveau d'optimisation, etcM SK2 2. **SessionOptions.AppendExecutionProviderM SK1CUDA()** - Dite à l'ONNX Runtime d'utiliser GPU - Si cela réussit, CUDA fonctionne - Si ce n'est pas le cas, quelque chose dans la pile est défectueux 3. **OrtEnv.Instance().GetAvailableProvidersM SK2** - Liste tous les fournisseurs d'exécution disponibles - Il faut inclure "CUDAExecutionProvider" si tout est installé correctement - Indique également "CPUExecutionProvider" en tant que rappel ### Faire l'essai ```bash dotnet run ``` **Résultats attendus**: ``` === CUDA Test from C# === Test 1: CUDA Execution Provider ✅ CUDA execution provider created successfully Device ID: 0 Test 2: Available Execution Providers - CUDAExecutionProvider - CPUExecutionProvider ✅ CUDA provider is available Test 3: CUDA Device Information ✅ Successfully configured for CUDA device 0 (Full device info requires native CUDA calls) === Test Complete === ``` ### Troubleshooting Common Errors #### Erreur: M SK1DllNotFoundException: Incapable de charger DLL 'onnxruntimeMSC4 **Cause**: ONNX Runtime ne peut 't find CUDA DLLs. **Fixer**: ```powershell # Make sure CUDA bin is in PATH $env:PATH += ";C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin" # Verify cudnn DLL exists Test-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\cudnn64_8.dll" # Try running again dotnet run ``` #### Erreur: M SK1CUDAExecutionProvider non trouvé" **Cause**: Utilisation incorrecte du paquet de temps d'exécution ONNX (CPUM SK2seulement). **Fixer**: ```bash dotnet remove package Microsoft.ML.OnnxRuntime dotnet add package Microsoft.ML.OnnxRuntime.Gpu --version 1.16.3 ``` #### Erreur: "Code d'erreur de la CUDAM SK2 | | 35 \ (La version du pilote de CUDA est insuffisante )" **Cause**: Le conducteur est trop vieux pour le CUDA **Fixer**: Mettre à jour le driver NVIDIA pour 545.xx ou plus récent. ## Essai avancé: Inférence réelle Let's faire quelque chose de réel - exploiter un petit réseau neuronal sur GPU vs CPU et comparer les vitesses. ### Télécharger un modèle d'essai Nous utilisons un modèle de reconnaissance numérique simple du MNIST : ```powershell # Download sample model Invoke-WebRequest -Uri "https://github.com/onnx/models/raw/main/vision/classification/mnist/model/mnist-8.onnx" -OutFile "mnist.onnx" ``` ### Code d'essai de l'inférence Mise à jour `Program.cs`: ```csharp using Microsoft.ML.OnnxRuntime; using Microsoft.ML.OnnxRuntime.Tensors; using System; using System.Diagnostics; using System.Linq; namespace CudaTest { class Program { static void Main(string[] args) { Console.WriteLine("=== GPU vs CPU Inference Test ===\n"); // Create dummy input (28x28 image flattened to 784 floats) var inputData = Enumerable.Range(0, 784).Select(i => (float)i / 784).ToArray(); var tensor = new DenseTensor(inputData, new[] { 1, 1, 28, 28 }); var inputs = new List { NamedOnnxValue.CreateFromTensor("Input3", tensor) }; // Test 1: CPU Inference Console.WriteLine("Test 1: CPU Inference"); var cpuTime = TestInference(inputs, useCuda: false, iterations: 100); Console.WriteLine($" Average time: {cpuTime:F2}ms\n"); // Test 2: GPU Inference Console.WriteLine("Test 2: GPU Inference"); var gpuTime = TestInference(inputs, useCuda: true, iterations: 100); Console.WriteLine($" Average time: {gpuTime:F2}ms\n"); // Compare Console.WriteLine("Comparison:"); Console.WriteLine($" CPU: {cpuTime:F2}ms"); Console.WriteLine($" GPU: {gpuTime:F2}ms"); Console.WriteLine($" Speedup: {cpuTime / gpuTime:F2}x faster on GPU"); } static double TestInference(List inputs, bool useCuda, int iterations) { var options = new SessionOptions(); if (useCuda) { options.AppendExecutionProvider_CUDA(0); } using var session = new InferenceSession("mnist.onnx", options); // Warmup run (first run is always slower) session.Run(inputs); // Timed runs var sw = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { using var results = session.Run(inputs); // Force evaluation var output = results.First().AsEnumerable().ToArray(); } sw.Stop(); return sw.Elapsed.TotalMilliseconds / iterations; } } } ``` **Explanation du code**: 1. **Tensor dense** Le mode de représentation des tableaux multidimensionnels - Formation `[1, 1, 28, 28]` = lotM SK1 taille =1, canaux=1, hauteurMNK4 largeurMZK5 2. **NomméOnnxValue** - Bind un tensor à un nom d'entrée - "Input3" est le nom d'entrée du modèle MNIST 3. **Démarrage à chaud** - La première inférence est toujours plus lente. - Nous courons une fois avant le moment pour obtenir des mesures exactes 4. **Méthode de mise en oeuvre** - Moyenne par rapport à 100 itérations pour des résultats stables ### Faire l'essai de performance ```bash dotnet run ``` **Résultats attendus** ( Vos chiffres varient ): ``` === GPU vs CPU Inference Test === Test 1: CPU Inference Average time: 0.42ms Test 2: GPU Inference Average time: 0.15ms Comparison: CPU: 0.42ms GPU: 0.15ms Speedup: 2.80x faster on GPU ``` **Pourquoi un tel petit ralentissement?** - MNIST est petit (seulement 100modèle de KBM SK2 - Les frais généraux de transfert des données GPU dominent - Pour les modèles plus gros (1GBM SK1 vous ' voyez ### Retour à la clé Nous' avons prouvé que l’ensemble du cheminement fonctionne : ✅ Utilisateur correctement installé ✅ Trousse d'outils CUDA accessible ✅ cuDNN intégré ✅ ONNX Runtime trouve CUDA ✅ CM SK1 peut exécuter une inference accélérée GPU- ## Comprendre le rendement ### Soudan du transfert de la mémoire Voici ce qui se passe lors de la détermination. ```mermaid sequenceDiagram participant App as C# Application participant CPU as CPU Memory participant GPU as GPU Memory participant Compute as GPU Cores App->>CPU: Create input tensor CPU->>GPU: Transfer input (PCIe) Note over GPU: Slow! ~16GB/s GPU->>Compute: Execute model Note over Compute: Fast! TFLOPS Compute->>GPU: Write output GPU->>CPU: Transfer output (PCIe) Note over GPU: Slow again! CPU->>App: Return results ``` **Leçons sur le rendement**: 1. **Traitement par lots** - Transférer plusieurs intrants à la fois pour amortir les frais généraux 2. **Garder les données sur GPU** - Opérations de chaîne pour éviter les transferts 3. **Les modèles plus grands profitent davantage** - Coût de transfert fixe, calcul d'échelle ### Quand utiliser GPU vs CPU ```mermaid graph TD A[Inference Request] --> B{Model Size} B -->|< 100MB| C{Batch Size} B -->|> 100MB| D[Use GPU] C -->|Single Item| E[Use CPU] C -->|Batch > 10| D D --> F[10-100x Faster] E --> G[Lower Latency for Single] class D,E choice classDef choice stroke:#333,stroke-width:2px ``` **Règle de la poignée**: - **GPU** - Modèles de grande envergure , Traitement par lot, Génie d'incorporation - **CPU** - Modèles petits, Demandes uniques , latenceM SK3 critique Pour notre assistant de rédaction du blog: - **Embeddings** - Processus par lots 100+ tronçons GPU - **Inférence LLM** - Modèle grand (7B params) → GPU - **Recherche par vecteur** - dépend du choix de la base de données , souvent CPUM SK2 lié ## Résumé Nous' avons réussi: 1. ✅ Utilisateur NVIDIA installé (545.xx+) 2. ✅ Trousse d'outils CUDA installée 12.1 3. ✅ cuDNN intégré 8.9.7 4. ✅ Vérifié avec `nvidia-smi` et `nvcc` 5. ✅ Accès GPU testé à partir de C# avec ONNX Runtime 6. ✅ Comparaison des performances de ran (GPU vs CPU) Notre environnement de développement est maintenant prêt pour les charges de travail d’AI! ## Qu’est-ce que's Suivant? À l'intérieur **Partie 3**, nous ' nous plongons dans les bases de données d’embeddings et de vecteurs - Qu'est-ce que les embeddings et comment ils permettent la recherche sémantique? - Choix entre Qdrant, pgvector, et autres options - Gérer des embeddings localement avec ONNX Runtime - Stockage et recherche efficaces de millions de vecteurs - Élaborer notre premier prototype de recherche sémantique Nous ' commencerons enfin à travailler avec le contenu réel du blog et à voir RAG en action ! ## Référence sur la résolution des problèmes ### Commandes rapides de diagnostic ```powershell # Check GPU nvidia-smi # Check CUDA nvcc --version where.exe nvcc # Check cuDNN Test-Path "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\cudnn64_8.dll" # Check environment $env:CUDA_PATH $env:PATH -split ';' | Select-String CUDA # Test from C# dotnet run ``` ### Questions communes | Erreur | Cause | Réparer M| |-------|-------|-----| | `nvidia-smi` n'a pas été trouvé | Driver not installed | Installer le driver NVIDIA | | `nvcc` non trouvé | CUDA n'est pas dans le PATH | Ajouter un fichier de CUDA au PATH | La charge de DLL a échoué | CuDNN manquant | Copie des fichiers cuDNN à CUDA dir | Fournisseur de CUDA non trouvé | Trouble dans le paquet NuGet ≥| Usage `Microsoft.ML.OnnxRuntime.Gpu` | | Version de pilote insuffisante | Ancien pilote | Mise à jour à M545.xx+ P| ### Version Matrice de compatibilité | Version CUDA | version cuDNN | Runtime ONNX M| Driver Required P| |--------------|---------------|--------------|-----------------| | 12.1 ≥| ≤8.9.7 | 1.16. x MSC6 MSC7 xx SMC8 | 12.3 ≥| ≤9.0.0 | 1.17. x MSC6 MSC7 xx SMC8 | 11.8 ≥| ≤8.9.2 | 1.15. x MSC6 MSC7 xx SMC8 ## Navigation des séries - [Partie 1: Introduction & Architecture](/blog/building-a-lawyer-gpt-for-your-blog-part1) - **Partie 2: Établissement d'un GPU & CUDA en C#** (le présent articleM SK1 - [Partie 3: Comprendre les emplacements & Bases de données vectorielles](/blog/building-a-lawyer-gpt-for-your-blog-part3) - [Partie 4: Établissement du pipeline d’ingestion](/blog/building-a-lawyer-gpt-for-your-blog-part4) - [Partie 5: Le client Windows](/blog/building-a-lawyer-gpt-for-your-blog-part5) - [Partie 6: Intégration locale de LLM](/blog/building-a-lawyer-gpt-for-your-blog-part6) - [Partie 7: Production de contenu & Génie rapide](/blog/building-a-lawyer-gpt-for-your-blog-part7) - [Partie 8: Faits avancés & Déploiement de la production](/blog/building-a-lawyer-gpt-for-your-blog-part8) ## Ressources - [Documentation de la trousse d'outils CUDA](https://docs.nvidia.com/cuda/) - [Documentation cuDNN](https://docs.nvidia.com/deeplearning/cudnn/api/index.html) - [OnNX Runtime GPU Execution Provider](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html) - [Zone des développeurs NVIDIA](https://developer.nvidia.com/) Nous vous ferons plaisir. [Partie 3](/blog/building-a-lawyer-gpt-for-your-blog-part3), où nous commençons enfin à construire le moteur de recherche sémantique