# Construyendo un "Abogado GPT" para su blog - Parte 2: Configuración de la GPU y CUDA en C#
2025-11-12T22:45
> ATENCIÓN: Estos son los proyectos de mensajes que se han "espaciado".
Es probable que gran parte de lo que está a continuación no funcione; Yo genera estos como cómo para MÍ y luego hacer todos los pasos y hacer que la aplicación de muestra funcione...¡Has sido astuto y los has visto!Probablemente estarán listos a mediados de diciembre.
## Introducción
¡Bienvenidos a la Parte 2Parte 1
> , expusimos la visión de construir un asistente de escritura que utilice su blog como base de conocimiento - como cómo los abogados utilizan LLMs entrenados en jurisprudencia para redactar documentos.
**Ahora es el momento de ensuciarnos las manos con la base: asegurarse de que su GPU esté lista para cargas de trabajo de IA.**NOTA: Esto es parte de mis experimentos con IA (redacción asistida) + mi propia edición.
La misma voz, el mismo pragmatismo; sólo los dedos más rápidos.[Acerca de mi hardware](https://developer.nvidia.com/cuda-toolkit): Estoy usando un NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X, y 96GB DDR5 RAM.[¡Pero no necesitas esto!](https://developer.nvidia.com/cudnn)Como se cubre en la Parte 1, puede utilizar cualquier GPU NVIDIA con 8GB+ VRAM, o incluso ejecutar sólo CPU (lento pero funcional).
[TOC]
## Esta parte se centra en la configuración de la GPU, pero notaré alternativas solo para CPU cuando sea relevante.
Esta parte puede parecer básica si ya estás familiarizado con
### CUDA
```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
```
**, pero confía en mí - He perdido innumerables horas depurando errores misteriosos que se remontan a los desajustes de versiones, variables de entorno faltantes, o incorrecto**:
1. **cuDNN**instalaciones.
2. **Lo haremos bien desde el principio.**Por qué importa la aceleración de la GPU
3. **Antes de sumergirnos en la instalación, vamos a entender por qué necesitamos aceleración GPU en absoluto.**CPU vs GPU para cargas de trabajo de IA
4. **Por qué las GPUs dominan para la IA**Paralelismo
**- Las GPUs tienen miles de núcleos contra docenas de CPUs.**Operaciones Matrix
- **- La IA es en su mayoría matemáticas de matriz, que GPUs sobresalen en**Ancho de banda de memoria
- **- Las GPUs mueven los datos mucho más rápido**Hardware especializado
- Los núcleos tensores aceleran las operaciones específicas de IA
**Ejemplo del mundo real**Generando incrustaciones para un post de blog:
- **CPU (Ryzen 9 9950X)**: ~5 segundos por mensaje
- **GPU (A4000 16GB)**: ~0.3 segundos por mensaje
- **¡Eso es 16 veces más rápido, y se compone al procesar cientos de postes!**Desempeño en otras GPUs
- (aproximado):
## RTX 4090
(24GB): Más rápido, ~0.2s por puesto
### RTX 3060
(12GB): ~0,5s por puesto
- **GTX 1070 Ti**(8GB): ~0.8s por puesto
- **¡Todavía mucho más rápido que la CPU!**Comprensión de su hardware
- **Antes de instalar cualquier cosa, vamos a entender con lo que estamos trabajando.**Mi GPU: NVIDIA RTX A4000
- **Esta es mi GPU específica - una tarjeta de estación de trabajo profesional con:**16GB GDDR6 VRAM
### - Suficiente para modelos de parámetros 7B-13B
6144 Núcleos CUDA
- Potencia de procesamiento paralela
|-----|------|----------------|----------|
256 Núcleos tensores
- Operaciones aceleradas de IA
CUDA Capacidad de cálculo 8.6
- Importante para la compatibilidad
Opciones comunes de GPU
Esto es lo que varias GPUs pueden manejar:
### GPU VRAM Max Tamaño del modelo bueno para
RTX 4090 24GB 13B-30B Overkill para este proyecto**RTX 4070 Ti 12GB 7B-13B Excelente elección**
**RTX 3060 12GB 7B Apto para el presupuesto**RTX 4060 Ti 16GB 7B-13B Gran valor
**A4000 (mina) 16GB 7B-13B Estación de trabajo GPU**:
- **GTX 1070 Ti 8GB 7B (ajustado) Mínimo viable**¿Qué hay de las NPUs Intel/AMD?
- **Es posible que haya oído hablar de Intel Core Ultra o AMD Ryzen AI chips con NPUs integradas (Unidades de procesamiento neuronal).**¿Puedes usarlos en lugar de NVIDIA?
- **Respuesta corta**: ¡Todavía no, pero tal vez en 2024-2025!
- **Limitaciones actuales**No CUDA
**: Las NPUs no soportan CUDA, que este tutorial utiliza**:
- Soporte .NET limitado
- : El soporte de la NPU de ONNX Runtime es experimental[Compatibilidad con los modelos](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html): La mayoría de los modelos GGUF se dirigen a CUDA/CPU
- Soporte DirectML
: Todavía madurando para LLMs**Si tiene una CPU equipada con NPU**Utilice el modo sólo CPU por ahora (todo funciona, sólo más lento)
### ¡Cuidado!
ONNX Runtime DirectML
```bash
# PowerShell
wmic path win32_VideoController get name
```
actualizaciones
```
Name
NVIDIA RTX A4000
```
Las partes futuras notarán cuando el apoyo de la NPU mejore
### Esta serie se centra en
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
```
**porque es maduro y bien apoyado en .NET, pero los conceptos se traducirán a NPUs una vez que el ecosistema alcance!**:
- **Compruebe su GPU**Primero, verifique que Windows vea su GPU:
- **Deberías ver algo como:**O utilice NVIDIA Panel de control → Información del sistema → Pantalla de pestaña.
- **Descripción general de la arquitectura**Así es como funciona la pila de software:
- **Desglose por capas**Controlador NVIDIA
- **- Comunicación GPU de bajo nivel**Kit de herramientas CUDA
## - APIs para la programación de 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
```
## - Biblioteca de Deep Neural Network (kernels optimizados)
### ONNX Duración / LLAMASharp
- Marcos de alto nivel para la lucha contra el blanqueo de dinero
```bash
nvidia-smi
```
Su aplicación
```
+-----------------------------------------------------------------------------+
| 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 |
+-------------------------------+----------------------+----------------------+
```
**- Nuestro código C#**:
- `Driver Version`Hoja de ruta de instalación
- `CUDA Version`Aquí está el orden que vamos a instalar las cosas (¡el orden importa!):
- `Memory-Usage`Paso 1: Conductor NVIDIA
### Comprobar el controlador actual
Abra PowerShell:`nvidia-smi`Debería ver la salida como:
1. Información clave[: Debe ser 545.xx o más reciente](https://www.nvidia.com/Download/index.aspx)
2. : Esta es la versión MAX CUDA soportada, no lo que está instalado
- : Utilizado actualmente / VRAM total**Actualizar el controlador si es necesario**
- Si**no funciona o tu conductor es viejo:**
- Ir a**Descargas del controlador NVIDIA**
- Seleccionar:**Tipo de producto:**RTX/Quadro
- Serie de productos:**Serie RTX Axxxx**Producto:
3. RTX A4000
4. Sistema operativo:`nvidia-smi`
## Ventanas 11
(o su versión)
### Tipo de descarga:
**Controlador de estudio**(más estable que Game Ready)[Instalar y reiniciar](https://developer.nvidia.com/cuda-toolkit)Verificar de nuevo con
- **Paso 2: Kit de herramientas CUDA**CUDA proporciona la interfaz de programación para la aceleración de GPU.
- **Selección de versiones**Crítico
- **: Necesitamos**CUDA
### 12.x para modelos modernos.
1. Concretamente:[CUDA 12,1+](https://developer.nvidia.com/cuda-toolkit-archive)
2. - Buen equilibrio de compatibilidad y características (en el momento de escribir)**Última 12.x**- Compruebe la compatibilidad con sus bibliotecas
3. NO CUDA 11.x**- Faltan características más nuevas que los modelos necesitan**
4. Descargar e instalar
### Ir a
Archivo de herramientas 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)
```
**Seleccionar**Instrumental CUDA 12.1
### (o 12.3 si eres aventurero)
Elija:
```
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1
```
Windows → x86_64 → 11 → exe (local)
### Descargar (~3GB)
Opciones de instalación
**Ejecute el instalador.**:
```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
```
**Cuando se le solicite:**:
1. ¿ Por qué es una costumbre?**: No queremos rebajar nuestro controlador o instalar software de juegos.**:
- Ruta de instalación`This PC`La ruta predeterminada está bien:
2. Pero tenga en cuenta esto - vamos a necesitarlo para las variables de entorno!**Establecer variables de entorno**El instalador generalmente establece estos, pero verificar:
- `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`Si falta, añadir manualmente
```
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp
```
4. **Abrir**Variables ambientales
### Haga clic con el botón derecho
```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
```
## → Propiedades → Configuración avanzada del sistema → Variables de entorno
Bajo
### Variables del sistema
**, verificar/agregar:**: [In](https://developer.nvidia.com/cudnn)Variable, asegúrese de que existen:
Reinicie su terminal**para que los cambios surtan efecto**Verificar la instalación de CUDA**Paso 3: CuDNN (Biblioteca de la Red Neural Profunda de CUDA)**cuDNN proporciona implementaciones optimizadas de operaciones de aprendizaje profundo.
### Compatibilidad con la versión
1. Crítico[cuDNN](https://developer.nvidia.com/rdp/cudnn-archive)
2. ¡La versión debe coincidir con la versión CUDA!
3. Por**CUDA 12.x**
4. , necesitamos**CuDNN 8,9+**
5. para CUDA 12.x (en el momento de redactarse el presente informe, 8,9.7 o posterior)
### Descargar cuDNN
Ir a
**Archivo cuDNN**Necesitarás una cuenta NVIDIA Developer (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)
```
**Buscar:**:
```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\"
```
**Descargar cuDNN v8.9,7 (5 de diciembre de 2023), para CUDA 12.x**:
1. Seleccionar:`bin\`Instalador local para Windows (Zip)`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\`
2. Descargar (~800MB)`include\`Extraer e instalar cuDNN`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\`
3. cuDNN es sólo un conjunto de archivos que copia en su instalación CUDA.`lib\x64\`Extraer el ZIP`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\`
### , ya verás:
```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"
```
## Copiar archivos a la instalación de CUDA
O hacerlo manualmente
### Copiar todos los archivos desde
```powershell
nvidia-smi
```
a
### Copiar todos los archivos desde
```powershell
nvcc --version
```
a
### Copiar todos los archivos desde
```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
Verificar la instalación de cuDNN
**Paso 4: Verificación completa**:
```powershell
cd "C:\ProgramData\NVIDIA Corporation\CUDA Samples\v12.1"
```
**Asegurémonos de que todo funcione juntos.**:
```powershell
cd "1_Utilities\deviceQuery"
```
**Comprobación de hardware**Debería mostrar su GPU sin errores.
```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
```
**Comprobación CUDA**:
```powershell
.\x64\Release\deviceQuery.exe
```
Debería mostrar CUDA 12.1 (o cualquier versión que haya instalado).
```
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
```
**Comprobación de las variables del sistema**: `Result = PASS`
Prueba de muestras CUDA (opcional pero recomendada)
## El kit de herramientas CUDA incluye programas de muestra.
Compilamos y ejecutamos uno.
### Navegue a las muestras
```bash
mkdir CudaTest
cd CudaTest
dotnet new console -n CudaTest
cd CudaTest
```
### Buscar dispositivoQuery
[Compilarlo](https://onnxruntime.ai/)(requiere Visual Studio):
```bash
dotnet add package Microsoft.ML.OnnxRuntime.Gpu # Latest version
```
**Ejecutalo.**
- `Microsoft.ML.OnnxRuntime`Debería ver la salida como:
- `Microsoft.ML.OnnxRuntime.Gpu`La línea de claves
### Si ves esto, ¡tu pila GPU + CUDA + cuDNN está funcionando!
Paso 5: Pruebas desde 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 ===");
}
}
}
```
**Ahora la parte divertida - vamos a utilizar realmente CUDA de C#!**:
1. **Crear proyecto de prueba**Añadir tiempo de ejecución de ONNX con CUDA
- `DeviceId`ONNX Runtime
- es la forma más fácil de usar CUDA desde C#.
2. **¿Por qué este paquete?**- Sólo CPU
- - Incluye soporte CUDA
- Código de ensayo: Detección de GPU
3. **Crear**Desglose por código
- OrtCUDAProviderOpciones
- - Configura la ejecución CUDA
### - Qué GPU usar (0 para la primera GPU)
```bash
dotnet run
```
**Puede establecer límites de memoria, nivel de optimización, 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 ===
```
### SessionOptions.AppendExecutionProvider_CUDA()
#### - Indica a ONNX Runtime que use GPU
**Si esto tiene éxito, CUDA está trabajando**Si falla, algo en la pila se rompe
**OrtEnv.Instance().ObtenerDisponibleProviders()**:
```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
```
#### - Lista todos los proveedores de ejecución disponibles
**Debe incluir "CUDAExecutionProvider" si todo está instalado correctamente**También muestra "CPUExecutionProvider" como reserva
**Ejecutar la prueba**:
```bash
dotnet remove package Microsoft.ML.OnnxRuntime
dotnet add package Microsoft.ML.OnnxRuntime.Gpu --version 1.16.3
```
#### Producto previsto
**Solución de problemas Errores comunes**Error: "DllNotFoundException: No se puede cargar DLL 'onnxruntime'"
**Causa**: ONNX Runtime no puede encontrar DLLs de CUDA.
## Arreglar
Error: "CUDAExecutionProvider no se encontró"
### Causa
: Usar el paquete de tiempo de ejecución ONNX incorrecto (sólo 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"
```
### Arreglar
Error: "Código de error de CUDA: 35 (la versión del controlador de CUDA es insuficiente)"`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. **: El conductor es demasiado viejo para CUDA 12.x.**Arreglar
- : Actualizar el controlador NVIDIA a 545.xx o más reciente.`[1, 1, 28, 28]`Prueba avanzada: Inferencia real
2. **Vamos a hacer algo real - ejecutar una pequeña red neuronal en GPU vs CPU y comparar las velocidades.**Descargar un modelo de prueba
- Usaremos un simple modelo de reconocimiento de dígitos MNIST (formato ONNX).
3. **Código de prueba de inferencia**Actualizar
- Explicación del código
4. **DenseTensor**- La forma en que ONNX Runtime representa los arrays multidimensionales
### Forma
```bash
dotnet run
```
**= lote_tamaño=1, canales=1, altura=28, ancho=28**NombreOnnxValue
```
=== 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
```
**- Ata un tensor a un nombre de entrada**
- "Input3" es el nombre de entrada en el modelo MNIST
- Calentamiento
- - La primera inferencia es siempre más lenta (carga de modelos, optimización)
### Corremos una vez antes de tiempo para obtener mediciones precisas
Metodología de cronometración
✅ Driver installed correctly
✅ CUDA Toolkit accessible
✅ cuDNN integrated
✅ ONNX Runtime finds CUDA
✅ C# can run GPU-accelerated inference
## - Promedio de más de 100 iteraciones para resultados estables
### Prueba de rendimiento de ejecución
Producto previsto
```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
```
**(sus números variarán):**:
1. **¿Por qué una velocidad tan pequeña?**MNIST es pequeño (sólo modelo 100KB)
2. **Predomina la transferencia de datos de la GPU**Para modelos más grandes (1GB+), verá velocidades de 10-100x
3. **Para llevar la llave**Hemos probado que toda la pila funciona:
### Comprensión del desempeño
```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
```
**Transferencia de memoria cuello de botella**:
- **Esto es lo que sucede durante la inferencia:**Enseñanzas sobre el desempeño
- **Procesamiento por lotes**- Transferir muchas entradas a la vez para amortizar los gastos generales
Mantener datos sobre la GPU
- **- Operaciones en cadena para evitar transferencias**Los modelos más grandes se benefician más
- **- Costo de transferencia fija, cálculo de escala**Cuándo usar GPU vs CPU
- **Regla general**GPU
## - Grandes modelos, procesamiento por lotes, generación de incrustaciones
CPU
1. ✅ Installed NVIDIA driver (545.xx+)
2. ✅ Installed CUDA Toolkit 12.1
3. ✅ Integrated cuDNN 8.9.7
4. ✅ Verified with `nvidia-smi`- Modelos pequeños, peticiones individuales, latencia crítica`nvcc`
5. ✅ Tested GPU access from C# with ONNX Runtime
6. ✅ Ran performance comparison (GPU vs CPU)
Para nuestro asistente de escritura de blog:
## Incrustaciones
- Proceso por lotes 100+ trozos → GPU**Inferencia de LLM**- Modelo grande (7B params) → GPU
- Búsqueda de vectores
- - Depende de la opción de DB, a menudo conectado a la CPU
- Resumen
- Hemos tenido éxito:
- y
¡Nuestro entorno de desarrollo ya está listo para cargas de trabajo de IA!
## ¿Qué sigue?
### In
```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
, nos sumergiremos profundamente en incrustaciones y bases de datos de vectores:
|-------|-------|-----|
| `nvidia-smi`¿Qué son incrustaciones y cómo permiten la búsqueda semántica?
| `nvcc`Elegir entre Qdrant, pgvector y otras opciones
Generando incrustaciones localmente con ONNX Runtime
Almacenamiento y consulta de millones de vectores de manera eficiente`Microsoft.ML.OnnxRuntime.Gpu` |
Construyendo nuestro primer prototipo de búsqueda semántica
### ¡Finalmente empezaremos a trabajar con contenido real de blog y veremos a RAG en acción!
Referencia de solución de problemas
|--------------|---------------|--------------|-----------------|
Comandos de diagnóstico rápido
Cuestiones comunes
# Error # # Causa # # Solución #
## no se encontró el controlador no instalado install NVIDIA driver
- [no se encuentra CUDA no en PATH Añadir CUDA bin a PATH](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- **DLL carga fallida cuDNN falta Copiar archivos cuDNN a CUDA dir**CUDA proveedor no encontrado mal paquete NuGet Uso
- [Versión de controlador insuficiente Antiguo controlador Actualización a 545.xx+](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [Matriz de compatibilidad de versiones](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [Versión CUDA Versión CuDNN Versión ONNX Runtime Requerido Driver](/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.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)
## Navegación en serie
- [Parte 1: Introducción y Arquitectura](https://docs.nvidia.com/cuda/)
- [Parte 2: Configuración de la GPU y CUDA en C#](https://docs.nvidia.com/deeplearning/cudnn/api/index.html)
- [(en este puesto)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
- [Parte 3: Comprender los embebidos y las bases de datos vectoriales](https://developer.nvidia.com/)
Parte 4: Construcción del oleoducto de ingestión[Parte 5: El cliente de Windows](/blog/building-a-lawyer-gpt-for-your-blog-part3)Parte 6: Integración local de la LLM