# Bygga en "Lawyer GPT" för din blogg - Del 2: GPU Setup & CUDA i C#
2025-11-12T22:45
> VARNING: DETTA UTKASTS TILL POSTER SOM "FÖRSÄKRATS".
Det är troligt att mycket av det som är nedan inte kommer att fungera; Jag genererar dessa som hur-till för MIG och sedan göra alla steg och få provappen att fungera ... Du har varit smygande och sett dem! de kommer sannolikt att vara redo i mitten av december.
## Inledning
Välkommen till del 2Häfte 1
> , Vi lade fram visionen för att bygga en skrivassistent som använder din blogg som en kunskapsbas - som hur advokater använder LLMs utbildad i rättspraxis för att utarbeta dokument.
**Nu är det dags att få våra händer smutsiga med grunden: se till att din GPU är redo för AI arbetsbelastning.**OBS: Detta är en del av mina experiment med AI (assisterad utformning) + min egen redigering.
Samma röst, samma pragmatism, bara snabbare fingrar.[Om min hårdvara](https://developer.nvidia.com/cuda-toolkit): Jag använder ett NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X och 96GB DDR5 RAM.[Men du behöver inte det här!](https://developer.nvidia.com/cudnn)Som omfattas av del 1, kan du använda alla NVIDIA GPU med 8GB+ VRAM, eller ens köra CPU-enbart (slower men funktionell).
[TOC]
## Denna del fokuserar på GPU inställning, men jag ska notera CPU-bara alternativ där det är relevant.
Den här delen kan verka grundläggande om du redan känner till
### 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
```
**, men lita på mig - Jag har slösat bort otaliga timmar debugging mystiska fel som spårats tillbaka till version missmatchningar, saknade miljövariabler, eller felaktiga**:
1. **cuDNN Ordförande**Anläggningar.
2. **Vi gör det här från början.**Varför GPU-accelerationen är viktig
3. **Innan vi dyker in i installationen, låt oss förstå varför vi behöver GPU-acceleration alls.**CPU vs GPU för AI arbetsbelastningar
4. **Varför GPUs dominerar för AI**Parallellism
**- GPU:er har tusentals kärnor jämfört med CPU:er.**Matrixåtgärder
- **- AI är mestadels matris matte, som GPUs utmärker sig på**Minnesbandbredd
- **- GPUs flytta data mycket snabbare**Specialiserad maskinvara
- Tensorkärnor påskyndar AI-specifika operationer
**Exemplet i verkligheten**Skapar inbäddningar för ett blogginlägg:
- **CPU (Ryzen 9 9950X)**: ~5 sekunder per post
- **GPU (A4000 16GB)**: ~0,3 sekunder per post
- **Det är 16x snabbare, och det föreningar vid bearbetning av hundratals inlägg!**Prestanda för andra GPU:er
- (ungefärlig):
## NT1 tullskuld NT1 tullskuld NT1 tullskuld NT1 tullskuld
(24GB): Snabbast, ~0.2 per tjänst
### NT1 tullskuld NT1 tullskuld NT1 tullskuld NT1 tullskuld
(12GB): ~0.5 per post
- **GTX 1070 Ti**(8GB): ~0,8 per tjänst
- **Fortfarande mycket snabbare än CPU!**Förstå din hårdvara
- **Innan du installerar något, låt oss förstå vad vi arbetar med.**Min GPU: NVIDIA RTX A4000
- **Detta är min specifika GPU - en professionell arbetsstation kort med:**16GB GDDR6 VRAM
### - Tillräckligt för 7B-13B-parametermodeller
6144 CUDA-kärnor
- Parallell processkraft
|-----|------|----------------|----------|
256 Tensorkärnor
- Påskyndad AI-verksamhet
CUDA beräknar kapacitet 8.6
- Viktigt för kompatibilitet
Vanliga GPU-alternativ
Här är vad olika GPU:er kan hantera:
### på GPU på VRAM på Max modellstorlek och bra för påse
på RTX 4090 på 24GB på 13B-30B på overkill för detta projekt**på RTX 4070 Ti 12GB 7B-13B på ett utmärkt val**
**• RTX 3060 + 12GB + 7B + budgetvänlig**till RTX 4060 Ti på 16GB på 7B-13B
**på A4000 (mina) på 16GB 7B-13B på arbetsstation GPU**:
- **på GTX 1070 Ti 8GB 7B (tät)**Hur är det med Intel/AMD NPU:er?
- **Du kanske har hört talas om Intel Core Ultra eller AMD Ryzen AI-chips med inbyggda NPU (Neural Processing Units).**Kan du använda dem istället för NVIDIA?
- **Kort svar**Inte än, men kanske 2024-2025!
- **Nuvarande begränsningar**Ingen CUDA
**: NPUs stöder inte CUDA, som denna handledning använder**:
- Begränsat .NET-stöd
- : ONNX Runtimes NPU-stöd är experimentellt[Förlaga till kompatibilitet](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html): De flesta GGUF modeller mål CUDA/CPU
- Stöd för direktML
: Fortfarande mogna för LLMs**Om du har en NPU-utrustad CPU**Använd endast CPU-läge för tillfället (allt fungerar, bara långsammare)
### Håll utkik efter
ONNX körtid DirektML
```bash
# PowerShell
wmic path win32_VideoController get name
```
uppdateringar
```
Name
NVIDIA RTX A4000
```
Framtida delar kommer att notera när NPU-stöd förbättras
### Denna serie fokuserar på
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
```
**eftersom det är mogen och väl förankrad i .NET, men koncepten kommer att översätta till NPU när ekosystemet kommer ikapp!**:
- **Kontrollera din GPU**Kontrollera först att Windows ser din GPU:
- **Du skulle se något i stil med:**Eller använd NVIDIA Kontrollpanelen → Systeminformation → Visa fliken.
- **Översikt över arkitekturen**Så här fungerar programvarustacken:
- **Layerfördelning**NVIDIA- drivrutin
- **- GPU-kommunikation på låg nivå**Verktygslåda för CUDA
## - API:er för GPU-programmering
cuDNN Ordförande
```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
```
## - Djup neurala nätverksbibliotek (optimerade kärnor)
### ONNX körtid / Llamasharp
- Högnivåramar för ML
```bash
nvidia-smi
```
Din ansökan
```
+-----------------------------------------------------------------------------+
| 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 |
+-------------------------------+----------------------+----------------------+
```
**- Vår C#-kod.**:
- `Driver Version`Färdplan för anläggningen
- `CUDA Version`Här är ordern vi ska installera saker (order frågor!):
- `Memory-Usage`Steg 1: NVIDIA-drivrutin
### Kontrollera aktuell drivrutin
Öppna PowerShell:`nvidia-smi`Du ska se utdata som:
1. Nyckelinformation[: Bör vara 545.xx eller nyare](https://www.nvidia.com/Download/index.aspx)
2. : Detta är MAX CUDA-versionen som stöds, inte vad som är installerat
- : För närvarande används / totalt VRAM**Uppdatera drivrutinen om det behövs**
- Om**Funkar inte eller din förare är gammal:**
- Gå till**NVIDIA drivrutinhämtningar**
- Välj:**Produkttyp:**NT1 sockerbeta NT1 sockerbeta NT1 sockerbeta NT1 sockerbeta NT1 sockerbeta
- Produktserie:**NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal NT1 motorvarvtal**Produkt:
3. NT1 tullskuld NT1 tullskuld NT1 tullskuld NT1 tullskuld
4. Operativt system:`nvidia-smi`
## Fönster 11
(eller din version)
### Ladda ner typ:
**Studio Driver**( stabilare än Game Ready)[Installera och starta om](https://developer.nvidia.com/cuda-toolkit)Verifiera igen med
- **Steg 2: CUDA-verktygslåda**CUDA tillhandahåller programmeringsgränssnittet för GPU-acceleration.
- **Versionsval**Kritisk
- **: Vi behöver**CUDA
### 12.x för moderna modeller.
1. Särskilt gäller följande:[CUDA 12.1+](https://developer.nvidia.com/cuda-toolkit-archive)
2. - Bra balans mellan kompatibilitet och funktioner (vid tidpunkten för skrivandet)**Senaste 12,x**- Kontrollera kompatibilitet med dina bibliotek
3. Inte CUDA 11.x**- Saknade funktioner nyare modeller behöver**
4. Ladda ner & installera
### Gå till
CUDA verktygslåda Arkiv
```
Installation Type: Custom (Advanced)
Select Components:
✅ CUDA Toolkit
✅ CUDA Documentation
✅ CUDA Samples
✅ CUDA Visual Studio Integration
❌ GeForce Experience (not needed)
❌ NVIDIA Driver (already installed)
```
**Välj**CUDA-verktygslåda 12.1
### (eller 12.3 om du är äventyrlig)
Välj:
```
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1
```
Windows → x86_64 → 11 → exe (lokal)
### Ladda ner (~3GB)
Installationsalternativ
**Kör installationsprogrammet.**:
```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
```
**När du blir tillfrågad:**:
1. Varför är det brukligt?**: Vi vill inte nedgradera vår drivrutin eller installera spelprogram.**:
- Installationssökväg`This PC`Förvald sökväg är fin:
2. Men notera detta - vi behöver det för miljövariabler!**Ställ in miljövariabler**Installationsprogrammet ställer vanligtvis in dessa, men verifiera:
- `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. Kontrollera PowerShell`Path`Om saknas, lägg till manuellt
```
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp
```
4. **Öppna**Miljövariabler
### Högerklicka
```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
```
## → Egenskaper → Avancerade systeminställningar → Miljövariabler
Enligt
### Systemvariabler
**, kontrollera/lägg till:**: [Till](https://developer.nvidia.com/cudnn)Variabel, se till att dessa finns:
Starta om terminalen**för att förändringar ska få effekt**Verifiera CUDA- installation**Steg 3: CuDNN (CUDA Deep Neural Network Library)**cuDNN ger optimerade implementationer av djupinlärning.
### Versionskompatibilitet
1. Kritisk[cuDNN Ordförande](https://developer.nvidia.com/rdp/cudnn-archive)
2. version måste matcha CUDA version!
3. För**CUDA 12.x**
4. , vi behöver**cuDNN 8.9+**
5. för CUDA 12.x (vid tidpunkten för skrivandet, 8.9.7 eller senare)
### Ladda ner cuDNN
Gå till
**cuDNN- arkivet**Du behöver ett NVIDIA Developer-konto (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)
```
**Sök:**:
```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\"
```
**Ladda ner cuDNN v8.9.7 (5 december 2023), för CUDA 12.x**:
1. Välj:`bin\`Lokal installation för Windows (Zip)`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\`
2. Ladda ner (~800MB)`include\`Extrahera och installera cuDNN`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\`
3. cuDNN är bara en uppsättning filer du kopierar till din CUDA-installation.`lib\x64\`Extrahera ZIP`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\`
### Du ska få se:
```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"
```
## Kopiera filer till CUDA- installation
Eller gör det manuellt
### Kopiera alla filer från
```powershell
nvidia-smi
```
till
### Kopiera alla filer från
```powershell
nvcc --version
```
till
### Kopiera alla filer från
```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
```
### till
Verifiera cuDNN- installation
**Steg 4: Fullständig verifiering**:
```powershell
cd "C:\ProgramData\NVIDIA Corporation\CUDA Samples\v12.1"
```
**Låt oss se till att allt fungerar tillsammans.**:
```powershell
cd "1_Utilities\deviceQuery"
```
**Hårdvarukontroll**Ska visa din GPU utan fel.
```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- kontroll**:
```powershell
.\x64\Release\deviceQuery.exe
```
Ska visa CUDA 12.1 (eller vilken version du än har installerat).
```
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
```
**Kontrollera systemvariabler**: `Result = PASS`
CUDA-provtest (valfritt men rekommenderat)
## CUDA Toolkit innehåller exempelprogram.
Vi sammanställer och kör ett.
### Navigera till prover
```bash
mkdir CudaTest
cd CudaTest
dotnet new console -n CudaTest
cd CudaTest
```
### Hitta enhetQuery
[Kompilera det](https://onnxruntime.ai/)(kräver Visuell Studio):
```bash
dotnet add package Microsoft.ML.OnnxRuntime.Gpu # Latest version
```
**Kör den.**
- `Microsoft.ML.OnnxRuntime`Du ska se utdata som:
- `Microsoft.ML.OnnxRuntime.Gpu`Nyckelraden
### Om du ser detta, din GPU + CUDA + cudNN stack fungerar!
Steg 5: Testning från 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 den roliga delen - låt oss faktiskt använda CUDA från C#!**:
1. **Skapa testprojekt**Lägg till ONNX- körtid med CUDA
- `DeviceId`ONNX körtid
- är det enklaste sättet att använda CUDA från C#.
2. **Varför detta paket?**- Endast CPU
- - Inkluderar stöd för CUDA
- Provningskod: GPU-detektion
3. **Skapa**Uppdelning efter kod
- OrtCUDAProvideralternativ
- - Anpassar CUDA- körning
### - Vilken GPU att använda (0 för första GPU)
```bash
dotnet run
```
**Kan ställa in minnesgränser, optimeringsnivå, 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 ===
```
### Sessionsalternativ.TillåtExecutionProvider_CUDA()
#### - Talar om för ONNX Körtid att använda GPU
**Om detta lyckas, CUDA arbetar**Om det misslyckas, något i stacken är trasigt
**OrtEnv.Instans().GetTillgängliga Tillhandahållare()**:
```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
```
#### - Listar alla tillgängliga tillhandahållare av utförande
**Bör inkludera "CUDAExecutionProvider" om allt är installerat korrekt**Visar även "CPUExecutionProvider" som reserv
**Kör testet**:
```bash
dotnet remove package Microsoft.ML.OnnxRuntime
dotnet add package Microsoft.ML.OnnxRuntime.Gpu --version 1.16.3
```
#### Förväntade resultat
**Felsökning av vanliga fel**Fel: "DllNotFoundUception: Kunde inte läsa in DLL "onnxruntime"
**Orsak**: ONNX Runtime kan inte hitta CUDA DLLs.
## Rätta
Fel: "CUDAExecutionProvider hittades inte"
### Orsak
: Använda fel ONNX Runtime-paket (endast 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"
```
### Rätta
Fel: "CUDA-felkod: 35 (CUDA- drivrutinsversion är otillräcklig)"`Program.cs`:
```csharp
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using System;
using System.Diagnostics;
using System.Linq;
namespace CudaTest
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("=== GPU vs CPU Inference Test ===\n");
// Create dummy input (28x28 image flattened to 784 floats)
var inputData = Enumerable.Range(0, 784).Select(i => (float)i / 784).ToArray();
var tensor = new DenseTensor(inputData, new[] { 1, 1, 28, 28 });
var inputs = new List
{
NamedOnnxValue.CreateFromTensor("Input3", tensor)
};
// Test 1: CPU Inference
Console.WriteLine("Test 1: CPU Inference");
var cpuTime = TestInference(inputs, useCuda: false, iterations: 100);
Console.WriteLine($" Average time: {cpuTime:F2}ms\n");
// Test 2: GPU Inference
Console.WriteLine("Test 2: GPU Inference");
var gpuTime = TestInference(inputs, useCuda: true, iterations: 100);
Console.WriteLine($" Average time: {gpuTime:F2}ms\n");
// Compare
Console.WriteLine("Comparison:");
Console.WriteLine($" CPU: {cpuTime:F2}ms");
Console.WriteLine($" GPU: {gpuTime:F2}ms");
Console.WriteLine($" Speedup: {cpuTime / gpuTime:F2}x faster on GPU");
}
static double TestInference(List inputs, bool useCuda, int iterations)
{
var options = new SessionOptions();
if (useCuda)
{
options.AppendExecutionProvider_CUDA(0);
}
using var session = new InferenceSession("mnist.onnx", options);
// Warmup run (first run is always slower)
session.Run(inputs);
// Timed runs
var sw = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
using var results = session.Run(inputs);
// Force evaluation
var output = results.First().AsEnumerable().ToArray();
}
sw.Stop();
return sw.Elapsed.TotalMilliseconds / iterations;
}
}
}
```
**Orsak**:
1. **: Driver är för gammal för CUDA 12.x.**Rätta
- : Uppdatera NVIDIA drivrutin till 545.xx eller senare.`[1, 1, 28, 28]`Avancerat test: Faktisk slutsats
2. **Låt oss göra något verkligt - köra ett litet neuralt nätverk på GPU vs CPU och jämföra hastigheter.**Ladda ner en testmodell
- Vi använder en enkel MNIST-digitaligenkänningsmodell (ONNX-format).
3. **Kod för slutledningsprov**Uppdatera
- Kodförklaring
4. **DenseTensor**- ONNX Runtime sätt att representera flerdimensionella matriser
### Form
```bash
dotnet run
```
**= batch_size=1, kanaler=1, höjd=28, bredd=28**NamngivenOnnxValue
```
=== 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
```
**- Binder en tensor till ett inmatningsnamn**
- "Input3" är indatanamnet i MNIST-modellen
- Uppvärmningskörning
- - Första slutsatsen är alltid långsammare (modell lastning, optimering)
### Vi kör en gång innan timingen för att få korrekta mätningar
Tidsbestämningsmetod
✅ Driver installed correctly
✅ CUDA Toolkit accessible
✅ cuDNN integrated
✅ ONNX Runtime finds CUDA
✅ C# can run GPU-accelerated inference
## - Genomsnitt över 100 iterationer för stabila resultat
### Kör prestandatest
Förväntade resultat
```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
```
**(ditt antal kommer att variera):**:
1. **Varför en sådan liten upptrappning?**MNIST är liten (endast 100KB modell)
2. **Ovanför GPU dataöverföring dominerar**För större modeller (1GB+) kommer du att se 10-100x speedups
3. **Nyckeluttag**Vi har bevisat hela stacken fungerar:
### Förståelse för prestanda
```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
```
**Minnesöverföring Flaskhals**:
- **Så här går det till när man drar slutsatsen:**Prestandalektioner
- **Förädling av tillverkningssatser**- Överför många ingångar på en gång för att amortera overhead
Spara data på GPU
- **- Kedjeverksamhet för att undvika överföringar**Större modeller gagnar mer
- **- Fast överföringskostnad, skalning beräkna**När du ska använda GPU vs CPU
- **Tumregel**GPU
## - Stora modeller, satsbearbetning, inbäddning generering
Maskiner och apparater för tillverkning av massa, papper eller papp, i.a.n.
1. ✅ Installed NVIDIA driver (545.xx+)
2. ✅ Installed CUDA Toolkit 12.1
3. ✅ Integrated cuDNN 8.9.7
4. ✅ Verified with `nvidia-smi`- Små modeller, enstaka förfrågningar, latenskritiska`nvcc`
5. ✅ Tested GPU access from C# with ONNX Runtime
6. ✅ Ran performance comparison (GPU vs CPU)
För vår bloggskrivarassistent:
## Inbäddningar
- Batch process 100 + bitar → GPU**LLM:s slutsats**- Stor modell (7B params) → GPU
- Vektorsökning
- - Beror på DB val, ofta CPU-bunden
- Sammanfattning
- Vi har lyckats:
- och
Vår utvecklingsmiljö är nu redo för AI arbetsbelastningar!
## Vad är nästa?
### Till
```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
```
### Häfte 3
, Vi kommer att dyka djupt i inbäddningar och vektordatabaser:
|-------|-------|-----|
| `nvidia-smi`Vad är inbäddningar och hur möjliggör de semantisk sökning?
| `nvcc`Välja mellan Qdrant, pgvector och andra alternativ
Skapa inbäddningar lokalt med ONNX Runtime
Lagring och sökning av miljontals vektorer effektivt`Microsoft.ML.OnnxRuntime.Gpu` |
Bygga vår första semantiska sökprototyp
### Vi kommer äntligen att börja arbeta med faktiska blogginnehåll och se RAG i aktion!
Felsökningsreferens
|--------------|---------------|--------------|-----------------|
Snabbdiagnostikkommandon
Vanliga frågor
Fel på grund av fel på grund av korrigering på grund av fel
## hittades inte med drivrutinen inte installerad på plats Installera NVIDIA- drivrutinen på plats
- [hittades inte med CUDA inte i PATH och Lägg till CUDA bin i PATH](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- **på DLL-belastningen misslyckades på grund av att cudNN saknas och Kopiera cudNN-filer till CUDA dir på grund av att filerna saknas**på CUDA leverantör inte hittas på fel NuGet paket på Använd
- [på Driver version otillräcklig på Gamla drivrutinen på Uppdatera till 545.xx+ till](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Kompatibilitetsmatris för version](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [till CUDA Version på CUDNN Version på NOX Körtid på drivrutinen krävs](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [och 12,1 på 8,9.7 på 1,16 x på 545.xx+](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [till 12,3 och 9.0.0 på 1,17.x på 546.xx+](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [till 11,8 och 8.9.2 på 1,15.x på 520.xx+](/blog/building-a-lawyer-gpt-for-your-blog-part8)
## Serienavigering
- [Del 1: Introduktion och arkitektur](https://docs.nvidia.com/cuda/)
- [Del 2: GPU- inställning & CUDA i C#](https://docs.nvidia.com/deeplearning/cudnn/api/index.html)
- [(detta inlägg)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
- [Del 3: Förstå inbäddningar och vektordatabaser](https://developer.nvidia.com/)
Del 4: Byggande av ledning för förtäring[Del 5: Windows-klienten](/blog/building-a-lawyer-gpt-for-your-blog-part3)Del 6: Lokal LLM-integration