跳转至

AI

参考


GPU

  • CPU 支持复杂指令集, 而 GPU 只能执行简单指令集。简单的结构使得 GPU 可以在同一时间内处理更多的指令

  • GPU 通过 SIMD(单指令多数据)来实现并行处理, 在同一时间内对多个数据进行相同的操作, 这使得它在处理大规模数据时具有更高的效率

CUDA

  • NVIDIA 推出的并行计算架构, 本质就是一个 C 库, 调用 GPU 参与计算

  • 可以通过编写 CPU / GPU 代码进行矩阵运算查看效果

    CPU 代码
    C++
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
    #include <iostream>
#include <thread>
#include <vector>

const int N = 3e3 + 10;

std::vector<std::thread> threads;
int A[N][N], B[N][N], C[N][N];
int n = N - 10;

void cpu_matrix_multiply(int i) {  // 线程函数, 用于计算矩阵乘法的一行
    for (int j = 1; j <= n; ++j) {
        for (int k = 1; k <= n; ++k) {
            C[i][j] += A[i][k] * B[k][j];
        }
    }
}

int main() {
    // g++ main.cpp && ./a.out
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            A[i][j] = i + j;
            B[i][j] = i - j;
        }
    }  // 初始化矩阵 A, B

    auto start = std::chrono::high_resolution_clock::now();  // 记录开始时间

    for (int i = 1; i <= n; ++i)
        threads.emplace_back(cpu_matrix_multiply, i);
    for (auto& t : threads)
        t.join();

    auto end = std::chrono::high_resolution_clock::now();  // 记录结束时间
    std::chrono::duration<double> duration = end - start;
    std::cout << "Time taken: " << duration.count() << " seconds" << std::endl;

    return 0;
}

    GPU 代码
    C++
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
    #include <cuda_runtime.h>
#include <chrono>
#include <iostream>

const int N = 3e3 + 10;
int A[N][N], B[N][N], C[N][N];
int n = N - 10;

__global__ void cuda_matrix_multiply(int* A, int* B, int* C, int n) {
    int row = blockIdx.y * blockDim.y + threadIdx.y + 1;
    int col = blockIdx.x * blockDim.x + threadIdx.x + 1;

    if (row <= n && col <= n) {
        int sum = 0;
        for (int k = 1; k <= n; ++k) {
            sum += A[row * N + k] * B[k * N + col];
        }
        C[row * N + col] = sum;
    }
}

int main() {
    // nvcc main.cu && ./a.out
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            A[i][j] = i + j;
            B[i][j] = i - j;
        }
    }  // 初始化矩阵 A, B

    // 分配 GPU 内存
    int *d_A, *d_B, *d_C;
    cudaMalloc(&d_A, N * N * sizeof(int));
    cudaMalloc(&d_B, N * N * sizeof(int));
    cudaMalloc(&d_C, N * N * sizeof(int));

    // 复制数据到 GPU
    cudaMemcpy(d_A, A, N * N * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, B, N * N * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_C, C, N * N * sizeof(int), cudaMemcpyHostToDevice);

    auto start = std::chrono::high_resolution_clock::now();

    dim3 blockSize(16, 16);
    dim3 gridSize((n + blockSize.x - 1) / blockSize.x, 
                  (n + blockSize.y - 1) / blockSize.y);

    cuda_matrix_multiply<<<gridSize, blockSize>>>(d_A, d_B, d_C, n);

    cudaDeviceSynchronize();

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;
    std::cout << "Time taken: " << duration.count() << " seconds" << std::endl;

    // 清理内存
    cudaFree(d_A);
    cudaFree(d_B);
    cudaFree(d_C);

    return 0;
}

CPU GPU
AMD 7900x NVIDIA 4070
7s 0.03s

PyTorch

  • PyTorch 是对 CUDA 的封装, 提供了更高层次的 API 来简化 GPU 编程

机器学习

“计算机程序可以在给定某种类别的任务 T 和性能度量 P 下学习经验 E(数据), 如果其在任务 T 中的性能恰好可以用 P 度量, 则随着经验 E(数据) 而提高。” -- Tom Mitchell

f(x) = y: 机器学习的目标是通过数据来创造函数 f, 使得输入 x 能够映射到输出 y

强化学习

一种机器学习的范式, 智能体通过与环境交互来学习如何在特定情境下采取行动以最大化累积奖励

监督学习

一种机器学习的范式, 通过使用带有标签的数据来训练模型, 使其能够学习输入与输出之间的映射关系

无监督学习

一种机器学习的范式, 通过使用不带标签的数据来训练模型, 使其能够发现数据中的模式和结构

神经网络

神经网络

深度学习

神经网络的一种特殊形式, 通常指的是具有多层隐藏层的神经网络

大模型

包含超大规模参数(通常在十亿个以上)的神经网络模型