# Aufbau einer "Rechtsanwalt GPT" für Ihr Blog - Teil 2: GPU Setup & CUDA in C# > 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 2![Im](/blog/building-a-lawyer-gpt-for-your-blog-part1)Teil 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](https://developer.nvidia.com/cuda-toolkit): Ich benutze einen NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X und 96GB DDR5 RAM.[Aber das brauchst du nicht!](https://developer.nvidia.com/cudnn)Wie in Teil 1 beschrieben, können Sie jede NVIDIA GPU mit 8GB+ VRAM verwenden oder sogar nur CPU laufen lassen (niedriger, aber funktional). [TOC] ## 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 ```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 ``` **, 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 dominieren**Parallelität **- GPUs haben Tausende von Kernen gegen CPUs Dutzende**Matrix-Operationen - **- KI ist meist Matrix-Mathematik, die GPUs zeichnen sich bei**Speicherbandbreite - **- GPUs verschieben Daten viel schneller**Spezialisierte 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 Projekt**RTX 4070 Ti- 12GB- 7B-13B- Ausgezeichnete Wahl** **RTX 3060 - 12GB - 7B - Budgetfreundlich**RTX 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änkungen**Keine CUDA **: NPUs unterstützen CUDA nicht, die dieses Tutorial verwendet**: - Begrenzte .NET-Unterstützung - : Die NPU-Unterstützung von ONNX Runtime ist experimentell[Kompatibilität des Modells](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html): Die meisten GGUF-Modelle zielen auf CUDA/CPU ab - Direkt-ML-Unterstützung : Reifung für LLMs**Wenn Sie eine NPU-ausgestattete CPU haben**Verwenden Sie jetzt nur CPU-Modus (alles funktioniert, nur langsamer) ### Achten Sie auf ONNX Runtime DirectML ```bash # 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 ```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 ``` **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 Architektur**So funktioniert der Software-Stack: - **Ebenenaufteilung**NVIDIA-Treiber - **- Low-Level-GPU-Kommunikation**CUDA Toolkit ## - APIs für die GPU-Programmierung L 347 vom 20.12.2013, S. 671. ```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 ``` ## - Deep Neural Network Bibliothek (optimierte Kernel) ### ONNX Laufzeit / LLamaSharp - Hochrangige ML-Frameworks ```bash 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 Version`Fahrplan für die Installation - `CUDA Version`Hier ist die Reihenfolge, die wir installieren (Bestellung zählt!): - `Memory-Usage`Schritt 1: NVIDIA-Treiber ### Aktuelle Treiber überprüfen PowerShell öffnen:`nvidia-smi`Sie sollten die Ausgabe sehen wie: 1. Schlüsselinfos[: Soll 545.xx oder neuer sein](https://www.nvidia.com/Download/index.aspx) 2. : Dies ist die MAX CUDA Version unterstützt, nicht das, was installiert ist - : Derzeit verwendet / VRAM insgesamt**Treiber aktualisieren, wenn nötig** - Wenn**funktioniert nicht oder Ihr Fahrer ist alt:** - Gehen Sie zu**NVIDIA Treiber Downloads** - Wählen:**Produkttyp:**RTX/Quadro - Erzeugnisreihe:**RTX-Axxxx-Serie**Erzeugnis: 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](https://developer.nvidia.com/cuda-toolkit)Überprüfen Sie erneut mit - **Schritt 2: CUDA Toolkit**CUDA bietet die Programmierschnittstelle für die GPU-Beschleunigung. - **Versionsauswahl**Kritisch - **: Wir brauchen**KUDA ### 12.x für moderne Modelle. 1. Insbesondere:[CUDA 12.1+](https://developer.nvidia.com/cuda-toolkit-archive) 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ählen**CUDA 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.**: ```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 ``` **Nach Aufforderung:**: 1. Warum Brauch?**: Wir wollen unseren Treiber nicht herunterfahren oder Gaming-Software installieren.**: - Installationspfad`This PC`Der Standardpfad ist in Ordnung: 2. Aber beachten Sie dies - wir werden es für Umgebungsvariablen brauchen!**Umgebungsvariablen einstellen**Der 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 PowerShell`Path`Wenn 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. **Öffnen**Umgebungsvariablen ### Rechtsklick ```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 ``` ## → Eigenschaften → Erweiterte Systemeinstellungen → Umgebungsvariablen Unter ### Systemvariablen **, überprüfen/hinzufügen:**: [Im](https://developer.nvidia.com/cudnn)variabel, um sicherzustellen, dass diese vorhanden sind: Starten Sie Ihr Terminal neu**für das Wirksamwerden der Änderungen**CUDA-Installation überprüfen**Schritt 3: cuDNN (CUDA Deep Neural Network Library)**cuDNN bietet optimierte Implementierungen von Deep-Learning-Operationen. ### Versionskompatibilität 1. Kritisch[L 347 vom 20.12.2013, S. 671.](https://developer.nvidia.com/rdp/cudnn-archive) 2. Version muss mit CUDA Version übereinstimmen! 3. Für**CUDA 12.x** 4. , wir brauchen**cudNN 8.9+** 5. für CUDA 12.x (zum Zeitpunkt des Schreibens, 8.9.7 oder höher) ### CuDNN herunterladen Gehen Sie zu **cuDNN Archiv**Sie 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:**: ```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\" ``` **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 installieren`C:\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 extrahieren`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\` ### Sie werden sehen: ```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" ``` ## Dateien in die CUDA-Installation kopieren Oder machen Sie es manuell ### Kopieren Sie alle Dateien aus ```powershell nvidia-smi ``` zu ### Kopieren Sie alle Dateien aus ```powershell nvcc --version ``` zu ### Kopieren Sie alle Dateien aus ```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 ``` ### zu cuDNN-Installation überprüfen **Schritt 4: Vollständige Überprüfung**: ```powershell cd "C:\ProgramData\NVIDIA Corporation\CUDA Samples\v12.1" ``` **Stellen wir sicher, dass alles zusammen funktioniert.**: ```powershell cd "1_Utilities\deviceQuery" ``` **Überprüfung der Hardware**Sollte Ihre GPU ohne Fehler zeigen. ```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-Prüfung**: ```powershell .\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 ```bash mkdir CudaTest cd CudaTest dotnet new console -n CudaTest cd CudaTest ``` ### Gerät suchenQuery [Kompilieren](https://onnxruntime.ai/)(erfordert Visual Studio): ```bash dotnet add package Microsoft.ML.OnnxRuntime.Gpu # Latest version ``` **Führen Sie es aus.** - `Microsoft.ML.OnnxRuntime`Sie sollten die Ausgabe sehen wie: - `Microsoft.ML.OnnxRuntime.Gpu`Die Schlüsselzeile ### Wenn Sie das sehen, funktioniert Ihr GPU + CUDA + cuDNN Stack! Schritt 5: Prüfung von 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 ==="); } } } ``` **Jetzt der lustige Teil - lassen Sie uns tatsächlich CUDA von C# verwenden!**: 1. **Testprojekt erstellen**ONNX-Laufzeit mit CUDA hinzufügen - `DeviceId`ONNX 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. **Erstellen**Code-Aufschlüsselung - OrtCUDAProvideroptionen - - Konfiguriert die CUDA-Ausführung ### - Welche GPU zu verwenden ist (0 für die erste GPU) ```bash 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 CUDA**Wenn es fehlschlägt, ist etwas im Stapel kaputt. **OrtEnv.Instance().GetavailableProviders()**: ```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 ``` #### - Listet alle verfügbaren Ausführungsanbieter auf **Sollte "CUDAExecutionProvider" enthalten, wenn alles korrekt installiert ist**Zeigt auch "CPUExecutionProvider" als Fallback **Führen Sie den Test aus**: ```bash dotnet remove package Microsoft.ML.OnnxRuntime dotnet add package Microsoft.ML.OnnxRuntime.Gpu --version 1.16.3 ``` #### Erwartete Produktion **Fehlerbehebung bei häufigen Fehlern**Fehler: "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. ```powershell # 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`: ```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; } } } ``` **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 Schlussfolgerung**Aktualisieren - Code-Erläuterung 4. **DenseTensor**- ONNX Runtimes Art und Weise, mehrdimensionale Arrays darzustellen ### Form ```bash dotnet run ``` **= Batch_size=1, Kanäle=1, Höhe=28, Breite=28**Benannt 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 ```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 ``` **(Ihre Zahlen variieren):**: 1. **Warum so eine kleine Beschleunigung?**MNIST ist winzig (nur 100KB Modell) 2. **Overhead der GPU-Datenübertragung dominiert**Für größere Modelle (1GB+) sehen Sie 10-100x Speedups 3. **Schlüssel zum Mitnehmen**Wir haben bewiesen, dass der gesamte Stapel funktioniert: ### Leistungsfähigkeit verstehen ```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 ``` **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 vermeiden**Größere Modelle profitieren mehr - **- Fixe Transferkosten, Skalierungsrechnung**Wann GPU vs CPU verwendet werden soll - **Faustregel**GPU ## - 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-kritisch`nvcc` 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 → GPU**LLM-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 ```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 ``` ### Teil 3 Wir tauchen tief in Einbettungen und Vektordatenbanken ein: |-------|-------|-----| | `nvidia-smi`Was sind Einbettungen und wie ermöglichen sie semantische Suche? | `nvcc`Auswahl zwischen Qdrant, pgvector und anderen Optionen Einbettungen lokal mit ONNX Laufzeit erzeugen Millionen von Vektoren effizient speichern und abfragen`Microsoft.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](/blog/building-a-lawyer-gpt-for-your-blog-part1) - **• 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 kopieren**Nicht gefunden CUDA-Anbieter Falsches NuGet-Paket verwenden - [Die Treiberversion ist unzureichend.Alter Treiber. Aktualisieren Sie auf 545.xx+.](/blog/building-a-lawyer-gpt-for-your-blog-part3) - [Matrix für Versionskompatibilität](/blog/building-a-lawyer-gpt-for-your-blog-part4) - [CUDA-Version cuDNN-Version ONNX-Laufzeit-Treiber erforderlich](/blog/building-a-lawyer-gpt-for-your-blog-part5) - [12.1 8.9.7.1 1.16.x .545.xx+ .](/blog/building-a-lawyer-gpt-for-your-blog-part6) - [12.3.9.0.0.1.17.x.546.xx+.](/blog/building-a-lawyer-gpt-for-your-blog-part7) - [11,8,8,2,2,1,15,x,520,xx+,](/blog/building-a-lawyer-gpt-for-your-blog-part8) ## Reihennavigation - [Teil 1: Einführung & Architektur](https://docs.nvidia.com/cuda/) - [Teil 2: GPU-Einrichtung und CUDA in C#](https://docs.nvidia.com/deeplearning/cudnn/api/index.html) - [(dieser Posten)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html) - [Teil 3: Einbettungen und Vektordatenbanken verstehen](https://developer.nvidia.com/) Teil 4: Aufbau der Ingestion Pipeline[Teil 5: Der Windows Client](/blog/building-a-lawyer-gpt-for-your-blog-part3)Teil 6: Lokale LLM-Integration