Back to "Établissement d'un "Lawyer GPT" pour votre blog - Partie 2: Installation de GPU CUDA en CM SK5"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

# Établissement d'un "Lawyer GPT" pour votre blog - Partie 2: Installation de GPU CUDA en CM SK5

<datetime class="hidden">2025-11-12T22:45</datetime>

## 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:

**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<float>(inputData, new[] { 1, 1, 28, 28 });
            var inputs = new List<NamedOnnxValue>
            {
                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<NamedOnnxValue> 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<float>().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

This is a preview from the server running through my markdig pipeline

AI AI-Article C# CUDA GPU LLM mostlylucid.blogllm

Établissement d'un "Lawyer GPT" pour votre blog - Partie 2: Installation de GPU CUDA en CM SK5

Wednesday, 12 November 2025

Introduction

Bienvenue à la partie 2! Partie 1, 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, 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 : installations. NousM SK1Nous le ferons dès le départ.

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

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:

Parallèle - Les GPU ont des milliers de noyaux par rapport aux CPUs
Opérations de matrice - L’AI est essentiellement mathématique de matrices , dont les GPUs excellent
largeur de bande de mémoire - Les GPUs déplacent les données beaucoup plus rapidement
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 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:

La maturité des écosystèmes: CUDA a 15+ années d’optimisation pour les LLM
LLamaSharp: Utilise llama.cpp qui cible CUDA /CPUM SK3 non DirectMLMSC4NPU
Rendement: Une gamme moyenne de GPU NVIDIA surpasse encore significativement les NPU pour notre charge de travail
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:

# 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:

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.

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:

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

Envoyer à Téléchargement de drivers NVIDIA
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
Installer et redémarrer
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 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

Envoyer à Archives de la trousse d'outils CUDA
Sélectionner Trousse d'outils CUDA 12.1 (ou 12.3 si vous êtes adventueux
Choisissez: Windows → xM SK1 → | | 11 \ → exécution
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:

$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:

Ouverture Variables environnementales:
- A droite-cliquer This PC → Propriétés → Établissements avancés du système → Variables environnementales
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

À 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

Restartez votre terminal pour que les changements prennent effet

Vérifier l'installation de CUDA

# 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

# 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 : 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

Envoyer à Archives de cuDNN
Vous 'Vous aurez besoin d'un compte de développeur NVIDIA.
Trouver: Télécharger cuDNN v8.9.7 M SK1décembre 5th, ≥2023), pour CUDA 12.x
Choisir: Installateur local pour Windows (Zip)
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:

# 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.:

Copie de tous les fichiers bin\ à C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\
Copie de tous les fichiers include\ à C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\
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

# 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

nvidia-smi

Il faut montrer votre GPU sans erreurs.

Examen de la CUDA

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

# 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:

cd "C:\ProgramData\NVIDIA Corporation\CUDA Samples\v12.1"

Trouver un appareil:

cd "1_Utilities\deviceQuery"

Compiler (exige un studio visuel):

# 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:

.\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

mkdir CudaTest
cd CudaTest
dotnet new console -n CudaTest
cd CudaTest

Ajouter ONNX Runtime avec CUDA

Le temps de fonctionnement d'ONNX est la façon la plus facile d'utiliser CUDA à partir de C#.

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:

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:

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
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
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

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:

# 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:

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 :

# 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:

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<float>(inputData, new[] { 1, 1, 28, 28 });
            var inputs = new List<NamedOnnxValue>
            {
                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<NamedOnnxValue> 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<float>().ToArray();
            }

            sw.Stop();

            return sw.Elapsed.TotalMilliseconds / iterations;
        }
    }
}

Explanation du code:

Tensor dense Le mode de représentation des tableaux multidimensionnels
- Formation [1, 1, 28, 28] = lotM SK1 taille =1, canaux=1, hauteurMNK4 largeurMZK5
NomméOnnxValue - Bind un tensor à un nom d'entrée
- "Input3" est le nom d'entrée du modèle MNIST
Démarrage à chaud - La première inférence est toujours plus lente.
- Nous courons une fois avant le moment pour obtenir des mesures exactes
Méthode de mise en oeuvre - Moyenne par rapport à 100 itérations pour des résultats stables

Faire l'essai de performance

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.

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:

Traitement par lots - Transférer plusieurs intrants à la fois pour amortir les frais généraux
Garder les données sur GPU - Opérations de chaîne pour éviter les transferts
Les modèles plus grands profitent davantage - Coût de transfert fixe, calcul d'échelle

Quand utiliser GPU vs CPU

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:

✅ Utilisateur NVIDIA installé (545.xx+)
✅ Trousse d'outils CUDA installée 12.1
✅ cuDNN intégré 8.9.7
✅ Vérifié avec nvidia-smi et nvcc
✅ Accès GPU testé à partir de C# avec ONNX Runtime
✅ 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

# 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
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

Partie 1: Introduction & Architecture
Partie 2: Établissement d'un GPU & CUDA en C# (le présent articleM SK1
Partie 3: Comprendre les emplacements & Bases de données vectorielles
Partie 4: Établissement du pipeline d’ingestion
Partie 5: Le client Windows
Partie 6: Intégration locale de LLM
Partie 7: Production de contenu & Génie rapide
Partie 8: Faits avancés & Déploiement de la production

Ressources

Nous vous ferons plaisir. Partie 3, où nous commençons enfin à construire le moteur de recherche sémantique