# Construire un "avocat GPT" pour votre blog - Partie 2: GPU Setup & CUDA en C#

<!--category-- AI, LLM, CUDA, C#, GPU, AI-Article, mostlylucid.blogllm -->
<datetime class="hidden">2025-11-12T22:45</datetime>

> AVERTISSEMENT: CES PROJETS DE POSTES QUI 'ESCAPÉ'.

Il est probable qu'une grande partie de ce qui est ci-dessous ne fonctionnera pas; je les génère comme comment faire pour MOI, puis faire toutes les étapes et obtenir le travail de l'application d'échantillon ... Vous avez été sournois et les a vus! ils seront probablement prêts à la mi-décembre.

<img src="https://media1.tenor.com/m/_rQc7PIEqwQAAAAd/cat-hello-cat-peek.gif" height="300px" />
## Présentation

Bienvenue dans la deuxième partie![Dans](/blog/building-a-lawyer-gpt-for-your-blog-part1)Première partie

> , nous avons exposé la vision pour construire un assistant d'écriture qui utilise votre blog comme base de connaissances - comme la façon dont les avocats utilisent les LLM formés sur la jurisprudence pour rédiger des documents.

**Maintenant, il est temps de se salir les mains avec la fondation: s'assurer que votre GPU est prêt pour les charges de travail d'IA.**REMARQUE: Ceci fait partie de mes expériences avec l'IA (couture assistée) + mon propre montage.

Même voix, même pragmatisme, juste des doigts plus rapides.[À propos de mon matériel](https://developer.nvidia.com/cuda-toolkit): J'utilise un NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X et 96GB DDR5 RAM.[Mais tu n'as pas besoin de ça !](https://developer.nvidia.com/cudnn)Comme couvert dans la partie 1, vous pouvez utiliser n'importe quel GPU NVIDIA avec 8 Go + VRAM, ou même exécuter CPU-seulement (inférieur mais fonctionnel).

[TOC]

## Cette partie se concentre sur la configuration GPU, mais je noterai les alternatives CPU seulement le cas échéant.

Cette partie pourrait sembler basique si vous êtes déjà familier avec

### CUDA

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

**, mais croyez-moi - J'ai gaspillé d'innombrables heures à déboguer des erreurs mystérieuses qui remontaient à des erreurs de version, des variables d'environnement manquantes, ou incorrectes**:

1. **CUDNN**les installations.
2. **Nous le ferons dès le début.**Pourquoi l'accélération du GPU compte-t-elle?
3. **Avant de plonger dans l'installation, comprenons pourquoi nous avons besoin d'accélération GPU du tout.**CPU vs GPU pour les charges de travail AI
4. **Pourquoi les GPU dominent pour l'IA**Parallélisme

**- Les GPU ont des milliers de cœurs contre des dizaines de CPU**Opérations matricielles

- **- L'IA est principalement matricielle, qui GPUs excelle à**Bande passante de la mémoire
- **- Les GPU déplacent les données beaucoup plus vite**Matériel spécialisé

- Les cœurs de tension accélèrent les opérations spécifiques à l'IA

**Exemple du monde réel**(sur mon matériel): Génération d'intégrations pour un billet de blog:

- **CPU (Ryzen 9 9950X)**: ~5 secondes par poste
- **GPU (A4000 16 Go)**: ~0.3 secondes par poste
- **C'est 16x plus rapide, et il se compose lors du traitement de centaines de postes!**Performance sur d'autres GPU
- (approximation):

## NT1 organisation commune de marché NT1 organisation commune de marché NT1 organisation commune de marché NT1 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché NT2 organisation commune de marché

(24 Go): Plus rapide, ~0.2s par poste

### NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT

(12GB): ~0,5s par poste

- **GTX 1070 Ti**(8GB): ~0,8s par poste
- **Encore beaucoup plus rapide que CPU!**Comprendre votre matériel
- **Avant d'installer quoi que ce soit, comprenons avec quoi nous travaillons.**Mon GPU: NVIDIA RTX A4000
- **Ceci est mon GPU spécifique - une carte de poste de travail professionnel avec:**16 Go GDDR6 VRAM

### - Assez pour les modèles de paramètres 7B-13B

6144 Noyaux CUDA

- Puissance de traitement parallèle
|-----|------|----------------|----------|
256 Noyaux de tension
- Accélération des opérations d'IA
Capacité de calcul CUDA 8.6
- Important pour la compatibilité
Options communes de GPU
Voici ce que les différents GPU peuvent gérer :

### GRAPHIQUE VRAMIQUE Taille maximale du modèle

RTX 4090: 24GB: 13B-30B: Surkill pour ce projet:**RTX 4070 Ti 12GB 7B-13B Excellent choix**

**RTX 3060:00 12GB:00 7B:00 Bon budget-friendly**RTX 4060 Tio: 16GB: 7B-13B: Grande valeur

*** A4000 (mine) * 16 Go * 7B-13B * Poste de travail * GPU ***:

- **GTX 1070 Ti=8GB=7B (étanchéité)= Minimum viable=**Qu'en est-il des NPU Intel/AMD?
- **Vous avez peut-être entendu parler de puces Intel Core Ultra ou AMD Ryzen AI avec des processeurs NPU intégrés (Unités de Traitement Neural).**Pouvez-vous les utiliser au lieu de NVIDIA ?
- **Réponse courte**: Pas encore, mais peut-être en 2024-2025 !
- **Limites actuelles**Pas de CUDA

**: Les NPU ne prennent pas en charge CUDA, que ce tutoriel utilise**:

- Soutien limité en .NET
- : Le support NPU d'ONNX Runtime est expérimental[Compatibilité du modèle](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html): La plupart des modèles GGUF ciblent CUDA/CPU
- Appui direct au ML

: Toujours en phase de maturation pour les LLM**Si vous avez un processeur équipé de NPU**Utilisez le mode CPU seulement pour l'instant (tout fonctionne, juste plus lentement)

### Veillez à ce qu'il n'y ait pas de

ONNX Runtime DirectML

```bash
# PowerShell
wmic path win32_VideoController get name
```

mises à jour

```
Name
NVIDIA RTX A4000
```

Les parties futures noteront quand le soutien NPU s'améliorera

### Cette série met l'accent sur

NVIDIA CUDA

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

**parce qu'il est mature et bien soutenu dans .NET, mais les concepts se traduiront par les NPU une fois l'écosystème rattrapé !**:

- **Vérifiez votre GPU**Tout d'abord, vérifiez que Windows voit votre GPU:
- **Vous devriez voir quelque chose comme:**Ou utilisez le panneau de configuration NVIDIA → Informations système → Afficher l'onglet.
- **Vue d'ensemble de l'architecture**Voici comment fonctionne la pile logicielle:
- **Ventilation par couche**Pilote NVIDIA
- **- Communication GPU de bas niveau**Boîte à outils CUDA

## - API pour la programmation GPU

CUDNN

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

## - Deep Neural Network bibliothèque (cerneaux optimisés)

### ONNX Durée d'exécution / LLamaSharp

- Cadres de gestion de haut niveau

```bash
nvidia-smi
```

Votre demande

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

**- Notre code C#**:

- `Driver Version`Feuille de route pour l'installation
- `CUDA Version`Voici l'ordre que nous allons installer des choses (l'ordre compte!):
- `Memory-Usage`Étape 1: Pilote NVIDIA

### Vérifiez le pilote actuel

Ouvrez PowerShell :`nvidia-smi`Vous devriez voir la sortie comme :

1. Informations clés[: devrait être 545.xx ou plus récent](https://www.nvidia.com/Download/index.aspx)

2. : C'est la version MAX CUDA prise en charge, pas ce qui est installé
   
   - : Actuellement utilisé / total VRAM**Mettre à jour le pilote si nécessaire**
   - Si**ne fonctionne pas ou votre chauffeur est vieux:**
   - Allez-y.**Téléchargements du pilote NVIDIA**
   - Sélectionner & #160;:**Type de produit:**NT2 NT2 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1
   - Série de produits :**Série RTX Axxxx**Produit:

3. NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1

4. Système d'exploitation:`nvidia-smi`

## Fenêtres 11

(ou votre version)

### Type de téléchargement:

**Pilote Studio**(plus stable que Game Ready)[Installer et redémarrer](https://developer.nvidia.com/cuda-toolkit)Vérifiez à nouveau avec

- **Étape 2 : Boîte à outils CUDA**CUDA fournit l'interface de programmation pour l'accélération GPU.
- **Sélection de la version**Critique
- **: Nous avons besoin**CUDA

### 12.x pour les modèles modernes.

1. Plus précisément :[CUDA 12.1+](https://developer.nvidia.com/cuda-toolkit-archive)
2. - Bon équilibre de la compatibilité et des fonctionnalités (au moment de l'écriture)**Dernier 12.x**- Vérifier la compatibilité avec vos bibliothèques
3. PAS CUDA 11.x**- Caractéristiques manquantes nouveaux modèles ont besoin**
4. Télécharger et installer

### Allez-y.

Archive de la boîte à outils CUDA

```
Installation Type: Custom (Advanced)

Select Components:
✅ CUDA Toolkit
✅ CUDA Documentation
✅ CUDA Samples
✅ CUDA Visual Studio Integration
❌ GeForce Experience (not needed)
❌ NVIDIA Driver (already installed)
```

**Sélectionner**Boîte à outils CUDA 12.1

### (ou 12.3 si vous êtes aventureux)

Choisissez :

```
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1
```

Windows → x86_64 → 11 → exe (local)

### Téléchargement (~3GB)

Options d'installation

**Exécutez l'installateur.**:

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

**Lorsqu'il est demandé :**:

1. Pourquoi Custom ?**: Nous ne voulons pas dévaloriser notre pilote ou installer un logiciel de jeu.**:
   
   - Voie d'installation`This PC`Le chemin par défaut est bon :

2. Mais notez ceci - nous en aurons besoin pour les variables d'environnement!**Définir les variables d'environnement**L'installateur les définit habituellement, mais vérifie:
   
   - `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. Vérifiez PowerShell`Path`S'il manque, ajouter manuellement
   
   ```
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp
   ```

4. **Ouvrir**Variables d'environnement

### Faites un clic droit

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

## → Propriétés → Paramètres avancés du système → Variables d'environnement

Sous

### Variables du système

**, vérifier/ajouter:**: [Dans](https://developer.nvidia.com/cudnn)Variable, assurez-vous qu'il en existe:

Redémarrez votre terminal**pour les modifications à prendre en vigueur**Vérifier l'installation de CUDA**Étape 3 : cudNN (bibliothèque du réseau neurologique profond de la CUDA)**cuDNN fournit des implémentations optimisées des opérations d'apprentissage profond.

### Compatibilité des versions

1. Critique[CUDNN](https://developer.nvidia.com/rdp/cudnn-archive)
2. version doit correspondre à la version CUDA!
3. Pour**CUDA 12.x**
4. , nous avons besoin**CUDNN 8,9+**
5. pour CUDA 12.x (au moment de l'écriture, 8.9.7 ou plus)

### Télécharger cudNN

Allez-y.

**Archives cudNN**Vous aurez besoin d'un compte NVIDIA Developer (gratuit)

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

**Rechercher :**:

```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\"
```

**Télécharger cuDNN v8.9.7 (5 décembre 2023), pour CUDA 12.x**:

1. Sélectionner & #160;:`bin\`Installateur local pour Windows (Zip)`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\`
2. Téléchargement (~800MB)`include\`Extraire et installer cudNN`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\`
3. cudNN n'est qu'un ensemble de fichiers que vous copiez dans votre installation CUDA.`lib\x64\`Extraire le ZIP`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\`

### , vous verrez :

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

## Copier les fichiers vers l'installation CUDA

Ou faites-le manuellement

### Copier tous les fichiers

```powershell
nvidia-smi
```

à l ' Assemblée générale

### Copier tous les fichiers

```powershell
nvcc --version
```

à l ' Assemblée générale

### Copier tous les fichiers

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

### à l ' Assemblée générale

Vérifier l'installation de cudNN

**Étape 4 : Vérification complète**:

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

**Assurons-nous que tout fonctionne ensemble.**:

```powershell
cd "1_Utilities\deviceQuery"
```

**Vérification du matériel**Doit afficher votre GPU sans erreur.

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

**Vérification CUDA**:

```powershell
.\x64\Release\deviceQuery.exe
```

Doit afficher CUDA 12.1 (ou quelle que soit la version que vous avez installée).

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

**Vérification des variables système**: `Result = PASS`

Essai des échantillons CUDA (facultatif mais recommandé)

## La trousse d'outils CUDA comprend des exemples de programmes.

Compilons et en faisons un.

### Naviguer dans les échantillons

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

### Trouver l'appareilQuery

[Compilez-le.](https://onnxruntime.ai/)(nécessite un studio visuel) :

```bash
dotnet add package Microsoft.ML.OnnxRuntime.Gpu  # Latest version
```

**Exécutez-le.**

- `Microsoft.ML.OnnxRuntime`Vous devriez voir la sortie comme :
- `Microsoft.ML.OnnxRuntime.Gpu`La ligne clé

### Si vous voyez cela, votre pile GPU + CUDA + cudNN fonctionne !

Étape 5 : Essais à partir de C#`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 ===");
        }
    }
}
```

**Maintenant la partie amusante - utilisons en fait CUDA de C#!**:

1. **Créer un projet d'essai**Ajouter ONNX Runtime avec CUDA
   
   - `DeviceId`ONNX Durée d'exécution
   - est la meilleure façon d'utiliser CUDA de C#.

2. **Pourquoi ce paquet ?**- CPU seulement
   
   - - Inclut le soutien de la CUDA
   - Code d'essai : Détection GPU

3. **Créer**Ventilation par code
   
   - OrtCUDAOptions de fourniture
   - - Configure l'exécution CUDA

### - Quel GPU utiliser (0 pour le premier GPU)

```bash
dotnet run
```

**Peut définir les limites de mémoire, le niveau d'optimisation, etc.**:

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

### SessionOptions.AppendExécutionProvider_CUDA()

#### - Indique à ONNX Runtime d'utiliser GPU

**Si cela réussit, CUDA travaille**Si elle échoue, quelque chose dans la pile est cassé

**OrtEnv.Instance().ObtenezDisponibleProvideurs()**:

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

#### - Liste tous les fournisseurs d'exécution disponibles

**Doit inclure "CUDAExecutionProvider" si tout est installé correctement**Affiche également "CPUExecutionProvider" comme retour en arrière

**Exécuter l'essai**:

```bash
dotnet remove package Microsoft.ML.OnnxRuntime
dotnet add package Microsoft.ML.OnnxRuntime.Gpu --version 1.16.3
```

#### Produit escompté

**Dépannage des erreurs courantes**Erreur: "DllNotFoundException: Impossible de charger DLL 'onnxruntime'"

**Cause**: ONNX Runtime ne trouve pas les DLLs CUDA.

## Correction

Erreur : "CUDAExecutionProvider non trouvé"

### Cause

: Utilisation d'un mauvais paquet ONNX Runtime (uniquement CPU).

```powershell
# Download sample model
Invoke-WebRequest -Uri "https://github.com/onnx/models/raw/main/vision/classification/mnist/model/mnist-8.onnx" -OutFile "mnist.onnx"
```

### Correction

Erreur : "Code d'erreur CUDA : 35 (la version du pilote CUDA est insuffisante)"`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;
        }
    }
}
```

**Cause**:

1. **: Le conducteur est trop vieux pour CUDA 12.x.**Correction
   
   - : Mettre à jour le pilote NVIDIA à 545.xx ou plus récent.`[1, 1, 28, 28]`Test avancé : Inférence réelle

2. **Faisons quelque chose de réel - exécutez un petit réseau neuronal sur GPU vs CPU et comparez les vitesses.**Télécharger un modèle d'essai
   
   - Nous utiliserons un modèle de reconnaissance numérique MNIST simple (format ONNX).

3. **Code d'essai d'inférence**Mise à jour
   
   - Explication du code

4. **DenseTeneur**- La manière d'ONNX Runtime de représenter les tableaux multidimensionnels

### Forme

```bash
dotnet run
```

**= batch_size=1, canaux=1, hauteur=28, largeur=28**NomméOnnxValue

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

**- Raccorde un tenseur à un nom d'entrée**

- "Input3" est le nom d'entrée dans le modèle MNIST
- Échauffement
- - La première inférence est toujours plus lente (chargement du modèle, optimisation)

### Nous courons une fois avant le timing pour obtenir des mesures précises

Méthode de calendrier
✅ Driver installed correctly
✅ CUDA Toolkit accessible
✅ cuDNN integrated
✅ ONNX Runtime finds CUDA
✅ C# can run GPU-accelerated inference

## - Moyenne de plus de 100 itérations pour des résultats stables

### Exécuter l ' essai d ' efficacité

Produit escompté

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

**(vos numéros varieront):**:

1. **Pourquoi une si petite accélération ?**MNIST est minuscule (modèle 100Ko seulement)
2. **Le transfert de données GPU domine**Pour les modèles plus grands (1GB+), vous verrez 10-100x speedups
3. **Prise en charge des clés**Nous avons prouvé tout le travail de la pile:

### Compréhension des résultats

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

**Transfert de mémoire goulot d'étranglement**:

- **Voici ce qui se passe pendant l'inférence :**Enseignements de la performance
- **Traitement par lots**- Transférer de nombreux intrants à la fois pour amortir les frais généraux

Conserver les données sur GPU

- **- Opérations en chaîne pour éviter les transferts**Les modèles plus grands bénéficient davantage
- **- Coût de transfert fixe, calcul de l'échelle**Quand utiliser GPU vs CPU
- **Règle du pouce**GPU

## - Grands modèles, traitement par lots, génération d'intégration

CPU

1. ✅ Installed NVIDIA driver (545.xx+)
2. ✅ Installed CUDA Toolkit 12.1
3. ✅ Integrated cuDNN 8.9.7
4. ✅ Verified with `nvidia-smi`- Petits modèles, demandes uniques, latence-critique`nvcc`
5. ✅ Tested GPU access from C# with ONNX Runtime
6. ✅ Ran performance comparison (GPU vs CPU)

Pour notre assistant d'écriture de blog:

## Assemblages

- Procédé par lots de plus de 100 morceaux → GPU**Inférence LLM**- Grand modèle (7B params) → GPU

- Recherche vectorielle
- - Dépend du choix DB, souvent lié au processeur
- Résumé
- Nous avons réussi :
- et

Notre environnement de développement est maintenant prêt pour les charges de travail de l'IA!

## Qu'est-ce qu'il y a ?

### Dans

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

### Troisième partie

, nous plongerons profondément dans les bases de données vectorielles et d'intégration :
|-------|-------|-----|
| `nvidia-smi`Quels sont les éléments d'intégration et comment permettent-ils la recherche sémantique ?
| `nvcc`Choix entre Qdrant, pgvector et d'autres options
Génération d'intégrations locales avec ONNX Runtime
Entreposer et interroger efficacement des millions de vecteurs`Microsoft.ML.OnnxRuntime.Gpu` |
Construire notre premier prototype de recherche sémantique

### Nous allons enfin commencer à travailler avec le contenu réel du blog et voir RAG en action!

Référence de dépannage
|--------------|---------------|--------------|-----------------|
Commandes diagnostiques rapides
Questions communes
Erreur Cause Correction

## Non trouvé Installer le pilote NVIDIA Installer le pilote NVIDIA Installer le pilote NVIDIA Installer le pilote NVIDIA Installer le pilote NVIDIA Installer le pilote NVIDIA Installer le pilote NVIDIA Installer le pilote NVIDIA

- [CUDA non trouvé.CUDA non dans PATH.CUDA ajouter la corbeille CUDA à PATH.CUDA.CUDA non trouvé.CUDA non dans PATH.CUDA ajouté à PATH.CUDA non trouvé.CUDA non trouvé.CUDA non dans PATH.CUDA ajouté à PATH.CUDA non trouvé.CUDA non trouvé.CUDA non dans PATH.CUDA ajouté à PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA ajouté à PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.CUDA non trouvé dans PATH.](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- **La charge DLL a échoué.CuDNN manquant.Copy cuDNN files to CUDA dir.**Le fournisseur de CUDA n'a pas trouvé le mauvais paquet NuGet
- [Mise à jour de la version du pilote insuffisante de l'ancien pilote de 545.xx+](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Matrice de compatibilité de la version](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Version de CUDA Version de cudNN Version de ONNX Durée d'exécution du pilote requis](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [12,1 $ 8,9,7 $ 1,16.x $ 545.xx+ $](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [12.3.0.0.x 546.xx+.](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [11,8 8,8 8,9,2 χ 1.15 xx 520,xx+](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## Navigation des séries

- [Première partie: Introduction et architecture](https://docs.nvidia.com/cuda/)
- [Partie 2: Configuration GPU & CUDA en C#](https://docs.nvidia.com/deeplearning/cudnn/api/index.html)
- [(ce poste)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
- [Partie 3: Compréhension des intégrations et des bases de données vectorielles](https://developer.nvidia.com/)

Partie 4: Construction du pipeline d'ingestion[Partie 5: Le client Windows](/blog/building-a-lawyer-gpt-for-your-blog-part3)Partie 6: Intégration locale des LLM