# Costruire un "GPT avvocato" per il tuo blog - Parte 2: Configurazione GPU & CUDA in C# > ATTENZIONE: Questi sono i progetti di POST che sono "scaparnati." E 'probabile che gran parte di ciò che è qui sotto non funzionerà; Io generare questi come come come-per me e poi fare tutti i passi e ottenere il campione di lavoro app ... Sei stato subdolo e li hai visti! saranno probabilmente pronti a metà dicembre. ## Introduzione Benvenuti alla Parte 2![Dentro](/blog/building-a-lawyer-gpt-for-your-blog-part1)Parte 1 > , abbiamo esposto la visione per la costruzione di un assistente di scrittura che utilizza il tuo blog come base di conoscenze - come come gli avvocati utilizzano LLMs addestrati sulla giurisprudenza per redigere documenti. **Ora è il momento di sporcarci le mani con le fondamenta: assicuratevi che la vostra GPU sia pronta per i carichi di lavoro AI.**NOTA: Questo fa parte dei miei esperimenti con l'AI (elaborazione assistita) + il mio editing. Stessa voce, stesso pragmatismo, solo dita piu' veloci.[Informazioni sul mio hardware](https://developer.nvidia.com/cuda-toolkit): Sto usando una NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X e 96GB DDR5 RAM.[Ma questo non ti serve!](https://developer.nvidia.com/cudnn)Come coperto nella Parte 1, è possibile utilizzare qualsiasi GPU NVIDIA con VRAM 8GB+, o anche eseguire CPU-Solo (più lento ma funzionale). [TOC] ## Questa parte si concentra sulla configurazione della GPU, ma noterò alternative solo per la CPU, se pertinenti. Questa parte potrebbe sembrare di base se hai già familiarità con ### CUDACity name (optional, probably does not need a translation) ```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 ``` **, ma fidati di me - Ho sprecato innumerevoli ore di debug errori misteriosi che hanno fatto risalire a mancanze di versione, variabili d'ambiente mancanti, o errati**: 1. **CUDNN**impianti. 2. **Lo faremo fin dall'inizio.**Perché le questioni di accelerazione GPU 3. **Prima di immergerci nell'installazione, cerchiamo di capire perché abbiamo bisogno di accelerazione GPU a tutti.**CPU vs GPU per carichi di lavoro AI 4. **Perché le GPU dominano per l'IA**Parallelismo **- Le GPU hanno migliaia di core contro le dozzine di CPU**Operazioni di matrice - **- IA è principalmente matematica matrice, che GPU eccelle a**Larghezza di banda della memoria - **- Le GPU spostano i dati molto più velocemente**Hardware specializzato - I core del tensore accelerano le operazioni AI-specifiche **Esempio del mondo reale**Generazione di embeddings per un post sul blog: - **CPU (Ryzen 9 9950X)**: ~5 secondi per post - **GPU (A4000 16GB)**: ~0,3 secondi per post - **Questo è 16x più veloce, e si compone quando l'elaborazione di centinaia di post!**Prestazioni su altre GPU - (approssimativo): ## NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT2 NT2 NT2 NT2 NT2 NT2 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT1 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT1 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 NT2 (24GB): Più veloce, ~0.2s per posta ### RTX 3060 (12GB): ~0.5s per post - **GTX 1070 Ti**(8GB): ~0,8s per post - **Ancora molto più veloce della CPU!**Comprendere l'hardware - **Prima di installare qualcosa, cerchiamo di capire con cosa stiamo lavorando.**La mia GPU: NVIDIA RTX A4000 - **Questa è la mia GPU specifica - una scheda di postazione di lavoro professionale con:**16GB GDDR6 VRAM ### - Abbastanza per i modelli di parametri 7B-13B 6144 nuclei di CUDA - Potenza di elaborazione parallela |-----|------|----------------|----------| 256 Core del tensore - Operazioni di IA accelerate Capacità di calcolo CUDA 8.6 - Importante per la compatibilità Opzioni GPU comuni Ecco cosa possono gestire le varie GPU: ### | GPU | VRAM | Max Model Size | Good For | | RTX 4090 | 24GB | 13B-30B | Sovraccarico per questo progetto |**| RTX 4070 Ti | 12GB | 7B-13B | Ottima scelta |** **| RTX 3060 | 12GB | 7B | Budget-friendly |**| RTX 4060 Ti | 16GB | 7B-13B | Grande valore | **| A4000 (mine) | 16GB | 7B-13B | GPU della stazione di lavoro |**: - **| GTX 1070 Ti | 8GB | 7B (tiepido) | Minimo vitale |**Che dire delle NPU Intel/AMD? - **Potresti aver sentito parlare di chip Intel Core Ultra o AMD Ryzen AI con NPU integrate (Neural Processing Units).**Puoi usarli al posto di NVIDIA? - **Risposta breve**: Non ancora, ma forse nel 2024-2025! - **Limitazioni attuali**Nessun CUDA **: Le NPU non supportano CUDA, che questo tutorial utilizza**: - Supporto .NET limitato - : Il supporto NPU di ONNX Runtime è sperimentale[Compatibilità del modello](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html): La maggior parte dei modelli GGUF target CUDA/CPU - Supporto DirectML : Ancora in maturazione per i LLM**Se hai una CPU dotata di NPU**Usare solo la modalità CPU per ora (tutto funziona, solo più lentamente) ### Guarda per ONNX Runtime DirectML ```bash # PowerShell wmic path win32_VideoController get name ``` aggiornamenti ``` Name NVIDIA RTX A4000 ``` Le parti future noteranno quando il supporto NPU migliora ### Questa serie si concentra su: 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 ``` **perché è maturo e ben supportato in .NET, ma i concetti si tradurranno in NPU una volta che l'ecosistema raggiunge!**: - **Controlla la tua GPU**In primo luogo, verificare Windows vede la tua GPU: - **Dovresti vedere qualcosa come:**O utilizzare NVIDIA Pannello di controllo → Informazioni di sistema → Scheda di visualizzazione. - **Panoramica dell'architettura**Ecco come funziona lo stack software: - **Ripartizione dei livelli**Driver NVIDIA - **- Comunicazione GPU di basso livello**Kit strumenti CUDA ## - API per la programmazione GPU CUDNN ```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 libreria (semi ottimizzati) ### ONNX Runtime / LLamaSharp - quadri ML di alto livello ```bash nvidia-smi ``` La tua domanda ``` +-----------------------------------------------------------------------------+ | 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 | +-------------------------------+----------------------+----------------------+ ``` **- Il nostro codice C#**: - `Driver Version`Tabella di marcia per l'installazione - `CUDA Version`Ecco l'ordine che installeremo le cose (ordinare le cose!): - `Memory-Usage`Passo 1: Driver NVIDIA ### Controlla il driver corrente Apri PowerShell:`nvidia-smi`Dovresti vedere l'output come: 1. Informazioni chiave[: Dovrebbe essere 545.xx o più recente](https://www.nvidia.com/Download/index.aspx) 2. : Questa è la versione MAX CUDA supportata, non ciò che è installato - : Attualmente usato / VRAM totale**Aggiorna driver se necessario** - Se**non funziona o l'autista è vecchio:** - Vai a**Driver NVIDIA Download** - Seleziona:**Tipo di prodotto:**RTX/Quadro - Serie di prodotti:**RTX Axxxx Series**Prodotto: 3. RTX A4000 4. Sistema operativo:`nvidia-smi` ## Windows 11 (o la tua versione) ### Tipo di download: **Driver di studio**(più stabile del gioco pronto)[Installa e riavvia](https://developer.nvidia.com/cuda-toolkit)Verifica di nuovo con - **Passo 2: CUDA Toolkit**CUDA fornisce l'interfaccia di programmazione per l'accelerazione della GPU. - **Selezione versione**Critico - **: Abbiamo bisogno**CUDACity name (optional, probably does not need a translation) ### 12.x per modelli moderni. 1. In particolare:[CUDA 12.1+](https://developer.nvidia.com/cuda-toolkit-archive) 2. - Buon equilibrio di compatibilità e caratteristiche (al momento della scrittura)**Ultimi 12.x**- Controlla la compatibilità con le tue librerie 3. NON CUDA 11.x**- Mancano le caratteristiche di nuovi modelli bisogno** 4. Scarica e installa ### Vai a Archivio toolkit CUDA ``` Installation Type: Custom (Advanced) Select Components: ✅ CUDA Toolkit ✅ CUDA Documentation ✅ CUDA Samples ✅ CUDA Visual Studio Integration ❌ GeForce Experience (not needed) ❌ NVIDIA Driver (already installed) ``` **Seleziona**CUDA Toolkit 12.1 ### (o 12.3 se sei avventuroso) Scegli: ``` C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1 ``` Finestre → x86_64 → 11 → exe (locale) ### Scaricamento (~3GB) Opzioni di installazione **Esegui l'installatore.**: ```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 ``` **Quando richiesto:**: 1. Perche' personalizzato?**: Non vogliamo declassare il nostro driver o installare software di gioco.**: - Percorso di installazione`This PC`Il percorso predefinito va bene: 2. Ma notate questo - ne avremo bisogno per le variabili d'ambiente!**Imposta variabili d' ambiente**L'installatore di solito li imposta, ma verifica: - `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. Check in PowerShell`Path`Se manca, aggiungere manualmente ``` C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp ``` 4. **Apri**Variabili di ambiente ### Fare clic con il tasto destro del mouse ```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 ``` ## → Proprietà → Impostazioni avanzate del sistema → Variabili d'ambiente Sotto ### Variabili di sistema **, verificare/aggiungere:**: [Dentro](https://developer.nvidia.com/cudnn)variabile, assicurarne l'esistenza: Riavvia il terminale**per l'entrata in vigore delle modifiche**Verificare l'installazione di CUDA**Passo 3: cuDNN (libreria CUDA Deep Neural Network)**cuDNN fornisce implementazioni ottimizzate delle operazioni di deep learning. ### Compatibilità della versione 1. Critico[CUDNN](https://developer.nvidia.com/rdp/cudnn-archive) 2. la versione deve corrispondere alla versione CUDA! 3. Per**CUDA 12.x** 4. , abbiamo bisogno**cuDNN 8.9+** 5. per CUDA 12.x (al momento della scrittura, 8.9.7 o successivo) ### Scarica cuDNN Vai a **Archivio cuDNN**Avrai bisogno di un account NVIDIA Developer (gratuito) ``` 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) ``` **Trova:**: ```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\" ``` **Scarica cuDNN v8.9.7 (5 dicembre 2023), per CUDA 12.x**: 1. Seleziona:`bin\`Installatore locale per Windows (Zip)`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\` 2. Download (~800MB)`include\`Estrazione e installazione di cuDNN`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\` 3. cuDNN è solo un insieme di file che copiate nella vostra installazione CUDA.`lib\x64\`Estrai lo ZIP`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\` ### , vedrai: ```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" ``` ## Copia i file nell'installazione CUDA O fallo manualmente. ### Copia tutti i file da ```powershell nvidia-smi ``` a ### Copia tutti i file da ```powershell nvcc --version ``` a ### Copia tutti i file da ```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 ``` ### a Verificare l'installazione di cuDNN **Fase 4: Verifica completa**: ```powershell cd "C:\ProgramData\NVIDIA Corporation\CUDA Samples\v12.1" ``` **Assicuriamoci che tutto funzioni insieme.**: ```powershell cd "1_Utilities\deviceQuery" ``` **Controllo hardware**Dovrebbe mostrare la tua GPU senza errori. ```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 ``` **Controllo CUDA**: ```powershell .\x64\Release\deviceQuery.exe ``` Dovrebbe mostrare CUDA 12.1 (o qualsiasi versione tu abbia installato). ``` 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 ``` **Controllo delle variabili di sistema**: `Result = PASS` Test dei campioni CUDA (facoltativo ma raccomandato) ## Il kit di strumenti CUDA include programmi di esempio. Compiliamo ed eseguiamo uno. ### Vai ai campioni ```bash mkdir CudaTest cd CudaTest dotnet new console -n CudaTest cd CudaTest ``` ### Trova dispositivoQuery [Compilalo](https://onnxruntime.ai/)(richiede Visual Studio): ```bash dotnet add package Microsoft.ML.OnnxRuntime.Gpu # Latest version ``` **Eseguilo.** - `Microsoft.ML.OnnxRuntime`Dovresti vedere l'output come: - `Microsoft.ML.OnnxRuntime.Gpu`La linea chiave ### Se vedete questo, la vostra GPU + CUDA + cuDNN stack sta funzionando! Passo 5: Testing from 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 ==="); } } } ``` **Ora la parte divertente - usiamo effettivamente CUDA da C#!**: 1. **Crea progetto di prova**Aggiungi ONNX Runtime con CUDA - `DeviceId`ONNX Runtime - è il modo più semplice per usare CUDA da C#. 2. **Perche' questo pacco?**- Solo CPU - - Include il supporto CUDA - Codice di prova: Rilevamento GPU 3. **Crea**Ripartizione del codice - Opzioni di OrtCUDAProvider - - Configura l'esecuzione CUDA ### - Quale GPU usare (0 per la prima GPU) ```bash dotnet run ``` **Può impostare limiti di memoria, livello di ottimizzazione, ecc.**: ``` === 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 === ``` ### Opzioni di sessione.Applica esecuzioneProvider_CUDA() #### - Dice a ONNX Runtime di usare la GPU **Se questo riesce, CUDA sta funzionando**Se fallisce, qualcosa nella pila è rotto **OrtEnv.Instance().GetAvailableProvider()**: ```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 ``` #### - Elenca tutti i fornitori di esecuzione disponibili **Dovrebbe includere "CUDAExecutionProvider" se tutto è installato correttamente**Mostra anche "CPUExecutionProvider" come ripiego **Eseguire il test**: ```bash dotnet remove package Microsoft.ML.OnnxRuntime dotnet add package Microsoft.ML.OnnxRuntime.Gpu --version 1.16.3 ``` #### Uscita prevista **Risoluzione dei problemi Errori comuni**Errore: "DllNotFoundException: Impossibile caricare DLL 'onnxruntime'" **Causa**: ONNX Runtime non riesce a trovare le DLL CUDA. ## Correggi Errore: "CUDAExecutionProvider non trovato" ### Causa : Utilizzo del pacchetto ONNX Runtime sbagliato (solo CPU). ```powershell # Download sample model Invoke-WebRequest -Uri "https://github.com/onnx/models/raw/main/vision/classification/mnist/model/mnist-8.onnx" -OutFile "mnist.onnx" ``` ### Correggi Errore: "Codice errore CUDA: 35 (la versione del driver CUDA è insufficiente)"`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; } } } ``` **Causa**: 1. **: Il conducente è troppo vecchio per CUDA 12.x.**Correggi - : Aggiornare driver NVIDIA a 545.xx o più recente.`[1, 1, 28, 28]`Test avanzato: Inferenza effettiva 2. **Facciamo qualcosa di reale - esegui una piccola rete neurale su GPU vs CPU e confronta velocità.**Scaricare un modello di prova - Utilizzeremo un semplice modello di riconoscimento digitale MNIST (formato ONNX). 3. **Codice di prova dell'inferenza**Aggiorna - Spiegazione del codice 4. **DenseTensor**- Il modo di rappresentare gli array multidimensionali di ONNX Runtime ### Forma ```bash dotnet run ``` **= batch_size=1, canali=1, altezza=28, larghezza=28**NamedOnnxValue ``` === 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 ``` **- Conduce un tensore a un nome di input** - "Input3" è il nome di ingresso nel modello MNIST - Riscaldamento in esecuzione - - La prima inferenza è sempre più lenta (caricamento del modello, ottimizzazione) ### Scappiamo una volta prima del tempo per ottenere misurazioni accurate Metodologia dei tempi ✅ Driver installed correctly ✅ CUDA Toolkit accessible ✅ cuDNN integrated ✅ ONNX Runtime finds CUDA ✅ C# can run GPU-accelerated inference ## - Media oltre 100 iterazioni per risultati stabili ### Eseguire il test delle prestazioni Uscita prevista ```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 ``` **(i tuoi numeri variano):**: 1. **Perche' un cosi' piccolo velocita'?**MNIST è piccolo (solo modello 100KB) 2. **L'overhead del trasferimento dati GPU domina**Per i modelli più grandi (1GB+), vedrete 10-100x speedups 3. **Key TakeawayCity name (optional, probably does not need a translation)**Abbiamo dimostrato che l'intero stack funziona: ### Comprendere le prestazioni ```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 ``` **Memory Transfer Bottleneck**: - **Ecco cosa succede durante l'inferenza:**Lezioni di performance - **Elaborazione del lotto**- Trasferire molti input contemporaneamente per ammortizzare le spese generali Tenere i dati sulla GPU - **- Operazioni a catena per evitare trasferimenti**I modelli più grandi beneficiano di più - **- Costo fisso di trasferimento, calcolo scalare**Quando usare GPU vs CPU - **Regola del pollice**GPU ## - Modelli di grandi dimensioni, elaborazione batch, generazione embedding CPU 1. ✅ Installed NVIDIA driver (545.xx+) 2. ✅ Installed CUDA Toolkit 12.1 3. ✅ Integrated cuDNN 8.9.7 4. ✅ Verified with `nvidia-smi`- Piccoli modelli, singole richieste, latenza-critica`nvcc` 5. ✅ Tested GPU access from C# with ONNX Runtime 6. ✅ Ran performance comparison (GPU vs CPU) Per il nostro assistente di scrittura del blog: ## Incorporazioni - Processo batch 100+ pezzi → GPU**Inferenza LLM**- Modello grande (7B params) → GPU - Ricerca vettoriale - - Dipende dalla scelta del DB, spesso legato alla CPU - Sommario - Abbiamo avuto successo: - e Il nostro ambiente di sviluppo è ora pronto per carichi di lavoro AI! ## Cosa c'e' dopo? ### Dentro ```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 ``` ### Parte 3 , ci tufferemo in profondità in inglobi e database vettoriali: |-------|-------|-----| | `nvidia-smi`Quali sono le inserzioni e come permettono la ricerca semantica? | `nvcc`Scegliere tra Qdrant, pgvector e altre opzioni Generazione di embeddings localmente con ONNX Runtime Memorizzare e interrogare in modo efficiente milioni di vettori`Microsoft.ML.OnnxRuntime.Gpu` | Costruire il nostro primo prototipo di ricerca semantica ### Finalmente inizieremo a lavorare con i contenuti reali del blog e vedere RAG in azione! Riferimento per la risoluzione dei problemi |--------------|---------------|--------------|-----------------| Comandi diagnostici rapidi Questioni comuni | Errore | Causa | Corretto | ## non trovato | Driver non installato | Installa driver NVIDIA | - [non trovato | CUDA non in PATH | Aggiungi cestino CUDA a PATH |](/blog/building-a-lawyer-gpt-for-your-blog-part1) - **| Carico DLL non riuscito | Manca il cudNN | Copia i file cudNN in CUDA dir |**| Fornitore CUDA non trovato | Pacchetto NuGet errato | Uso - [| Versione del driver insufficiente | Vecchi driver | Aggiornamento a 545.xx+ |](/blog/building-a-lawyer-gpt-for-your-blog-part3) - [Matrice compatibilità versione](/blog/building-a-lawyer-gpt-for-your-blog-part4) - [| Versione CUDA | Versione cuDNN | Runtime ONNX | Driver required |](/blog/building-a-lawyer-gpt-for-your-blog-part5) - [| 12.1 | 8.9.7 | 1.16.x | 545.xx+ |](/blog/building-a-lawyer-gpt-for-your-blog-part6) - [| 12,3 | 9,0 | 1,17.x | 546.xx+ |](/blog/building-a-lawyer-gpt-for-your-blog-part7) - [| 11.8 | 8.9.2 | 1.15.x | 520.xx+ |](/blog/building-a-lawyer-gpt-for-your-blog-part8) ## Navigazione serie - [Parte 1: Introduzione e architettura](https://docs.nvidia.com/cuda/) - [Parte 2: Configurazione GPU & CUDA in C#](https://docs.nvidia.com/deeplearning/cudnn/api/index.html) - [(questo posto)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html) - [Parte 3: Comprensione delle basi di dati e dei vettori](https://developer.nvidia.com/) Parte 4: Costruzione del gasdotto per l'ingestione[Parte 5: Il client di Windows](/blog/building-a-lawyer-gpt-for-your-blog-part3)Parte 6: Integrazione LLM locale