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

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

Wednesday, 12 November 2025

//

20 minute read

Comments Raw Edit
AI AI-Article C# CUDA GPU LLM mostlylucid.blogllm

Inleiding

Välkomna till del 2! In Del 1, 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 |96GB DDRMska9~ RAMMka10 Men du behöver inte~'~ det härMske12 som ni ser i delen 1,~ kan ni använda vilken NVIDIA GPU som helst med |NVIDIA 14GBM Ska15~ VRAM Mska16 eller till och med köra CPUMssa17 endast |(~ långsammare men funktionellaMsa19 Den här delen fokuserar på GPU-uppsättningenMsta20 men jag ska lägga märke till CPU- endast alternativ där relevantaMSA23

Den här delen kan verka grundläggande om du redan är bekanta med CUDA, 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 installering. Vi' gör det här redan från början

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

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

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

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

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:

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

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

$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

# Check CUDA compiler
nvcc --version

# Should output:
# nvcc: NVIDIA (R) Cuda compiler driver
# Copyright (c) 2005-2023 NVIDIA Corporation
# Built on Tue_Feb__7_19:32:13_Pacific_Standard_Time_2023
# Cuda compilation tools, release 12.1, V12.1.66

# Check path resolves
where.exe nvcc
# Should show: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\nvcc.exe

steg 3: cuDNN (CUDA Deep Neural Network library

cuDNN erbjuder optimerade implementeringar av djupinlärningsoperationer

Versionskompatibilitet

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

# 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

# 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

nvidia-smi

Borde visa din GPU utan några fel

CUDA-kontroll

nvcc --version

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

Systemvariabler

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

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

söka efter en apparat:

cd "1_Utilities\deviceQuery"

Kompilera den ( kräver visuell studio

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

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

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

Lägg till ONNX Runtime med CUDA

Runtime på ONNX är det enklaste sättet att använda CUDA från C#.

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:

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

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:

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

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

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

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

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.

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

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

# 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

resurser

Se er i Del 3, där vi slutligen börjar bygga den semantiska sökmotorn

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.