WARNUNG: DIESE SIND ENTWICKLUNGSSTELLEN, DIE "ESCAPED" SIND.

Es ist wahrscheinlich viel von dem, was unten ist, wird nicht funktionieren; Ich generiere diese als how-to für ME und dann tun Sie alle Schritte und bekommen die Beispiel-App funktioniert...Sie haben hinterhältig und sie gesehen! sie werden wahrscheinlich bereit sein Mitte Dezember.

## Einleitung

Willkommen in Teil 2Teil 1

, wir legten die Vision für den Aufbau eines Schreibassistenten, der Ihren Blog als Wissensbasis nutzt - wie wie Anwälte LLMs auf Fallrecht geschult verwenden, um Dokumente zu entwerfen.

**Jetzt ist es an der Zeit, unsere Hände mit der Stiftung schmutzig zu machen: Stellen Sie sicher, dass Ihre GPU für KI-Workloads bereit ist.**HINWEIS: Dies ist Teil meiner Experimente mit KI (unterstützter Entwurf) + meiner eigenen Bearbeitung.

Dieselbe Stimme, derselbe Pragmatismus; nur schnellere Finger.Über meine Hardware: Ich benutze einen NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X und 96GB DDR5 RAM.Aber das brauchst du nicht!Wie in Teil 1 beschrieben, können Sie jede NVIDIA GPU mit 8GB+ VRAM verwenden oder sogar nur CPU laufen lassen (niedriger, aber funktional).

Dieser Teil konzentriert sich auf GPU-Setup, aber ich werde nur CPU-Alternativen beachten, wo relevant.

Dieser Teil könnte einfach erscheinen, wenn Sie bereits vertraut sind mit

KUDA

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

, aber vertrauen Sie mir - Ich habe unzählige Stunden Debugging mysteriöse Fehler verschwendet, die zurück zu Versionsfehlern zurückverfolgt, fehlende Umgebungsvariablen, oder falsch:

1. **L 347 vom 20.12.2013, S. 671.**Anlagen.
2. **Wir machen das von Anfang an.**Warum GPU-Beschleunigung zählt
3. **Bevor wir in die Installation eintauchen, lassen Sie uns verstehen, warum wir überhaupt eine GPU-Beschleunigung brauchen.**CPU gegen GPU für AI Workloads
4. Warum GPUs für KI dominierenParallelität

- GPUs haben Tausende von Kernen gegen CPUs DutzendeMatrix-Operationen

• - KI ist meist Matrix-Mathematik, die GPUs zeichnen sich beiSpeicherbandbreite

• - GPUs verschieben Daten viel schnellerSpezialisierte Hardware

• Tensorkerne beschleunigen KI-spezifischen Betrieb

Beispiel für die reale Welt(auf meiner Hardware): Generieren von Einbettungen für einen Blog-Post:

• CPU (Ryzen 9 9950X): ~5 Sekunden pro Post
• GPU (A4000 16GB): ~0,3 Sekunden pro Post
• **Das ist 16x schneller, und es Verbindungen, wenn Hunderte von Pfosten zu verarbeiten!**Leistung auf anderen GPUs
• (ungefähr)

RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT

(24GB): Schnellste, ~0,2s pro Post

NT2 BERUFSBILDUNG

(12 GB): ~0,5 s je Post

• GTX 1070 Ti(8 GB): ~0,8 s je Post
• **Noch viel schneller als CPU!**Ihre Hardware verstehen
• **Bevor wir etwas installieren, wollen wir verstehen, womit wir arbeiten.**Meine GPU: NVIDIA RTX A4000
• **Dies ist meine spezielle GPU - eine professionelle Workstation-Karte mit:**16GB GDDR6 VRAM

- Genug für 7B-13B Parameter Modelle

6144 CUDA-Kerne

• Parallele Verarbeitungsleistung |-----|------|----------------|----------| 256 Tensorkerne
• Beschleunigte KI-Operationen CUDA Berechnungsfähigkeit 8.6
• Wichtig für die Kompatibilität Häufige GPU-Optionen Hier ist, was verschiedene GPUs handhaben können:

GPU, VRAM, Max Model Größe, gut für

RTX 4090, 24GB, 13B-30B, Overkill für dieses ProjektRTX 4070 Ti- 12GB- 7B-13B- Ausgezeichnete Wahl

RTX 3060 - 12GB - 7B - BudgetfreundlichRTX 4060 Ti- 16GB- 7B-13B- Großer Wert

A4000 (Mine) 16 GB 7B-13B, Arbeitsstation GPU:

• **, GTX 1070 Ti , 8GB , 7B (dicht) , Minimum lebensfähig ,**Was ist mit Intel/AMD NPUs?
• **Vielleicht haben Sie von Intel Core Ultra oder AMD Ryzen AI Chips mit eingebauten NPUs (Neural Processing Units) gehört.**Können Sie diese anstelle von NVIDIA verwenden?
• Kurze Antwort: Noch nicht, aber vielleicht 2024-2025!
• Derzeitige BeschränkungenKeine CUDA

: NPUs unterstützen CUDA nicht, die dieses Tutorial verwendet:

• Begrenzte .NET-Unterstützung
• : Die NPU-Unterstützung von ONNX Runtime ist experimentellKompatibilität des Modells: Die meisten GGUF-Modelle zielen auf CUDA/CPU ab
• Direkt-ML-Unterstützung

: Reifung für LLMsWenn Sie eine NPU-ausgestattete CPU habenVerwenden Sie jetzt nur CPU-Modus (alles funktioniert, nur langsamer)

Achten Sie auf

ONNX Runtime DirectML

# PowerShell
wmic path win32_VideoController get name

Aktualisierungen

Name
NVIDIA RTX A4000

Zukünftige Teile werden zur Kenntnis genommen, wenn sich die NPU-Unterstützung verbessert

Diese Reihe konzentriert sich auf

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

weil es reif und gut unterstützt in .NET ist, aber die Konzepte werden zu NPUs übersetzen, sobald das Ökosystem aufholt!:

• Überprüfen Sie Ihre GPUÜberprüfen Sie zunächst Windows sieht Ihre GPU:
• **Sie sollten so etwas wie sehen:**Oder verwenden Sie NVIDIA Control Panel → Systeminformationen → Registerkarte Display.
• Überblick über die ArchitekturSo funktioniert der Software-Stack:
• EbenenaufteilungNVIDIA-Treiber
• - Low-Level-GPU-KommunikationCUDA Toolkit

- APIs für die GPU-Programmierung

L 347 vom 20.12.2013, S. 671.

graph LR
    A[1. NVIDIA Driver] --> B[2. CUDA Toolkit]
    B --> C[3. cuDNN]
    C --> D[4. Verify Install]
    D --> E[5. Test from C#]

    class A,B,C,D,E steps

    classDef steps stroke:#333,stroke-width:2px

- Deep Neural Network Bibliothek (optimierte Kernel)

ONNX Laufzeit / LLamaSharp

• Hochrangige ML-Frameworks

nvidia-smi

Ihre Bewerbung

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

- Unser C#-Code:

• Driver VersionFahrplan für die Installation
• CUDA VersionHier ist die Reihenfolge, die wir installieren (Bestellung zählt!):
• Memory-UsageSchritt 1: NVIDIA-Treiber

Aktuelle Treiber überprüfen

PowerShell öffnen:nvidia-smiSie sollten die Ausgabe sehen wie:

1. Schlüsselinfos: Soll 545.xx oder neuer sein

2. : Dies ist die MAX CUDA Version unterstützt, nicht das, was installiert ist

   • : Derzeit verwendet / VRAM insgesamtTreiber aktualisieren, wenn nötig
   • Wennfunktioniert nicht oder Ihr Fahrer ist alt:
   • Gehen Sie zuNVIDIA Treiber Downloads
   • Wählen:**Produkttyp:**RTX/Quadro
   • Erzeugnisreihe:RTX-Axxxx-SerieErzeugnis:

3. NT1 ENTWICKLUNG NT1 ENTWICKLUNG NT1 ENTWICKLUNG NT1 ENTWICKLUNG NT1 ENTWICKLUNG NT1 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG NT2 ENTWICKLUNG

4. Betriebssystem:nvidia-smi

Fenster 11

(oder Ihre Version)

Download-Typ:

Studio-Treiber(stabiler als das Spiel)Installieren und NeustartenÜberprüfen Sie erneut mit

• Schritt 2: CUDA ToolkitCUDA bietet die Programmierschnittstelle für die GPU-Beschleunigung.
• VersionsauswahlKritisch
• : Wir brauchenKUDA

12.x für moderne Modelle.

1. Insbesondere:CUDA 12.1+
2. • Gute Balance von Kompatibilität und Funktionen (zum Zeitpunkt des Schreibens)Letzte 12.x- Kompatibilität mit Ihren Bibliotheken prüfen
3. NICHT CUDA 11.x- Fehlende Funktionen neuere Modelle benötigen
4. & Installieren herunterladen

Gehen Sie zu

CUDA Toolkit Archiv

Installation Type: Custom (Advanced)

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

WählenCUDA Toolkit 12.1

(oder 12.3, wenn du abenteuerlustig bist)

Wählen Sie:

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

Fenster → x86_64 → 11 → exe (lokal)

Herunterladen (~3GB)

Installationsoptionen

Führen Sie den Installer aus.:

$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

Nach Aufforderung::

1. Warum Brauch?: Wir wollen unseren Treiber nicht herunterfahren oder Gaming-Software installieren.:

   • InstallationspfadThis PCDer Standardpfad ist in Ordnung:

2. Aber beachten Sie dies - wir werden es für Umgebungsvariablen brauchen!Umgebungsvariablen einstellenDer Installer setzt diese in der Regel, aber verifizieren Sie:

   • 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. Einchecken PowerShellPathWenn fehlt, fügen Sie manuell hinzu

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

4. ÖffnenUmgebungsvariablen

Rechtsklick

# 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

→ Eigenschaften → Erweiterte Systemeinstellungen → Umgebungsvariablen

Unter

Systemvariablen

, überprüfen/hinzufügen:: Imvariabel, um sicherzustellen, dass diese vorhanden sind:

Starten Sie Ihr Terminal neufür das Wirksamwerden der ÄnderungenCUDA-Installation überprüfen**Schritt 3: cuDNN (CUDA Deep Neural Network Library)**cuDNN bietet optimierte Implementierungen von Deep-Learning-Operationen.

Versionskompatibilität

1. KritischL 347 vom 20.12.2013, S. 671.
2. Version muss mit CUDA Version übereinstimmen!
3. FürCUDA 12.x
4. , wir brauchencudNN 8.9+
5. für CUDA 12.x (zum Zeitpunkt des Schreibens, 8.9.7 oder höher)

CuDNN herunterladen

Gehen Sie zu

cuDNN ArchivSie benötigen ein NVIDIA Developer-Konto (kostenlos)

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)

Suchen::

# Assuming you extracted to Downloads and CUDA is in default location
# Run PowerShell as Administrator

$cudnnPath = "$env:USERPROFILE\Downloads\cudnn-windows-x86_64-8.9.7.29_cuda12-archive"
$cudaPath = "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1"

# Copy DLLs
Copy-Item "$cudnnPath\bin\*.dll" -Destination "$cudaPath\bin\"

# Copy headers
Copy-Item "$cudnnPath\include\*.h" -Destination "$cudaPath\include\"

# Copy libs
Copy-Item "$cudnnPath\lib\x64\*.lib" -Destination "$cudaPath\lib\x64\"

Download cuDNN v8.9.7 (5. Dezember 2023), für CUDA 12.x:

1. Wählen:bin\Lokale Installation für Windows (Zip)C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\
2. Herunterladen (~800MB)include\CuDNN extrahieren und installierenC:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\
3. cuDNN ist nur ein Satz von Dateien, die Sie in Ihre CUDA-Installation kopieren.lib\x64\ZIP extrahierenC:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\

Sie werden sehen:

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

Dateien in die CUDA-Installation kopieren

Oder machen Sie es manuell

Kopieren Sie alle Dateien aus

nvidia-smi

zu

Kopieren Sie alle Dateien aus

nvcc --version

zu

Kopieren Sie alle Dateien aus

# All these should return paths
$env:CUDA_PATH
$env:CUDA_PATH_V12_1

# Check PATH includes CUDA bin
$env:PATH -split ';' | Select-String CUDA

zu

cuDNN-Installation überprüfen

Schritt 4: Vollständige Überprüfung:

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

Stellen wir sicher, dass alles zusammen funktioniert.:

cd "1_Utilities\deviceQuery"

Überprüfung der HardwareSollte Ihre GPU ohne Fehler zeigen.

# 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-Prüfung:

.\x64\Release\deviceQuery.exe

Sollte CUDA 12.1 anzeigen (oder welche Version Sie installiert haben).

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

Systemvariablen prüfen: Result = PASS

CUDA-Probentest (optional, aber empfohlen)

Das CUDA Toolkit enthält Beispielprogramme.

Lassen Sie uns eins kompilieren und ausführen.

Zu den Proben navigieren

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

Gerät suchenQuery

Kompilieren(erfordert Visual Studio):

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

Führen Sie es aus.

• Microsoft.ML.OnnxRuntimeSie sollten die Ausgabe sehen wie:
• Microsoft.ML.OnnxRuntime.GpuDie Schlüsselzeile

Wenn Sie das sehen, funktioniert Ihr GPU + CUDA + cuDNN Stack!

Schritt 5: Prüfung von 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 ===");
        }
    }
}

Jetzt der lustige Teil - lassen Sie uns tatsächlich CUDA von C# verwenden!:

1. Testprojekt erstellenONNX-Laufzeit mit CUDA hinzufügen

   • DeviceIdONNX Laufzeit
   • ist der einfachste Weg CUDA von C# zu verwenden.

2. Warum dieses Paket?- Nur CPU

   • • Inklusive CUDA-Unterstützung
   • Prüfcode: GPU-Erkennung

3. ErstellenCode-Aufschlüsselung

   • OrtCUDAProvideroptionen
   • • Konfiguriert die CUDA-Ausführung

- Welche GPU zu verwenden ist (0 für die erste GPU)

dotnet run

Kann Speichergrenzen, Optimierungsniveau, etc. setzen.:

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

SessionOptionen.AppendExecutionProvider_CUDA()

- Sagt ONNX Laufzeit zu verwenden GPU

Wenn dies gelingt, arbeitet CUDAWenn es fehlschlägt, ist etwas im Stapel kaputt.

OrtEnv.Instance().GetavailableProviders():

# 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

- Listet alle verfügbaren Ausführungsanbieter auf

Sollte "CUDAExecutionProvider" enthalten, wenn alles korrekt installiert istZeigt auch "CPUExecutionProvider" als Fallback

Führen Sie den Test aus:

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

Erwartete Produktion

Fehlerbehebung bei häufigen FehlernFehler: "DllNotFoundException: DLL 'onnxruntime' kann nicht geladen werden"

Ursache: ONNX Runtime kann keine CUDA DLLs finden.

Fixieren

Fehler: "CUDAExecutionProvider nicht gefunden"

Ursache

: Falsches ONNX Runtime-Paket (nur CPU) verwenden.

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

Fixieren

Fehler: "CUDA-Fehlercode: 35 (CUDA-Treiberversion ist unzureichend)"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;
        }
    }
}

Ursache:

1. **: Treiber ist zu alt für CUDA 12.x.**Fixieren

   • : Aktualisieren Sie den NVIDIA-Treiber auf 545.xx oder neuer.[1, 1, 28, 28]Fortgeschrittener Test: Tatsächliche Schlussfolgerung

2. **Lassen Sie uns etwas Reales tun - führen Sie ein winziges neuronales Netzwerk auf GPU vs CPU und vergleichen Sie Geschwindigkeiten.**Testmodell herunterladen

   • Wir verwenden ein einfaches MNIST-Digitalerkennungsmodell (ONNX-Format).

3. Prüfcode für die SchlussfolgerungAktualisieren

   • Code-Erläuterung

4. DenseTensor- ONNX Runtimes Art und Weise, mehrdimensionale Arrays darzustellen

Form

dotnet run

= Batch_size=1, Kanäle=1, Höhe=28, Breite=28Benannt nachOnnxValue

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

- Verbindet einen Tensor mit einem Eingabenamen

• "Input3" ist der Eingabename im MNIST-Modell
• Aufwärmlauf
• • Erste Inferenz ist immer langsamer (Modellbeladung, Optimierung)

Wir laufen einmal vor dem Timing, um genaue Messungen zu erhalten

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

- Durchschnitt über 100 Iterationen für stabile Ergebnisse

Leistungstest ausführen

Erwartete Produktion

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

(Ihre Zahlen variieren)::

1. **Warum so eine kleine Beschleunigung?**MNIST ist winzig (nur 100KB Modell)
2. Overhead der GPU-Datenübertragung dominiertFür größere Modelle (1GB+) sehen Sie 10-100x Speedups
3. Schlüssel zum MitnehmenWir haben bewiesen, dass der gesamte Stapel funktioniert:

Leistungsfähigkeit verstehen

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

Speicherübertragung Engpass:

• **Folgendes passiert während der Schlussfolgerung:**Leistungsunterricht
• Batch-Verarbeitung- Übertragen Sie viele Eingänge auf einmal, um Overhead zu amortisieren

Daten auf der GPU aufbewahren

• - Kettenoperationen, um Übertragungen zu vermeidenGrößere Modelle profitieren mehr
• - Fixe Transferkosten, SkalierungsrechnungWann GPU vs CPU verwendet werden soll
• FaustregelGPU

- Große Modelle, Stapelverarbeitung, Einbettung Generation

CPU

1. ✅ Installed NVIDIA driver (545.xx+)
2. ✅ Installed CUDA Toolkit 12.1
3. ✅ Integrated cuDNN 8.9.7
4. ✅ Verified with nvidia-smi- Kleine Modelle, Einzelwünsche, Latenz-kritischnvcc
5. ✅ Tested GPU access from C# with ONNX Runtime
6. ✅ Ran performance comparison (GPU vs CPU)

Für unseren Blog-Schreibassistenten:

Einbettungen

• Batch Prozess 100+ Stücke → GPULLM-Schlussfolgerung- Großes Modell (7B-Params) → GPU

• Vektorsuche

• • Abhängig von der DB-Auswahl, oft CPU-gebunden

• Zusammenfassung

• Wir haben es geschafft:

• und

Unsere Entwicklungsumgebung ist jetzt bereit für KI-Workloads!

Was kommt als Nächstes?

Im

# 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

Teil 3

Wir tauchen tief in Einbettungen und Vektordatenbanken ein: |-------|-------|-----| | nvidia-smiWas sind Einbettungen und wie ermöglichen sie semantische Suche? | nvccAuswahl zwischen Qdrant, pgvector und anderen Optionen Einbettungen lokal mit ONNX Laufzeit erzeugen Millionen von Vektoren effizient speichern und abfragenMicrosoft.ML.OnnxRuntime.Gpu | Bau unseres ersten semantischen Suchprototyps

Wir werden endlich anfangen, mit aktuellen Blog-Inhalten zu arbeiten und RAG in Aktion zu sehen!

Referenz zur Fehlerbehebung |--------------|---------------|--------------|-----------------| Schnelle Diagnosebefehle Gemeinsame Fragen Fehler beheben

Treiber nicht installiert Installieren NVIDIA-Treiber

• nicht gefunden CUDA nicht in PATH , CUDA bin zu PATH , CUDA hinzufügen
• • DLL-Last fehlgeschlagen • cuDNN fehlt • cuDNN-Dateien in CUDA dir? • cuDNN-Dateien kopieren • cuDNN-Dateien in CUDA dir? • cuDNN-Dateien in CUDA dir? • cuDNN-Dateien in cuDNN-Dateien kopieren • cuDNN-Dateien in cuDNN-Dateien kopieren • cuDNN-Dateien in cuDNN-Dateien kopieren • cuDNN-Dateien in cuDNN-Dateien kopieren • cuDNN-Dateien in cuDNN-Dateien kopieren • cuDNN-Dateien in cuDNN-Dateien kopieren • cuDNN-Dateien in cuDNN-Dateien kopierenNicht gefunden CUDA-Anbieter Falsches NuGet-Paket verwenden
• Die Treiberversion ist unzureichend.Alter Treiber. Aktualisieren Sie auf 545.xx+.
• Matrix für Versionskompatibilität
• CUDA-Version cuDNN-Version ONNX-Laufzeit-Treiber erforderlich
• 12.1 8.9.7.1 1.16.x .545.xx+ .
• 12.3.9.0.0.1.17.x.546.xx+.
• 11,8,8,2,2,1,15,x,520,xx+,

Reihennavigation

• Teil 1: Einführung & Architektur
• Teil 2: GPU-Einrichtung und CUDA in C#
• (dieser Posten)
• Teil 3: Einbettungen und Vektordatenbanken verstehen

Teil 4: Aufbau der Ingestion PipelineTeil 5: Der Windows ClientTeil 6: Lokale LLM-Integration