Bygga en "Lawyer GPT" för din blogg - Del 2: GPU Setup & CUDA i C# (Svenska (Swedish))

Bygga en "Lawyer GPT" för din blogg - Del 2: GPU Setup & CUDA i C#

Wednesday, 12 November 2025

//

21 minute read

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

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 2TillHä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: 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!Som omfattas av del 1, kan du använda alla NVIDIA GPU med 8GB+ VRAM, eller ens köra CPU-enbart (slower men funktionell).

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

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örandeAnlä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 AIParallellism

**- 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 snabbareSpecialiserad maskinvara

  • Tensorkärnor påskyndar AI-specifika operationer

Exemplet i verklighetenSkapar 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 projektpå RTX 4070 Ti 12GB 7B-13B på ett utmärkt val

• RTX 3060 + 12GB + 7B + budgetvänligtill 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 svarInte än, men kanske 2024-2025!
  • Nuvarande begränsningarIngen CUDA

: NPUs stöder inte CUDA, som denna handledning använder:

  • Begränsat .NET-stöd
  • : ONNX Runtimes NPU-stöd är experimentelltFörlaga till kompatibilitet: De flesta GGUF modeller mål CUDA/CPU
  • Stöd för direktML

: Fortfarande mogna för LLMsOm du har en NPU-utrustad CPUAnvänd endast CPU-läge för tillfället (allt fungerar, bara långsammare)

Håll utkik efter

ONNX körtid DirektML

# 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

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 GPUKontrollera 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 arkitekturenSå här fungerar programvarustacken:
  • LayerfördelningNVIDIA- drivrutin
  • - GPU-kommunikation på låg nivåVerktygslåda för CUDA

- API:er för GPU-programmering

cuDNN Ordförande

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
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 VersionFärdplan för anläggningen
  • CUDA VersionHär är ordern vi ska installera saker (order frågor!):
  • Memory-UsageSteg 1: NVIDIA-drivrutin

Kontrollera aktuell drivrutin

Öppna PowerShell:nvidia-smiDu ska se utdata som:

  1. Nyckelinformation: Bör vara 545.xx eller nyare

  2. : Detta är MAX CUDA-versionen som stöds, inte vad som är installerat

    • : För närvarande används / totalt VRAMUppdatera drivrutinen om det behövs
    • OmFunkar inte eller din förare är gammal:
    • Gå tillNVIDIA 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 motorvarvtalProdukt:

  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 omVerifiera igen med

  • Steg 2: CUDA-verktygslådaCUDA tillhandahåller programmeringsgränssnittet för GPU-acceleration.
  • VersionsvalKritisk
  • : Vi behöverCUDA

12.x för moderna modeller.

  1. Särskilt gäller följande:CUDA 12.1+
    • 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äljCUDA-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.:

$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ägThis PCFörvald sökväg är fin:

  2. Men notera detta - vi behöver det för miljövariabler!Ställ in miljövariablerInstallationsprogrammet 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 PowerShellPathOm 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. ÖppnaMiljövariabler

Högerklicka

# 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

→ Egenskaper → Avancerade systeminställningar → Miljövariabler

Enligt

Systemvariabler

, kontrollera/lägg till:: TillVariabel, se till att dessa finns:

Starta om terminalenför att förändringar ska få effektVerifiera CUDA- installation**Steg 3: CuDNN (CUDA Deep Neural Network Library)**cuDNN ger optimerade implementationer av djupinlärning.

Versionskompatibilitet

  1. KritiskcuDNN Ordförande
  2. version måste matcha CUDA version!
  3. FörCUDA 12.x
  4. , vi behövercuDNN 8.9+
  5. för CUDA 12.x (vid tidpunkten för skrivandet, 8.9.7 eller senare)

Ladda ner cuDNN

Gå till

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

# 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 cuDNNC:\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 ZIPC:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\

Du ska få se:

# 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

nvidia-smi

till

Kopiera alla filer från

nvcc --version

till

Kopiera alla filer från

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

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

Låt oss se till att allt fungerar tillsammans.:

cd "1_Utilities\deviceQuery"

HårdvarukontrollSka visa din GPU utan fel.

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

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

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

Hitta enhetQuery

Kompilera det(kräver Visuell Studio):

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

Kör den.

  • Microsoft.ML.OnnxRuntimeDu ska se utdata som:
  • Microsoft.ML.OnnxRuntime.GpuNyckelraden

Om du ser detta, din GPU + CUDA + cudNN stack fungerar!

Steg 5: Testning från C#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 ===");
        }
    }
}

Nu den roliga delen - låt oss faktiskt använda CUDA från C#!:

  1. Skapa testprojektLägg till ONNX- körtid med CUDA

    • DeviceIdONNX 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. SkapaUppdelning efter kod

    • OrtCUDAProvideralternativ
      • Anpassar CUDA- körning

- Vilken GPU att använda (0 för första GPU)

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 arbetarOm det misslyckas, något i stacken är trasigt

OrtEnv.Instans().GetTillgängliga Tillhandahållare():

# 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 korrektVisar även "CPUExecutionProvider" som reserv

Kör testet:

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 felFel: "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).

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

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

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 slutledningsprovUppdatera

    • Kodförklaring

  4. DenseTensor- ONNX Runtime sätt att representera flerdimensionella matriser

Form

dotnet run

= batch_size=1, kanaler=1, höjd=28, bredd=28NamngivenOnnxValue

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

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 dominerarFör större modeller (1GB+) kommer du att se 10-100x speedups
  3. NyckeluttagVi har bevisat hela stacken fungerar:

Förståelse för prestanda

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öringarStörre modeller gagnar mer
  • - Fast överföringskostnad, skalning beräknaNär du ska använda GPU vs CPU
  • TumregelGPU

- 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, latenskritiskanvcc
  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 → GPULLM: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

# 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-smiVad är inbäddningar och hur möjliggör de semantisk sökning? | nvccVälja mellan Qdrant, pgvector och andra alternativ Skapa inbäddningar lokalt med ONNX Runtime Lagring och sökning av miljontals vektorer effektivtMicrosoft.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

Serienavigering

Del 4: Byggande av ledning för förtäringDel 5: Windows-klientenDel 6: Lokal LLM-integration

Finding related posts...
logo

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