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: Estoy usando un NVIDIA RTX A4000 (16GB VRAM), AMD Ryzen 9 9950X, y 96GB DDR5 RAM.¡Pero no necesitas esto!Como se cubre en la Parte 1, puede utilizar cualquier GPU NVIDIA con 8GB+ VRAM, o incluso ejecutar sólo CPU (lento pero funcional).

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

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:

cuDNNinstalaciones.
**Lo haremos bien desde el principio.**Por qué importa la aceleración de la GPU
**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
Por qué las GPUs dominan para la IAParalelismo

**- 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 enAncho de banda de memoria
- Las GPUs mueven los datos mucho más rápidoHardware especializado
Los núcleos tensores aceleran las operaciones específicas de IA

Ejemplo del mundo realGenerando 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 proyectoRTX 4070 Ti 12GB 7B-13B Excelente elección

RTX 3060 12GB 7B Apto para el presupuestoRTX 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 actualesNo CUDA

: Las NPUs no soportan CUDA, que este tutorial utiliza:

Soporte .NET limitado
: El soporte de la NPU de ONNX Runtime es experimentalCompatibilidad con los modelos: La mayoría de los modelos GGUF se dirigen a CUDA/CPU
Soporte DirectML

: Todavía madurando para LLMsSi tiene una CPU equipada con NPUUtilice el modo sólo CPU por ahora (todo funciona, sólo más lento)

¡Cuidado!

ONNX Runtime DirectML

# 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

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 GPUPrimero, 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 arquitecturaAsí es como funciona la pila de software:
Desglose por capasControlador NVIDIA
- Comunicación GPU de bajo nivelKit de herramientas CUDA

- APIs para la programación de GPU

cuDNN

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

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 VersionHoja de ruta de instalación
CUDA VersionAquí está el orden que vamos a instalar las cosas (¡el orden importa!):
Memory-UsagePaso 1: Conductor NVIDIA

Comprobar el controlador actual

Abra PowerShell:nvidia-smiDebería ver la salida como:

Información clave: Debe ser 545.xx o más reciente
: Esta es la versión MAX CUDA soportada, no lo que está instalado
- : Utilizado actualmente / VRAM totalActualizar el controlador si es necesario
- Sino funciona o tu conductor es viejo:
- Ir aDescargas del controlador NVIDIA
- Seleccionar:**Tipo de producto:**RTX/Quadro
- Serie de productos:Serie RTX AxxxxProducto:
RTX A4000
Sistema operativo:nvidia-smi

Ventanas 11

(o su versión)

Tipo de descarga:

Controlador de estudio(más estable que Game Ready)Instalar y reiniciarVerificar de nuevo con

Paso 2: Kit de herramientas CUDACUDA proporciona la interfaz de programación para la aceleración de GPU.
Selección de versionesCrítico
: NecesitamosCUDA

12.x para modelos modernos.

Concretamente:CUDA 12,1+
- Buen equilibrio de compatibilidad y características (en el momento de escribir)Última 12.x- Compruebe la compatibilidad con sus bibliotecas
NO CUDA 11.x- Faltan características más nuevas que los modelos necesitan
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)

SeleccionarInstrumental 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.:

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

¿ Por qué es una costumbre?: No queremos rebajar nuestro controlador o instalar software de juegos.:
- Ruta de instalaciónThis PCLa ruta predeterminada está bien:
Pero tenga en cuenta esto - vamos a necesitarlo para las variables de entorno!Establecer variables de entornoEl 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

Check in PowerShellPathSi 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

AbrirVariables ambientales

Haga clic con el botón derecho

# 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

→ Propiedades → Configuración avanzada del sistema → Variables de entorno

Bajo

Variables del sistema

, verificar/agregar:: InVariable, asegúrese de que existen:

Reinicie su terminalpara que los cambios surtan efectoVerificar 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

CríticocuDNN
¡La versión debe coincidir con la versión CUDA!
PorCUDA 12.x
, necesitamosCuDNN 8,9+
para CUDA 12.x (en el momento de redactarse el presente informe, 8,9.7 o posterior)

Descargar cuDNN

Ir a

Archivo cuDNNNecesitará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::

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

Seleccionar:bin\Instalador local para Windows (Zip)C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\
Descargar (~800MB)include\Extraer e instalar cuDNNC:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\
cuDNN es sólo un conjunto de archivos que copia en su instalación CUDA.lib\x64\Extraer el ZIPC:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\

, ya verás:

# 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

nvidia-smi

Copiar todos los archivos desde

nvcc --version

Copiar todos los archivos desde

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

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

Asegurémonos de que todo funcione juntos.:

cd "1_Utilities\deviceQuery"

Comprobación de hardwareDebería mostrar su GPU sin errores.

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

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

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

Buscar dispositivoQuery

Compilarlo(requiere Visual Studio):

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

Ejecutalo.

Microsoft.ML.OnnxRuntimeDebería ver la salida como:
Microsoft.ML.OnnxRuntime.GpuLa línea de claves

Si ves esto, ¡tu pila GPU + CUDA + cuDNN está funcionando!

Paso 5: Pruebas desde 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 ===");
        }
    }
}

Ahora la parte divertida - vamos a utilizar realmente CUDA de C#!:

Crear proyecto de pruebaAñadir tiempo de ejecución de ONNX con CUDA
- DeviceIdONNX Runtime
- es la forma más fácil de usar CUDA desde C#.
¿Por qué este paquete?- Sólo CPU
- - Incluye soporte CUDA
- Código de ensayo: Detección de GPU
CrearDesglose por código
- OrtCUDAProviderOpciones
- - Configura la ejecución CUDA

- Qué GPU usar (0 para la primera GPU)

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á trabajandoSi falla, algo en la pila se rompe

OrtEnv.Instance().ObtenerDisponibleProviders():

# 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 correctamenteTambién muestra "CPUExecutionProvider" como reserva

Ejecutar la prueba:

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

Producto previsto

Solución de problemas Errores comunesError: "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).

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

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

Causa:

**: 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
**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).
Código de prueba de inferenciaActualizar
- Explicación del código
DenseTensor- La forma en que ONNX Runtime representa los arrays multidimensionales

Forma

dotnet run

= lote_tamaño=1, canales=1, altura=28, ancho=28NombreOnnxValue

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

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

**¿Por qué una velocidad tan pequeña?**MNIST es pequeño (sólo modelo 100KB)
Predomina la transferencia de datos de la GPUPara modelos más grandes (1GB+), verá velocidades de 10-100x
Para llevar la llaveHemos probado que toda la pila funciona:

Comprensión del desempeño

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 transferenciasLos modelos más grandes se benefician más
- Costo de transferencia fija, cálculo de escalaCuándo usar GPU vs CPU
Regla generalGPU

- Grandes modelos, procesamiento por lotes, generación de incrustaciones

CPU

✅ Installed NVIDIA driver (545.xx+)
✅ Installed CUDA Toolkit 12.1
✅ Integrated cuDNN 8.9.7
✅ Verified with nvidia-smi- Modelos pequeños, peticiones individuales, latencia críticanvcc
✅ Tested GPU access from C# with ONNX Runtime
✅ Ran performance comparison (GPU vs CPU)

Para nuestro asistente de escritura de blog:

Incrustaciones

Proceso por lotes 100+ trozos → GPUInferencia 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

# 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? | nvccElegir entre Qdrant, pgvector y otras opciones Generando incrustaciones localmente con ONNX Runtime Almacenamiento y consulta de millones de vectores de manera eficienteMicrosoft.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
DLL carga fallida cuDNN falta Copiar archivos cuDNN a CUDA dirCUDA proveedor no encontrado mal paquete NuGet Uso
Versión de controlador insuficiente Antiguo controlador Actualización a 545.xx+
Matriz de compatibilidad de versiones
Versión CUDA Versión CuDNN Versión ONNX Runtime Requerido Driver
12.1 8.9.7 1.16.x 545.xx+
12.3 9.0.0 1.17.x 546.xx+
11.8 8.9.2 1.15.x 520.xx+

Navegación en serie

Parte 4: Construcción del oleoducto de ingestiónParte 5: El cliente de WindowsParte 6: Integración local de la LLM

Construyendo un "Abogado GPT" para su blog - Parte 2: Configuración de la GPU y CUDA en C#

Esta parte se centra en la configuración de la GPU, pero notaré alternativas solo para CPU cuando sea relevante.

CUDA

RTX 4090

RTX 3060

- Suficiente para modelos de parámetros 7B-13B

GPU VRAM Max Tamaño del modelo bueno para

¡Cuidado!

Esta serie se centra en

- APIs para la programación de GPU

- Biblioteca de Deep Neural Network (kernels optimizados)

ONNX Duración / LLAMASharp

Comprobar el controlador actual

Ventanas 11

Tipo de descarga:

12.x para modelos modernos.

Ir a

(o 12.3 si eres aventurero)

Descargar (~3GB)

Haga clic con el botón derecho

→ Propiedades → Configuración avanzada del sistema → Variables de entorno

Variables del sistema

Compatibilidad con la versión

Descargar cuDNN

, ya verás:

Copiar archivos a la instalación de CUDA

Copiar todos los archivos desde

Copiar todos los archivos desde

Copiar todos los archivos desde

a

El kit de herramientas CUDA incluye programas de muestra.

Navegue a las muestras

Buscar dispositivoQuery

Si ves esto, ¡tu pila GPU + CUDA + cuDNN está funcionando!

- Qué GPU usar (0 para la primera GPU)

SessionOptions.AppendExecutionProvider_CUDA()

- Indica a ONNX Runtime que use GPU

- Lista todos los proveedores de ejecución disponibles

Producto previsto

Arreglar

Causa

Arreglar

Forma

Corremos una vez antes de tiempo para obtener mediciones precisas

- Promedio de más de 100 iteraciones para resultados estables

Prueba de rendimiento de ejecución

Comprensión del desempeño

- Grandes modelos, procesamiento por lotes, generación de incrustaciones

Incrustaciones

¿Qué sigue?

In

Parte 3

¡Finalmente empezaremos a trabajar con contenido real de blog y veremos a RAG en acción!

Error # # Causa # # Solución

no se encontró el controlador no instalado install NVIDIA driver

Navegación en serie