# Att bygga en "avrättare GPT" för din blogg - del 2: GPU-uppsättning | & CUDA i C | #

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

## Inleiding

Välkomna till del 2! In [Del 1](/blog/building-a-lawyer-gpt-for-your-blog-part1), la vi ut visionen för att bygga en skrivassistent som använder din blogg som en kunskapsbas - som jurister använder LLMs som utbildade i rättspraxis för att skriva ut dokument

> NOTET: Det här är en del av mina experiment med AI ( assisterad redigering ) + mitt eget redigerande M SK4 Samma röst, , samma pragmatism,; bara snabbare fingrar

**Om min hårdvara**: IM SK1m med hjälp av en NVIDIA RTX A4000 (16GB VRAM~), AMD Ryzen SSK5 | 9950×X~,~ och |96~GB DDR~Mska9~ RAM~Mka10~ Men du behöver inte~'~ det här~Mske12~ som ni ser i delen 1,~ kan ni använda vilken NVIDIA GPU som helst med |NVIDIA 14~GB~M Ska15~ VRAM ~Mska16~ eller till och med köra CPU~Mssa17~ endast |(~ långsammare men funktionella~Msa19~ Den här delen fokuserar på GPU-uppsättningen~Msta20~ men jag ska lägga märke till CPU~-~ endast alternativ där relevanta~MSA23~

Den här delen kan verka grundläggande om du redan är bekanta med [CUDA](https://developer.nvidia.com/cuda-toolkit), men lita på mig - Jag' har slösat bort oräkneliga timmar på att lösa mysteriösa fel som ledde tillbaka till versionsmismatcher [cuDNN](https://developer.nvidia.com/cudnn) installering. Vi' gör det här redan från början

[TOC]

## Varför GPU: s acceleration spelar roll

Innan vi dyker in i installering, låt oss förstå varför vi behöver GPU-acceleration överhuvudtaget.

### CPU vs GPU för AI Workloads

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

**Varför GPU dominerar AI**:

1. **Parallelism** - GPUs har tusentals noder jämfört med CPUs ' dussintals
2. **Matrixoperationer** - AI är till stor del matrixmatematik, , som GPUs presterar bra på
3. **Memory Bandwidth** - GPUs flyttar data mycket snabbare
4. **Specialiserad hårdvara** - Tensorkärnor accelererar AI

**Ett exempel på verkligheten** ( på min hårdvara ): Generera inbäddar för en bloggpost

- **CPU (Ryzen**: ~5 sekunder per post
- **GPU (A**: ~0.3 sekunder per post

Det är "'s 16' x snabbare , och det förväxlas när man bearbetar hundratals poster.

**Förmågor på andra GPUs** (pyttligtM SK1

- **RTX 4090** (24GBM SK1 snabbaste, ~0.2s per post
- **RTX 3060** (12GBM SK1 ~0.5s per post
- **GTX 1070 Ti** (8GBM SK1 ~0.8s per post
- fortfarande mycket snabbare än CPU!

## Att förstå din hårdvara

Innan man installerar något, ska vi förstå vad vi arbetar med.

### Min GPU: NVIDIA RTX A4000

Det här är min specifika GPU - en professionell arbetsstationskort med :

- **16GB GDDR6 VRAM** - Nog för 7BM SK2B-parametermodeller
- **6144 CUDA-corer** - Parallella processkraft
- **256 Tensorkärnor** - Accelerated AI operations
- **CUDA Beräkningsförmåga 8.6** - viktigt för kompatibilitet

### De vanliga GPU-optionerna

Här är vad olika GPUs kan hantera

| GPU | | | VRAM | МSK2 | Max-Modellstorlek || | Bra för |
|-----|------|----------------|----------|
| RTX ♫ ♫ 4090 ♫
| RTX 4070 Ti | 12GB M| | | 5 | B | 6 | b | 7 | Exzellent val | |
| RTX
| RTX
| AM SK1 (mine) ♫ ♫ | ♫
| GTX | | 1070 | Ti | | | МSK3 | GB | M| | T7 | B | MTSK6 | tunn | MVSK7 | S| | Minimalt hållbart

### Vad sägs om Intel/AMD NPUs

Du har kanske hört talas om Intel Core Ultra eller AMD Ryzen AI-chip med inbyggda **Kan du använda dem istället för NVIDIA?**

**Kort svar**: Den här tillämpningen är fortfarande inte tillämnt.

**Nutida tillstånd (lemma 2025)**:

- **DirectML har mognat**: [Runtime DirectML](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html) execution provider är nu i produktion
- **Support för NPU förbättras**: Intel's Core Ultra (Meteor LakeM SK3Lunar Lake) och AMDMSC5s Ryzen AI kan göra inferens via DirectML
- **Modellformatsbegränsningar**: NPUs fungerar bäst med ONNX-modeller ; GGUF-modeller | | ( | används för LLM-modeller
- **LLM prestationer**: För stora språkmodeller , NPUs är för närvarande långsammare än diskreta GPUs och ofta långsammar än moderna CPUs
- **Den bästa för**: Små modeller , i apparatbe inferens M SK3 batterin - kraftscenarier

**Varför vi fortfarande använder NVIDIA CUDA**:

1. **Ekosystemets mognad**: CUDA har 15+ år av optimering för LLM
2. **LLamaSharp**: använder llama.cpp som riktar sig mot CUDA
3. **Förmågor**: En mid-range NVIDIA GPU överträffar fortfarande NPUs signifikant för vår arbetsbela
4. **Samhällens stöd**: Mycket fler resurser och problemlösning tillgängliga

**Om du har en NPU-uppbyggd CPU**:

- För att skapa embedding (Part 3), kan man använda DirectML med ONNX Runtime - som kanske fungerar ganska bra
- För LLM-förklaringen (Part 6), kliva med CPU-läger eller skaffa en diskret GPU
- Titta på llama.cpp DirectML baksida (experimentell från Nov 2025)

**Framgångsperspektiv**: NPUs förbättrar sig snabbt . Till tidig tid kan de bli livsviktiga för LLM-förklaringar M SK3 speciellt för mindre modeller (1B-3B-parametern MSC6 Intels framväxande Arrow Lake och AMDs ' nästa, - gen XDNA | 2 lovar stora framsteg i AI-presterandet

Den här serien fokuserar på **NVIDIA CUDA** eftersom den levererar den bästa prestationen idag.

### Kontrollera din GPU

Först verifiera Windows ser din GPU:

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

Du borde se något som:".

```
Name
NVIDIA RTX A4000
```

Eller använda NVIDIA Control Panel → Systeminformation → Display tab.

### Arkitektur överblick

Här är hur mjukvarastecken fungerar'

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

**Breckning av lager**:

- **NVIDIA-driver** - Den låga -nivån av GPU-kommunikation
- **CUDA-Toolkit** - APIs för GPU-programmering
- **cuDNN** - Bibliotek för Deep Neural Network
- **Runtime / LLamaSharp** - Höga ML-gränssnitt på -
- **Din applikation** - Vår CM SK1 kod

## Installationskarta

Här är "'" -ordern vi , ' - installerar saker, (, "Order matters" -

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

## steg 1: NVIDIA-driver

### Kontrollera den nuvarande drivern

Att öppna PowerShell:

```bash
nvidia-smi
```

Du borde se utgång som:

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

**Nyckelinformation**:

- `Driver Version`: Ska vara 545.xx eller nyare
- `CUDA Version`: Det här är MAX CUDA-versionen som stödjer
- `Memory-Usage`: Ännu används / totalt VRAM

### uppdatera drivaren om det behövs

Om `nvidia-smi` inte fungerar eller din drivare är gammal

1. Gå till [NVIDIA Driver Downloads](https://www.nvidia.com/Download/index.aspx)

2. välja:
   
   - Produkttyp: **RTX/Quadro**
   - Produktserien: **RTX Axxxx-serien**
   - Produkt: **RTX A4000**
   - Operationssystem: **Windows 11** (eller din version
   - Download Type: **Studiodriver** (stabilare än Spelet är redo )

3. Installera och återstarta

4. Verifiera igen med `nvidia-smi`

## Schritt 2: CUDA verktygslåda

CUDA provides the programming interface for GPU acceleration.

### Versionsval

**Kritiskt**: Vi behöver [CUDA](https://developer.nvidia.com/cuda-toolkit) 12.x för moderna modeller

- **CUDA 12.1+** - Bra balans mellan kompatibilitet och egenskaper |  | vid skrivandet
- **Den senaste 12.x** - Se om det är kompatibelt med dina bibliotek
- **Inte CUDA 11.x** - Missande egenskaper nyare modeller behöver

### Download & Installera

1. Gå till [CUDA Toolkit Archiv](https://developer.nvidia.com/cuda-toolkit-archive)
2. Välj **CUDA verktygslåda 12.1** ( eller 12.3 om du är äventyrlig
3. välja: **Windows → x86_64 → ♫ ♫ 11 ♫**
4. ladda ner (~3GB)

### Installationsoptioner

kör installeret. När uppmanad:

```
Installation Type: Custom (Advanced)

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

**Varför Custom?**: Vi vill inte downgradera vår driver eller installera spelsoftware

### Installationspfad

Standardpfad är bra:

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

Men lägg märke till detta: -, vi , ', behöver den för miljövariabler, !

### Se miljövariabler

Installatorn sätter vanligtvis de här:, men kontrollerar

**kolla in 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
```

**Om saknas, lägg till manualt**:

1. Öffna **Miljövariabler**:
   
   - Regs-klicka `This PC` → egenskaper → avancerade systeminställningar → miljövariabler

2. Under **Systemvariabler**, kontrollera
   
   - `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. I `Path` variabeln , se till att de existerar:
   
   ```
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp
   ```

4. **Återstarta din terminal** för att förändringar ska ta effekt

### Verifiera CUDA-installation

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

## steg 3: cuDNN (CUDA Deep Neural Network library

cuDNN erbjuder optimerade implementeringar av djupinlärningsoperationer

### Versionskompatibilitet

**Kritiskt**: [cuDNN](https://developer.nvidia.com/cudnn) version måste matcha CUDA version!

För **CUDA 12.x**, vi behöver **cuDNN 8.9+** för CUDA 12.x ( vid skrivandes tidpunkt

### ladda ner cuDNN

1. Gå till [cuDNN-Archivet](https://developer.nvidia.com/rdp/cudnn-archive)
2. Du kommer att behöva ett NVIDIA Developerkonto (free
3. Hitta: **ladda ner cuDNN v8.9.7 (December 5thM SK3 | | 2023), för CUDA 12.x**
4. välja: **Lokal installer för Windows (Zip)**
5. ladda ner (~800MB)

### Extrahera och installera cuDNN

cuDNN är bara en uppsättning av filer som du kopierar i din CUDA-installation.

**Extrahera den ZIP**, du ' ska se

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

**Kopiera filer till CUDA-installation**:

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

**Eller gör det manuell**:

1. Koppla alla filer från `bin\` till `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\`
2. Koppla alla filer från `include\` till `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\`
3. Koppla alla filer från `lib\x64\` till `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\`

### Verifiera cuDNN installering

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

## steg 4: Complete Verification

Låt oss se till att allt fungerar tillsammans.

### Hardwarekontroll

```powershell
nvidia-smi
```

Borde visa din GPU utan några fel

### CUDA-kontroll

```powershell
nvcc --version
```

Borde visa CUDA 12.1 ( eller vilken version du än installerat

### Systemvariabler

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

### CUDA Samplestest (Optionellt men tillämpt)

CUDA-Toolkit innefattar provprogram. Låt 's kompilera och köra ett.

**Navigera till prover**:

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

**söka efter en apparat**:

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

**Kompilera den** ( kräver visuell studio

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

**kör den**:

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

Du borde se utgång som:

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

**Den nyckellinjen**: `Result = PASS`

Om du ser detta, så funkar din GPU + CUDA + cuDNN-steg

## steg 5: Testning från C

Den roliga biten - låter CUDA använda CSK2

### Att skapa ett testprojekt

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

### Lägg till ONNX Runtime med CUDA

[Runtime på ONNX](https://onnxruntime.ai/) är det enklaste sättet att använda CUDA från C#.

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

**Varför detta paket?**

- `Microsoft.ML.OnnxRuntime` - endast CPU
- `Microsoft.ML.OnnxRuntime.Gpu` - Inbegriper CUDA stöd

### Testkod: GPU-detektor

Att skapa `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 ===");
        }
    }
}
```

**Kodfördelning**:

1. **OrtCUDAProviderOptioner** - Konfigurerar CUDA-överdrag
   
   - `DeviceId` - Vilken GPU att använda 0 för första GPU
   - Kan sätta upp minnesgränser

2. **Sektionsoptioner.AppendExecutionProvider_CUDAM SK2** - Bevarar ONNX Runtime att använda GPU
   
   - Om det lyckas, CUDA fungerar
   - Om det misslyckas, är något i stapeln brutet

3. **OrtEnv.Instans().GetAvailableProviders ()** - Lyssner alla tillgängliga implementeringsprovider
   
   - bör inkludera "CUDAExecutionProvider" om allting är korrekt installerat
   - Det visar också "CPUExecutionProvider" som fallback

### kör testerna

```bash
dotnet run
```

**Oväntad utgång**:

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

### Att lösa vanliga fel

#### Error: M SK1DllNotFoundException: Kunde inte lada DLL 'onnxruntimeMSC4

**Saken**: ONNX Runtime kan inte hitta CUDA DLLs

**Fixera**:

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

#### Fout: "CUDAExecutionProvider inte funnit

**Saken**: Missbruk av det felaktiga Runtimepaketet

**Fixera**:

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

#### Fout: "CUDA felkoden : | | 35 \ ( | CUDA driver version is insufficient

**Saken**: Treiber är för gammalt för CUDA |

**Fixera**: uppdatera NVIDIA-drivaren till 545.xx eller nyare.

## Utvecklingstest : faktisk inferens

Låt oss göra något verkligt. Runna ett litet nervnätverk på GPU vs CPU och jämföra hastigheter.

### ladda ner en testmodell

Vi kommer att använda en enkel MNIST-digitigenkänningsmodell

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

### Inferenstestkod

uppdatera `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;
        }
    }
}
```

**Kodbetydande**:

1. **DenseTensor** - ONNX Runtime ' sättet att representera multidimensionella arrader
   
   - Form `[1, 1, 28, 28]` = pakett _storlek=1, kanalerM SK3 längd

2. **NameradOnnxValue** - Binder en tensor till ett ingångs namn
   
   - "Input

3. **Warmuprun** - Den första slutsatsen är alltid långsammare  modelllagning M SK2 optimering
   
   - Vi kör en gång innan vi lägger tiden för att få noggranna mätningar

4. **Timeringsmetodik** - medelvärde över 100 repetitioner för stabila resultat

### Att köra Leistungstest

```bash
dotnet run
```

**Oväntad utgång** ( dina tal kommer att variera ):

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

**Varför en så liten hastighet**

- MNIST är en liten modell
- överhead av dataöverföring dominerar
- För större modeller (1GB+), ser ni ' 10-100x accelerationer

### Ta med mig nyckeln

Vi' har bevisat att hela högen fungerar
✅ Treiber installerad korrekt
✅ CUDA verktygskit tillgängligt
✅ integrerad cuDNN
✅ ONNX Runtime hittar CUDA
✅ C# kan köra GPUM SK2 accelererad inferens

## Att förstå prestationer

### Memory Transfer Bottleneck

Här är vad som händer under förklaringen.

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

**Performancelektioner**:

1. **Batchprocessing** - Spegla flera ingångar på samma gång för att amortisera överhead
2. **Håll data på GPU** - Kettoperationer för att undvika överföring
3. **Större modeller gynnar mer** - Fixerad överförselkostnad, skalningsberäkning

### När man ska använda 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
```

**tumregler**:

- **GPU** - stora modeller , slagprocessing
- **CPU** - Små modeller , ensamma begärningar , latens

För vår bloggskrivare

- **Embeddings** - Batchprocess 100+ chunks → GPU
- **LLM-förklaring** - Stor modell | 7 | B paramer | МSK2 |
- **Vektorsökning** - beror på DB-valet

## sammanfattning

Vi' har lyckats:

1. ✅ Installerad NVIDIA-driver (545.xx+)
2. ✅ Installerad CUDA-Toolkit 12.1
3. ✅ Integrerad cuDNN 8.9.7
4. ✅ Bevestig med `nvidia-smi` och `nvcc`
5. ✅ Testad GPU-tillgång från C# med ONNX Runtime
6. ✅ Ran-presterande jämförelse (GPU vs CPU)

Vår utvecklingsmiljö är nu redo för AI: s arbetslast

## Vad's Nästa?

I **Del 3**, vi ' dyker djupt in i inbäddar och vektordatabaser

- Vad är inbäddar och hur möjliggör de semantiska sökningar?
- När man väljer mellan Qdrant, pgvector, och andra alternativ
- Generera inbäddar lokalt med ONNX Runtime
- Att lagra och söka miljoner vektorer effektivt
- Att bygga vår första semantiska sökprototyp

Vi' kommer äntligen börja arbeta med den faktiska bloggarna innehållet och se RAG i praktiken

## Troubleshooting Reference

### Vinniga diagnostiska kommandor

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

### Samma frågor

| Błęd | Anledningen | | | Fixera ||
|-------|-------|-----|
| `nvidia-smi` inte gevind | Treiber inte installerad | Installera NVIDIA driver |
| `nvcc` inte hitta | CUDA inte i PATH | Lägg CUDA-skivan till PATH
| Att ladda ned DLL misslyckades | CuDNN saknas ♫ ♫ | ♫ Kopiera cuDNN-filer till CUDA dir ♫
| CUDA-provider inte hitta | Verklig NuGet-package ♫ | ♫ Använd `Microsoft.ML.OnnxRuntime.Gpu` |
| Treiberversion otillräcklig

### Version Compatibility Matrix

| CUDA-version | | | cuDNN-version
|--------------|---------------|--------------|-----------------|
|  12.1
|  12.3
|  11.8

## Seri Navigation

- [Del 1: Inleiding & Arkitektur](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- **Del 2: GPU Setup & CUDA i C#** (this postM SK1
- [Del 3: Understanding Embeddings | & | Vektordatabaser](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Del 4: Byggnaden av införingsledning](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Del 5: Windows Client](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [Del 6: Lokal LLM integration](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [Del 7: innehållsgenerering & Vinniga ingenjörskonst](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [Del 8: Utvecklade egenskaper & Tillverkning av produktion](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## resurser

- [CUDA Toolkit Dokumentation](https://docs.nvidia.com/cuda/)
- [cuDNN Dokumentation](https://docs.nvidia.com/deeplearning/cudnn/api/index.html)
- [ONNX Runtime GPU Execution Provider](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
- [NVIDIA Developer Zone](https://developer.nvidia.com/)

Se er i [Del 3](/blog/building-a-lawyer-gpt-for-your-blog-part3), där vi slutligen börjar bygga den semantiska sökmotorn