# 为您的博客建立「律师GPT」-第2部分:GPU设置与CUDA C#

<!--category-- AI, LLM, CUDA, C#, GPU, AI-Article, mostlylucid.blogllm -->
<datetime class="hidden">2025-11-12T22:45</datetime>

> 警告:这些是“加入”的草稿。

可能很多下面的东西是行不通的; 我制作了这些作为给ME的操作方法, 然后做所有步骤,让样本应用起作用...你一直偷偷摸摸地看到它们!它们很可能在12月中旬就绪。

<img src="https://media1.tenor.com/m/_rQc7PIEqwQAAAAd/cat-hello-cat-peek.gif" height="300px" />
## 一. 导言 导言 导言 导言 导言 导言 一,导言 导言 导言 导言 导言 导言

欢迎来到第二部分![内](/blog/building-a-lawyer-gpt-for-your-blog-part1)第一部分 第一部分

> 例如律师如何使用受过判例法培训的LLMs起草文件。

**现在是时候让我们的手和基金会弄脏了:确保您的GPU准备好接受人工智能的工作量。**注:这是我对人工智能(协助起草)和我自己编辑的实验的一部分。

同一个声音,同样的务实;只是更快的手指。[关于我的硬件](https://developer.nvidia.com/cuda-toolkit)我使用NVIDIA RTX A4000(16GB VRAM)、AMD Ryzen 99950X和96GB DDCP5 RAM。[但你不需要这个!](https://developer.nvidia.com/cudnn)如第一部分所述,您可以使用任何带有 8GB+ VRAM 的 NVIDIA GPU, 或甚至只运行 CPU( 较小但功能性) 。

[TOC]

## 本部分的重点是 GPU 设置, 但我会在相关之处注意到仅使用 CPU 的替代品 。

如果你已经熟悉这个部分的话,这个部分可能看起来很基本

### CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA 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
```

**相信我,我浪费了无数小时 去调试神秘错误 追溯到版本错配、环境变数缺失或错误**:

1. **CHUNDN CHIN CHIDDN 中, cCDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDDN 中**设施。
2. **我们从一开始就这么做**为什么GPU 加速问题
3. **在我们潜入装置之前,让我们理解为什么我们需要GPU加速度。**用于 AI 工作量的 CPU vs GPU CPU
4. **为什么GPU占AI的支配地位**平行主义

**- GPU有成千上万个核心 相对于CPU的几十个**矩阵业务

- **- 人工智能主要是矩阵数学,GPU最擅长**内存带宽
- **- GPUs移动数据的速度要快得多**专用硬件

- 感测核心加速AI型具体行动

**真实世界实例**制作博客文章的嵌入内容:

- **CPU (Ryzen 9 9950X)**: ~ 5 秒/ 秒
- **GPU (A4000 16GB)**: ~ 0. 3 秒/ 秒
- **这是16x速度,它加起来 当处理上百个柱子!**其他GSPU的绩效
- (大约):

## RTX 4090

(24GB): 最快, ~ 0. 秒/ 秒/ 秒 (24GB): 最快, ~ 0. 秒/ 秒/ 秒/ 秒( 24GB): 最快, ~ 0. 秒/ 秒/ 秒/ 秒/ 秒/ 秒( 24GB): 最快

### RTX 3060

(12GB):~每个职位0.5 %

- **GTX 1070 Ti**(8GB):~每个职位0.8 %
- **比CPU还快!**了解硬件
- **在安装任何设备之前,让我们先了解我们的工作内容。**我的GPU: NVIDIA RTX A4000
- **这是我特有的GPU - 专业工作站卡**16GB GDDD6 VRAM 16GB GDD6

### - 足够7B-13B参数模型使用

6144 CUDA核心核心

- 平行处理权
|-----|------|----------------|----------|
256 电传感器核心
- 加速AIA行动
CUDA 计算能力 8.6
- 兼容性很重要
通用 GPU 选项
以下是各种 GPU 所能处理的:

### GPU  VRAM

RTX 4090 24GB 13B-30B*** RTX 4070 Ti * 12GB * 7B-13B * 最佳选择 ***

***RTX 3060 * 12GB * 7B * 预算友好 * * 12GB * 7B * 预算友好 ***RTX 4060 Ti 16GB 7B-13B 价值

*** A4000(地雷) * 16GB * 7B-13B * 工作站GPU * 16GB * 7B-13B * 工作站 GPU ***:

- **GTX 1070 Ti  8GB  7B (紧)  最低可行**英特尔/AMD NPUs怎么办?
- **你可能听说过 Intel Core Ultra 或AMD Ryzen AI 芯片和内置NPU(神经处理装置)的芯片。**你能用这些代替荷兰盾吗?
- **短答**:还没有,但也许在2024-2025年!
- **现有限制**无CUDA

**: NPUs 不支持 CUDA, 此教义使用的 CUDA**:

- 有限.NET支助
- ONNX 运行时 NPU 支持是实验性的[模型兼容性](https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html):大多数GGUF模型以CUDA/CPU为目标。
- 直接洗钱支助

:LLMM项目仍在成熟**如果您有 NPU 设备 CPU 的 CPU**现在只使用 CPU 模式( 一切工作, 慢一点)

### 监视监视

ONNX 运行时间直接洗钱

```bash
# PowerShell
wmic path win32_VideoController get name
```

更新更新更新

```
Name
NVIDIA RTX A4000
```

当 NAPU 支持改进时, 未来部分将会注意

### 本系列的焦点是

VIVDIA 哥达

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

**因为它在.NET中是成熟的, 并得到了很好的支持, 但是一旦生态系统赶上, 这些概念就会转化成NPUs!**:

- **检查您的 GPU**首先,验证 Windows 看见您的 GPU :
- **你应该看到一些东西,比如:**或使用 NVIDIA 控制面板“ 系统信息” 显示标签 。
- **建筑结构概览**以下是软件堆叠的原理:
- **图层分解**NVIDIA 驱动器
- **- 低级别GPU通信**CUDA CUDA工具包

## - 用于GPU编程的API

CHUNDN CHIN CHIDDN 中, cCDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDDN 中

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

## - 深神经网络图书馆(优化内核)

### 运行时间/拉马沙尔普

- 高级别多边借贷框架

```bash
nvidia-smi
```

您的应用程序应用程序

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

**- 我们的C#代码**:

- `Driver Version`安装路线图
- `CUDA Version`以下是我们安装东西的命令(命令事项! ) :
- `Memory-Usage`步骤1:NVIDIA驱动程序

### 检查当前驱动程序

开放电源外壳( Open PowerShell) :`nvidia-smi`您应该看到输出如 :

1. 密钥信息[:应该是545.xx或更新](https://www.nvidia.com/Download/index.aspx)

2. : 这是支持的 MAX CUDA 版本, 而不是安装的版本 。
   
   - :目前使用的 VRAM / 总计**需要时更新驱动程序**
   - 如果(如果)**不工作或驾驶器老旧:**
   - 转到**NVIDIA 驱动程序下载**
   - 选择 :**产品类型:**RTX/夸德罗
   - 产品系列:**RTX AxxXXX系列**产品 :

3. RTX A4000 RTX A4000

4. 操作系统 :`nvidia-smi`

## 视窗11

(或你的版本)

### 下载类型 :

**演播室司机**(比游戏准备更稳定)[安装并重新启动](https://developer.nvidia.com/cuda-toolkit)再次核查

- **步骤2:CUDA CUDA工具包**CUDA为GPU加速提供编程界面。
- **版本选择**关键
- **:我们需要**CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA CUDA

### 现代模式12x。

1. 具体而言:[CUDA 12.1+](https://developer.nvidia.com/cuda-toolkit-archive)
2. - 在兼容性和特点之间保持良好的平衡(在编写本报告时)**最新12.x**- 检查与您的图书馆的兼容性
3. 非CUDA 11.x**- 缺少地物特征的新模型需要**
4. 下载和安装

### 转到

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

**选择**CUDA 工具包12.1

### (或12.3 如果你很冒险)

选择 :

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

视窗 x86_64 + 11 + exe (当地)

### 下载 (~ 3GB)

安装选项

**运行安装器。**:

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

**提示时 :**:

1. 为什么定制?**:我们不想降低驾驶员的级别或安装游戏软件。**:
   
   - 安装路径`This PC`默认路径为罚款 :

2. 但请注意,我们的环境变数需要它!**设置环境变量**安装器通常设置这些, 但验证 :
   
   - `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. 在 PowerShell 中检查`Path`如果缺缺, 手动添加
   
   ```
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\libnvvp
   ```

4. **开放**环境变量

### 右键单击

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

## 属性 高级系统设置 环境变量

下 下

### 系统变量

**,核查/添加:**: [内](https://developer.nvidia.com/cudnn)变量,确保存在这些变量:

重新启动您的终端**使修改生效**CUDA 核查系统安装**第3步:cudNN(CUDA深神经网络图书馆)**cucDNN为深层学习业务提供最佳实施。

### 版本兼容性

1. 关键[CHUNDN CHIN CHIDDN 中, cCDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDN 中, CDDN 中](https://developer.nvidia.com/rdp/cudnn-archive)
2. 版本必须匹配 CUDA 版本 !
3. 用于**CUDA 12.x 十二届理事会**
4. ,我们需要**CHUNN 8.9+**
5. 12.x(在编写本报告时为8.9.7或以后)

### 下载 cuDNN

转到

**CHUDNN 归档**您需要一个 NVIDIA 开发者账户( 免费)

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

**查找 :**:

```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\"
```

**CUDA 12.x 下载 cuDNN v8.9.7 (12月5日,2023年12月5日)**:

1. 选择 :`bin\`Windows (Zip) 本地安装器`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\bin\`
2. 下载 (~ 800MB)`include\`提取并安装 cuDNN`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\include\`
3. CHUDNN只是你复制到 CUDA 安装中的一组文件。`lib\x64\`解开 ZIP`C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\lib\x64\`

### ,你会看到:

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

## 复制文件到 CUDA 安装

或者手工操作

### 复制所有文件

```powershell
nvidia-smi
```

至

### 复制所有文件

```powershell
nvcc --version
```

至

### 复制所有文件

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

### 至

核查 cuDNN 安装

**步骤4:完成核查**:

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

**让我们确保一切顺利**:

```powershell
cd "1_Utilities\deviceQuery"
```

**硬件检查**应该显示您的 GPU 没有错误 。

```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 检查**:

```powershell
.\x64\Release\deviceQuery.exe
```

应该显示 CUDA 12.1 (或安装的版本) 。

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

**系统变量检查**: `Result = PASS`

CUDA 样本测试(备选但建议)

## CUDA工具包包括样本方案。

让我们编集和运行一个。

### 采样导航

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

### 查找设备查询

[编成](https://onnxruntime.ai/)(需要视觉演播室):

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

**运行它**

- `Microsoft.ML.OnnxRuntime`您应该看到输出如 :
- `Microsoft.ML.OnnxRuntime.Gpu`关键行

### 如果你看到这个, 你的 GPU + CUDA + CUDN + CUDN 堆放工作了 !

步骤5: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 ===");
        }
    }
}
```

**现在有趣的部分 - 让我们实际使用C#C的CUDA!**:

1. **创建测试工程**添加 ONNX 使用 CUDA 运行时间
   
   - `DeviceId`ONNX 运行时间
   - 使用C#C的CUDA是最简单的方法。

2. **为什么是这个包裹?**- 只有CPU
   
   - - 包括CUDA支助
   - 测试代码: GPU 探测

3. **创建创建**代码分类明细
   
   - OrtCUD 评估选项
   - - 配置 CUDA 执行

### - 使用哪个 GPU (第一个 GPU 0)

```bash
dotnet run
```

**可以设定内存限值、优化水平等 。**:

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

### 会话选项。 附加执行 provvider_ CUDA ()

#### - 告诉 ONNX 使用 GPU 的运行时间

**如果成功,CUDA正在发挥作用**如果它失败了, 堆叠里的东西坏了

**Ortenv. Instance (). GetAvaable Providers ()**:

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

#### - 列出所有现有的执行提供者名单

**如果所有设备安装正确, 应该包括“ CUDA 执行 provvider ”**并显示“ CPU 执行 provvider ” 作为后退

**运行测试**:

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

#### 预期产出预期产出

**排除共同错误的麻烦**错误 : “ 不退出例外 : 无法装入 DLL 'onnxruntime' ”

**原因原因原因原因原因**运行时间找不到CUDA DLLs

## 修整

错误: “ 找不到 CUDA 执行 provider ”

### 原因原因原因原因原因

:使用错误的 ONNX 运行时间套件(仅使用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"
```

### 修整

错误: “ CUDA 错误代码: 35 ( CUDA 驱动程序版本不足) ”`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<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;
        }
    }
}
```

**原因原因原因原因原因**:

1. **司机太老了,CUDA 12.x。**修整
   
   - :将 NVIDIA 驱动程序更新为 545.xx 或更新 。`[1, 1, 28, 28]`高级测试: 实际推断

2. **让我们做一些真实的事情 运行一个微小的神经网络 在 GPU 和 CPU 上并比较速度。**下载测试模型
   
   - 我们将使用简单的MNIST数字识别模型(ONNX格式)。

3. **推断试验编码**更新更新更新
   
   - 代码解释

4. **高频传感器**- ONNX 运行时代表多维阵列的方式

### 形状形状形状

```bash
dotnet run
```

**=批量_ 大小= 1, 频道= 1, 高度=28, 宽度=28**命名为OnnxValue

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

**- 绑绑输入名称的阵格**

- “投入3”是MNIST 模型中的输入名称
- 温热运行
- - 第一种推论总是较慢(模型装货、优化)

### 我们跑过一次,才有时间进行精确的测量

时间安排方法
✅ Driver installed correctly
✅ CUDA Toolkit accessible
✅ cuDNN integrated
✅ ONNX Runtime finds CUDA
✅ C# can run GPU-accelerated inference

## - 平均100多个周期,以取得稳定结果

### 运行性性能测试

预期产出预期产出

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

**(你们的人数会变化):**:

1. **为什么这么小的超速?**MNIST是很小的(只有100KB型号)
2. **GPU数据传输的顶部**大型号(1GB+)的 1GB+, 你会看到10-100x超速
3. **密钥取取**我们已经证明了整个堆叠的工作原理:

### 理解业绩

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

**内存传输瓶头**:

- **以下是推断时发生的情况:**业绩经验教训
- **批次处理**- 将许多投入立即转移给摊分间接费用

保留 GPU 上的数据

- **- 避免转让的链业务**大型模型受益更多
- **- 固定转账费用,按比例计算**何时使用 GPU 和 CPU 的 GPU 和 CPU
- **拇指规则**GPU 通用 GPU

## - 大型模型、批量处理、嵌入生成

CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU CPU

1. ✅ Installed NVIDIA driver (545.xx+)
2. ✅ Installed CUDA Toolkit 12.1
3. ✅ Integrated cuDNN 8.9.7
4. ✅ Verified with `nvidia-smi`- 小型模型、单一请求、延迟临界`nvcc`
5. ✅ Tested GPU access from C# with ONNX Runtime
6. ✅ Ran performance comparison (GPU vs CPU)

博客写作助理:

## 内嵌

- 批次处理 100+块  GPU**LLM 推断**- 大型型号(7B参数)+GPU

- 矢量搜索
- - 取决于DB的选择, 常常受CPU的约束
- 摘要摘要摘要
- 我们已经成功:
- 和

我们的开发环境已经准备好接受人工智能的工作量了!

## 下一个是什么?

### 内

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

### 第三部分 第三部分

我们将深入潜入嵌入和矢量数据库:
|-------|-------|-----|
| `nvidia-smi`什么是嵌入式, 它们如何使语义搜索得以进行 ?
| `nvcc`在 Qdrant、 pgvector 和其他选项之间选择
正在生成本地嵌入 ONNX 运行时间
高效存储和查询数以百万计的矢量`Microsoft.ML.OnnxRuntime.Gpu` |
建立我们第一个语义搜索原型

### 我们终于将开始使用博客内容, 并看到RAG行动!

排除故障解决参考
|--------------|---------------|--------------|-----------------|
快速诊断命令
共同问题 共同问题
错误 原因 修补

## 未找到% % 驱动程序未安装 * * *安裝 NVIDIA 驱动程序 * * * *

- [在 PATH 中找不到 CUDA 。 将 CUDA bin 添加到 PATH 中 。](/blog/building-a-lawyer-gpt-for-your-blog-part1)
- **DLL 卸载失敗 * CHUDNN 失蹤 * * CUDA dir 的 CUDA 文件副本 * * CUDA dir ***CUDA 提供者未找到“ 错误的 Nuget 软件包 ” 。
- [驱动器版本不足 * * 旧驱动器 * * 更新至 545.xx+ * *](/blog/building-a-lawyer-gpt-for-your-blog-part3)
- [版本兼容矩阵](/blog/building-a-lawyer-gpt-for-your-blog-part4)
- [CUDA 版本 @ cuDNN 版本 @ ONNX 运行时间 @ 驱动器需求 @](/blog/building-a-lawyer-gpt-for-your-blog-part5)
- [-=YTET -伊甸园字幕组=- 翻译:](/blog/building-a-lawyer-gpt-for-your-blog-part6)
- [-=YTET -伊甸园字幕组=- 翻译:](/blog/building-a-lawyer-gpt-for-your-blog-part7)
- [11.8  8.9.2  1.15.x  5.20.xx+](/blog/building-a-lawyer-gpt-for-your-blog-part8)

## 系列导航

- [第1部分:导言和建筑](https://docs.nvidia.com/cuda/)
- [第2部分:C#中的GPU设置和CUDA CUDA](https://docs.nvidia.com/deeplearning/cudnn/api/index.html)
- [(本员额)](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
- [第三部分:了解嵌入和矢量数据库](https://developer.nvidia.com/)

第4部分:建设吸收管道[第5部分:视窗客户端](/blog/building-a-lawyer-gpt-for-your-blog-part3)第6部分:地方LLM整合