# Bouwen van een "Lawyer GPT" voor uw blog - Deel 2: GPU Setup & CUDA in C#

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

> WAARSCHUWING: Deze zijn ontwerp-Posts die 'onthuld'.

Het is waarschijnlijk veel van wat hieronder zal niet werken; IK genereren deze als how-to voor MIJ en dan doen alle stappen en krijg de sample app werken...Je bent stiekem en ze gezien! ze zullen waarschijnlijk klaar zijn medio december.

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

Welkom in deel 2![In](/blog/building-a-lawyer-gpt-for-your-blog-part1)Deel 1

> , legden we de visie voor het bouwen van een schrijfassistent die uw blog gebruikt als een kennisbasis - zoals hoe advocaten LLM's gebruiken opgeleid op het gebied van jurisprudentie om documenten te ontwerpen.

**Nu is het tijd om onze handen vuil te maken met de fundering: ervoor zorgen dat je GPU klaar is voor AI workloads.**OPMERKING: Dit maakt deel uit van mijn experimenten met AI (ondersteund opstellen) + mijn eigen bewerking.

Dezelfde stem, hetzelfde pragmatisme, gewoon snellere vingers.[Over mijn hardware](https://developer.nvidia.com/cuda-toolkit): Ik gebruik een NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X en 96GB DDR5 RAM.[Maar je hebt dit niet nodig!](https://developer.nvidia.com/cudnn)Zoals beschreven in deel 1, kunt u elke NVIDIA GPU met 8GB+ VRAM gebruiken, of zelfs CPU-alleen uitvoeren (langzamer maar functioneel).

[TOC]

## Dit deel richt zich op GPU setup, maar ik zal CPU-alleen alternatieven waar relevant op te merken.

Dit deel lijkt misschien basic als je al bekend bent met

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

**, maar geloof me - ik heb ontelbare uren verspild met het debuggen van mysterieuze fouten die terug te voeren naar versie mismatches, ontbrekende omgevingsvariabelen, of onjuist**:

1. **cuDNN**installaties.
2. **We doen dit meteen.**Waarom GPU versnelling belangrijk is
3. **Voordat we in installatie duiken, laten we begrijpen waarom we GPU acceleratie überhaupt nodig hebben.**CPU vs GPU voor AI Workloads
4. **Waarom GPU's domineren voor AI**Parallelisme

**- GPU's hebben duizenden kernen vs. CPU's' tientallen**Matrixbewerkingen

- **- AI is meestal matrix wiskunde, die GPU's blinken uit op**Geheugenbandbreedte
- **- GPU's verplaatsen data veel sneller**Gespecialiseerde hardware

- Tensor kernen versnellen AI-specifieke bewerkingen

**Voorbeeld in de echte wereld**(op mijn hardware): Het genereren van inbeddingen voor een blog post:

- **CPU (Ryzen 9 9950X)**: ~5 seconden per post
- **GPU (A4000 16GB)**: ~0,3 seconden per post
- **Dat is 16x sneller, en het combineert bij het verwerken van honderden posten!**Prestaties op andere GPU's
- (bij benadering):

## RTX 4090

(24GB): Snelste, ~0.2s per post

### RTX 3060

(12GB): ~0,5s per post

- **GTX 1070 Ti**(8GB): ~0,8s per post
- **Nog steeds veel sneller dan CPU!**Uw hardware begrijpen
- **Voordat we iets installeren, laten we begrijpen waar we mee werken.**Mijn GPU: NVIDIA RTX A4000
- **Dit is mijn specifieke GPU - een professionele werkstationkaart met:**16GB GDDR6 VRAM

### - Genoeg voor 7B-13B parameter modellen

6144 CUDA-kernen

- Parallelle verwerkingskracht
|-----|------|----------------|----------|
256 Tensorkernen
- Versnelde AI-operaties
CUDA Bereken vermogen 8.6
- Belangrijk voor compatibiliteit
Gemeenschappelijke GPU-opties
Hier is wat verschillende GPU's aankunnen:

### GPU VRAM Max Model Size  Goed voor 

RTX 4090 24GB 13B-30B Overkill voor dit project**RTX 4070 Ti, 12GB, 7B-13B, Uitstekende keuze.**

**RTX 3060 12GB 7B Budgetvriendelijk*** RTX 4060 Ti * 16GB * 7B-13B * Great value *

**A4000 (mijn) 16GB 7B-13B Werkstation GPU**:

- *** GTX 1070 Ti * 8GB * 7B (tight) * Minimum pairable ***Hoe zit het met Intel/AMD NPU's?
- **Je hebt misschien gehoord over Intel Core Ultra of AMD Ryzen AI chips met ingebouwde NPU's (Neural Processing Units).**Kun je die gebruiken in plaats van NVIDIA?
- **Kort antwoord**: Nog niet, maar misschien in 2024-2025!
- **Huidige beperkingen**Geen CUDA

**: NPU's ondersteunen CUDA niet, die deze tutorial gebruikt**:

- Beperkte .NET-ondersteuning
- : ONNX Runtime's NPU ondersteuning is experimenteel[Modelcompatibiliteit](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html): De meeste GGUF modellen doel CUDA / CPU
- DirectML-ondersteuning

: Nog steeds rijpen voor LLM's**Als u een met NPU uitgeruste CPU heeft**Gebruik CPU-alleen-modus voor nu (alles werkt, gewoon langzamer)

### Kijk uit voor

ONNX Runtime DirectML

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

updates

```
Name
NVIDIA RTX A4000
```

Toekomstige onderdelen zullen merken wanneer NPU-ondersteuning verbetert

### Deze serie richt zich op

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

**want het is volwassen en goed ondersteund in .NET, maar de concepten zullen vertalen naar NPU's zodra het ecosysteem inhaalt!**:

- **Controleer uw GPU**Controleer eerst of Windows uw GPU ziet:
- **Je zou zoiets moeten zien als:**Of gebruik NVIDIA Configuratiescherm → Systeeminformatie → Tabblad weergeven.
- **Overzicht architectuur**Hier is hoe de software stack werkt:
- **Indeling van de lagen**NVIDIA-stuurprogramma
- **- Low-level GPU communicatie**CUDA Toolkit

## - API's voor GPU-programmering

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 bibliotheek (geoptimaliseerde kernels)

### ONNX Runtime / LLamaSharp

- ML-kaders op hoog niveau

```bash
nvidia-smi
```

Uw aanvraag

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

**- Onze C# code.**:

- `Driver Version`Routekaart installeren
- `CUDA Version`Hier is de bestelling die we zullen installeren dingen (order matches!):
- `Memory-Usage`Stap 1: NVIDIA Driver

### Huidige stuurprogramma controleren

Open PowerShell:`nvidia-smi`U zou de uitvoer moeten zien als:

1. Belangrijkste informatie[: Moet 545.xx of nieuwer zijn](https://www.nvidia.com/Download/index.aspx)

2. : Dit is de MAX CUDA versie ondersteund, niet wat geïnstalleerd is
   
   - : Momenteel gebruikt / totaal VRAM**Stuurprogramma bijwerken indien nodig**
   - Als**werkt niet of uw chauffeur is oud:**
   - Ga naar**NVIDIA Driver Downloads**
   - Selecteer:**Productsoort:**RTX/Quadro
   - Productreeks:**RTX Axxxx Series**Product:

3. RTX A4000

4. Besturingssysteem:`nvidia-smi`

## Windows 11

(of uw versie)

### Downloadtype:

**Studio-driver**(meer stabiel dan Game Ready)[Installeren en opnieuw opstarten](https://developer.nvidia.com/cuda-toolkit)Weer controleren met

- **Stap 2: CUDA Toolkit**CUDA biedt de programmeerinterface voor GPU acceleratie.
- **Versieselectie**Kritiek
- **: We moeten**CUDA

### 12.x voor moderne modellen.

1. In het bijzonder:[CUDA 12.1+](https://developer.nvidia.com/cuda-toolkit-archive)
2. - Goede balans van compatibiliteit en kenmerken (op het moment van schrijven)**Laatste 12.x**- Controleer de compatibiliteit met uw bibliotheken
3. NIET CUDA 11.x**- Ontbrekende functies nieuwere modellen nodig**
4. Downloaden & installeren

### Ga naar

CUDA Toolkit Archief

```
Installation Type: Custom (Advanced)

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

**Selecteren**CUDA Toolkit 12.1

### (of 12,3 als je avontuurlijk bent)

Kies:

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

Windows → x86_64 → 11 → exe (lokaal)

### Downloaden (~3GB)

Installatieopties

**Controleer de 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
```

**Wanneer gevraagd:**:

1. Waarom op maat?**: We willen onze driver niet downgraden of gaming software installeren.**:
   
   - Installatiepad`This PC`Standaard pad is prima:

2. Maar let op: we hebben het nodig voor omgevingsvariabelen!**Omgevingsvariabelen instellen**De installateur stelt deze meestal in, maar verifieer:
   
   - `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. Check in PowerShell`Path`Indien ontbreken, handmatig toevoegen
   
   ```
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp
   ```

4. **Openen**Omgevingsvariabelen

### Klik met de rechtermuisknop

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

## → Eigenschappen → Geavanceerde systeeminstellingen → Omgevingsvariabelen

Onder

### Systeemvariabelen

**, verifiëren/toevoegen:**: [In](https://developer.nvidia.com/cudnn)variabele, zorg ervoor dat deze bestaan:

Uw terminal opnieuw opstarten**voor wijzigingen die van kracht worden**CUDA-installatie verifiëren**Stap 3: cuDNN (CUDA Deep Neural Network library)**cuDNN biedt geoptimaliseerde implementaties van deep learning operaties.

### Versiecompatibiliteit

1. Kritiek[cuDNN](https://developer.nvidia.com/rdp/cudnn-archive)
2. versie moet overeenkomen met CUDA versie!
3. Voor**CUDA 12.x**
4. , hebben we nodig**cuDNN 8.9+**
5. voor CUDA 12.x (op het moment van schrijven, 8.9.7 of later)

### CuDNN downloaden

Ga naar

**cuDNN-archief**Je hebt een NVIDIA Ontwikkelaar account nodig (gratis)

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

**Zoeken:**:

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

**Download cuDNN v8.9,7 (5 december 2023), voor CUDA 12.x**:

1. Selecteer:`bin\`Lokale installatie voor Windows (Zip)`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\`
2. Downloaden (~800MB)`include\`Uitpakken en installeren van cuDNN`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\`
3. cuDNN is slechts een set bestanden die je kopieert in je CUDA installatie.`lib\x64\`De ZIP uitpakken`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\`

### , zul je zien:

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

## Bestanden naar CUDA-installatie kopiëren

Of doe het handmatig

### Kopieer alle bestanden van

```powershell
nvidia-smi
```

tot

### Kopieer alle bestanden van

```powershell
nvcc --version
```

tot

### Kopieer alle bestanden van

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

### tot

CuDNN installatie verifiëren

**Stap 4: Volledige verificatie**:

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

**Laten we ervoor zorgen dat alles samen werkt.**:

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

**Hardwarecontrole**Moet uw GPU tonen zonder fouten.

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

**CUDA-controle**:

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

Moet CUDA 12.1 (of welke versie je ook hebt geïnstalleerd) tonen.

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

**Systeemvariabelen Controleren**: `Result = PASS`

CUDA-monsterstest (facultatief, maar aanbevolen)

## De CUDA Toolkit bevat sample programma's.

Laten we er een compileren en uitvoeren.

### Navigeren naar monsters

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

### Apparaat zoekenQuery

[Compileer het](https://onnxruntime.ai/)(vereist Visual Studio):

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

**Voer het uit.**

- `Microsoft.ML.OnnxRuntime`U zou de uitvoer moeten zien als:
- `Microsoft.ML.OnnxRuntime.Gpu`De sleutelregel

### Als je dit ziet, werkt je GPU + CUDA + cuDNN stack!

Stap 5: Testen vanuit 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 ===");
        }
    }
}
```

**Nu het leuke gedeelte - laten we eigenlijk gebruiken CUDA van C#!**:

1. **Testproject aanmaken**ONNX-runtime toevoegen met CUDA
   
   - `DeviceId`ONNX-runtime
   - is de makkelijkste manier om CUDA van C# te gebruiken.

2. **Waarom dit pakketje?**- alleen CPU
   
   - - Inclusief CUDA-ondersteuning
   - Testcode: GPU-detectie

3. **Aanmaken**Opsplitsing van de code
   
   - OrtCUDAProviderOptions
   - - Configureert CUDA-uitvoering

### - Welke GPU te gebruiken (0 voor de eerste GPU)

```bash
dotnet run
```

**Kan geheugenlimieten instellen, optimalisatieniveau, enz.**:

```
=== 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.AppendExecutionProvider_CUDA()

#### - Vertelt ONNX Runtime om GPU te gebruiken

**Als dit lukt, werkt CUDA**Als het mislukt, iets in de stack is gebroken

**OrtEnv.Instance().GetAvailableProviders()**:

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

#### - Lijst met alle beschikbare uitvoerders

**Moet bevatten "CUDAExecutionProvider" als alles correct is geïnstalleerd**Ook toont "CPUExecutionProvider" als terugval

**Voer de test uit.**:

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

#### Verwachte output

**Problemen met het oplossen van gemeenschappelijke fouten**Fout: "DllNotFoundException: kan DLL 'onnxruntime' niet laden"

**Oorzaak**ONNX Runtime kan geen CUDA DLL's vinden.

## Repareren

Fout: "CUDAExecutionProvider niet gevonden"

### Oorzaak

: Gebruik van verkeerde ONNX Runtime pakket (CPU-only).

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

### Repareren

Fout: "CUDA foutcode: 35 (CUDA driver versie is onvoldoende) "`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;
        }
    }
}
```

**Oorzaak**:

1. **: Chauffeur is te oud voor CUDA 12.x.**Repareren
   
   - : Update NVIDIA driver naar 545.xx of nieuwer.`[1, 1, 28, 28]`Geavanceerde test: werkelijke gevolgtrekking

2. **Laten we iets echts doen - run een klein neuraal netwerk op GPU vs CPU en vergelijk snelheden.**Download een testmodel
   
   - We gebruiken een eenvoudig MNIST-digitherkenningsmodel (ONNX-formaat).

3. **Inferentietestcode**Bijwerken
   
   - Code-uitleg

4. **DenseTensor**- ONNX Runtime's manier om multidimensionale arrays te representeren

### Vorm

```bash
dotnet run
```

**= batch_size=1, kanalen=1, hoogte=28, breedte=28**NamedOnnxValue

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

**- Bindt een tensor naar een invoernaam**

- "Input3" is de invoernaam in het MNIST model
- Opwarming
- - Eerste gevolgtrekking is altijd langzamer (modelbelasting, optimalisatie)

### We lopen één keer voor de timing om nauwkeurige metingen te krijgen

Tijdschema
✅ Driver installed correctly
✅ CUDA Toolkit accessible
✅ cuDNN integrated
✅ ONNX Runtime finds CUDA
✅ C# can run GPU-accelerated inference

## - Gemiddelde meer dan 100 iteraties voor stabiele resultaten

### Prestatietest uitvoeren

Verwachte output

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

**(Uw nummers zullen variëren):**:

1. **Waarom zo'n kleine snelheid?**MNIST is klein (slechts 100KB model)
2. **Overhead van GPU gegevensoverdracht domineert**Voor grotere modellen (1GB+) zie je 10-100x speedups
3. **Sleutel afhaalmaaltijd**We hebben bewezen dat de hele stapel werkt:

### Prestaties begrijpen

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

**Geheugenoverdracht Bottleneck**:

- **Dit is wat er gebeurt tijdens de conclusie:**Prestatielessen
- **Batchverwerking**- Transfer veel ingangen tegelijk om overhead te amortiseren

Gegevens over GPU bewaren

- **- Chain operaties om overdracht te voorkomen**Grotere modellen profiteren meer
- **- Vaste transferkosten, schaalberekening**Wanneer GPU versus CPU te gebruiken
- **Vuistregel**GPU

## - Grote modellen, batch verwerking, inbedding generatie

CPU

1. ✅ Installed NVIDIA driver (545.xx+)
2. ✅ Installed CUDA Toolkit 12.1
3. ✅ Integrated cuDNN 8.9.7
4. ✅ Verified with `nvidia-smi`- Kleine modellen, enkele verzoeken, latency-kritiek`nvcc`
5. ✅ Tested GPU access from C# with ONNX Runtime
6. ✅ Ran performance comparison (GPU vs CPU)

Voor onze blog schrijven assistent:

## Inbeddingen

- Batch proces 100+ brokken → GPU**LLM-inferentie**- Groot model (7B params) → GPU

- Vector zoeken
- - Afhankelijk van DB keuze, vaak CPU-gebonden
- Samenvatting
- We hebben succes:
- en

Onze ontwikkelomgeving is nu klaar voor AI workloads!

## Wat is het volgende?

### In

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

### Deel 3

We duiken diep in inbeddingen en vectordatabases:
|-------|-------|-----|
| `nvidia-smi`Wat zijn inbeddingen en hoe kunnen ze semantisch zoeken?
| `nvcc`Kiezen tussen Qdrant, pgvector en andere opties
Inbeddingen lokaal genereren met ONNX Runtime
Efficiënt opslaan en opvragen van miljoenen vectoren`Microsoft.ML.OnnxRuntime.Gpu` |
Bouwen van ons eerste semantische zoekprototype

### We zullen eindelijk beginnen met het werken met de eigenlijke blog content en het zien van RAG in actie!

Referentie probleemoplossing
|--------------|---------------|--------------|-----------------|
Snelle kenmerkende commando's
Gemeenschappelijke vraagstukken
Fout in de oorzaak Fix

## niet gevonden Driver niet geïnstalleerd Installeer NVIDIA stuurprogramma

- [niet gevonden CUDA niet gevonden in PATH Voeg CUDA bin toe aan PATH](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- **DLL-belasting mislukt CuDNN ontbrekende CuDNN-bestanden kopiëren naar CUDA dir**CUDA-provider niet gevonden Verkeerde NuGet-pakket Gebruik
- [Driver-versie onvoldoende... Oude driver... Update naar 545.xx+...](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Versiecompatibiliteitsmatrix](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Versie van de CUDA, versie van de CuDNN, versie van de ONNX Runtime, stuurprogramma vereist](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [ * 8.9.7 * * 1.16.x * 545.xx+ *](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [12,3 * 9.0.0 * 1.17.x * 546.xx+ *](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [11.8 .8 .8.9.2 .. 1.15.x .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.15. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## Serienavigatie

- [Deel 1: Inleiding en architectuur](https://docs.nvidia.com/cuda/)
- [Deel 2: GPU-instellingen & CUDA in C#](https://docs.nvidia.com/deeplearning/cudnn/api/index.html)
- [(dit bericht)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
- [Deel 3: Inbeddingen en vectordatabases begrijpen](https://developer.nvidia.com/)

Deel 4: Bouwen van de Ingestie Pijpleiding[Deel 5: De Windows Client](/blog/building-a-lawyer-gpt-for-your-blog-part3)Deel 6: Lokale LLM-integratie