The Daylight

[CUDA] 快速入门CUDA(2) 以任务为导向的实践-解决最小二乘法问题

快速入门CUDA(2) 以任务为导向的实践-解决最小二乘法问题

文章目录

快速入门CUDA(2) 以任务为导向的实践-解决最小二乘法问题
- 1 问题介绍
- 2 MATLAB解法实现
- 3 CUDA解法实现
- - 3.1 总览
  - 3.2 第一步，读取矩阵
  - 3.3 将矩阵放到GPU上
  - 3.4 矩阵运算
  - 3.5 求解矩阵A的SVD
- 4 代码汇总

1 问题介绍

今天我们要解决的是一个最小二乘法的问题，这也是我的作业。下面就简单的介绍一下问题，以及所涉及到的公式，便于我们完成这个任务。如果不理解这个数学问题也没有关系，关键在于理解公式，以及我们要做的运算即可。

给定一个 $n\times n$ 的矩阵 $A$ ，要找到一个近似的解 $x$ 满足下面式子所表达的最小乘法问题。
$\arg {\min _{x \in {R^n}}}{\left\| {Ax - b} \right\|_2}$
向量 $b$ 的计算方法是将 $A$ 乘以一个单位向量 $e$ ，由全1组成。确保 $A$ 可以被向量分解(SVD)
$A=U\Sigma V^T$
其中 $U$ 和 $V$ 都是 $n\times n$ 的正交矩阵，而 $\Sigma$ 是一个 $n\times n$ 的对角矩阵，并且它的对角元素满足下列不等式
$\sigma_1\ge \sigma_2\ge\sigma_3\ge \cdots \ge \sigma_n \ge 0$
那么只要 $\sigma_n\ge0$ ，我们就可以求出解
$x=V\Sigma ^{-1} U^T b$
当然，如果我们将 $U$ 和 $V$ 表示为
$U=[u_1,u_2,\cdots,u_n],V=[v_1,v_2,\cdots,v_n]$
那么同样可以求得解为
$\sum\limits_{i = 1}^n {\frac{{u_i^Tb}}{{{\sigma _i}}}{v_i}}$
我们可以找到对于 $1 < k < n 1而言，可以找到 σ k > > σ k + 1 \sigma_k>>\sigma_{k+1} 。这样我们只需要收集前 k k 列的 U U 和 V V 和 Σ \Sigma ，就可以得到一个矩阵 A A 的近似了。$

令
$U_k = U(:,1:k), V_k=V(:,1:k), \Sigma _k = \Sigma(1:k, 1:k)$
可以得到 $A_k$ ，也被称之为Truncated SVD (TSVD)。
$A_k=U_k\Sigma_kV_k^T$
接着可以得到
${\left\| {A - {A_k}} \right\|_2} \approx {\sigma _{k + 1}}$
同样，有两种方法计算解 $x_k$

${x_k} = \sum\limits_{i = 1}^k {\frac{{{u_i}^Tb}}{{{\sigma _i}}}{v_i}} \\ x_k=V_k\Sigma_k^{-1}U_k^Tb$
最后，我们可以计算出
$={\left\| {x - {x_k}} \right\|_2}\\ r={\left\| {A_kx_k - b} \right\|_2}$
至此，我们明确了目的，对于一个给定的矩阵 $A$ ，我们要计算出 $x_k,e,r$ 。

2 MATLAB解法实现

根据上述的任务要求，我们可以先用MATLAB进行实现，因为MATLAB拥有大量的内置函数，使用起来很方便，运算速度也很快。此外，我们还可以用MATLAB的运算结果来检验我们后期用CUDA实现算法的正确性。

clear all 
clc
m = 256;
n = 128;
% load MyMatrix.txt 从文件中读取矩阵
% A = MyMatrix;
A =rand(m, n);  %  随机生成矩阵
b = A * ones(n, 1);
[U,S,V] = svd(A);  % 求解svd
sigma = diag(S);
% temp = S;
% temp(1:128,1:128) = inv(S(1:128,:));
% x_true = V * temp * U' * b;  % solution 1
x = 0;
for i = 1:n
    x = x + V(:,i) * ((U(:,i)'*b) / sigma(i)); %  solution 2
end
k = 2;
for i = 2:n-1
    fprintf('sigma(%d)=%e,sigma(%d)=%e, sigma(%d) / sigma(%d)=%e\n',i+1,sigma(i+1),i,sigma(i),i+1,i,sigma(i + 1) / sigma(i));
    if sigma(i + 1) / sigma(i) <= 1e-3
        k = i;
        break
    else
        k = i;
    end
end
U_k = U(:,1:k);
V_k = V(:,1:k);
sigma_k = S(1:k,1:k);
A_k = U_k * sigma_k * V_k';
x_k = 0;
for i = 1:k
    x_k = x_k + V(:,i) * ((U(:,i)'*b) / sigma(i)); %  solution 2
end
% x_k = V_k * inv(sigma_k) * U_k' * b
e = norm(x - x_k)  % 计算误差
r = norm(A_k * x_k - b)

可以看到用MATLAB实现还是相对容易的，基本上就是对着公式去实现即可。

3 CUDA解法实现

接下来，我们正式使用CUDA来编程，在此之前，我们可以思考一下会用到哪些操作和与之对应的函数。

3.1 总览

在这个问题当中，显然涉及到矩阵的乘法，SVD的计算，矩阵的2范数计算，矩阵的转置，求逆矩阵。按照正常的思路，可以分别对应实现函数，然后调用函数实现。不过，如果我们自己用CUDA来实现上述的功能，可能会有一定的难度，而且所实现的函数计算速度也一定不如NVIDIA官方为我们提供的API（除非你是计算机天才2333）。相信大部分人应该和我一样是普通人，初学者，那就快乐地当一名调包侠吧！

3.2 第一步，读取矩阵

第一步先将矩阵 $A$ 读入，并给它分配空间，注意，此处我们仍然是在host上进行的，也就是CPU负责这个任务。直接给出读取矩阵的函数，矩阵存储的格式为，前两个数字为矩阵的行数和列数，然后才是矩阵的具体内容。

float* readMatrix(char* filename) {
    int i, j;
    FILE *file;
    file = fopen(filename, "r");
    if (file == NULL)
    {
      printf("[ERROR] File \'%s\' does not exist in the current directory\n", filename);
      printf("[ERROR] Program exited.\n");
      exit(0);
    }

    int m, n;
    float float_m, float_n;
    fscanf(file, "%f", &float_m);
    fscanf(file, "%f", &float_n);
    m = (int) float_m;
    n = (int) float_n;
    float *A = (float *) malloc(m * n * sizeof(float)); 
    for (i = 0; i < m; i++)
      for (j = 0; j < n; j++)
      {
        fscanf(file, "%f", &A[i + j * n]);
      }

    fclose(file);
    printf("[INFO] Test matrix has been successfully imported, size=%dx%d.\n", m, n);
    return A;
}

3.3 将矩阵放到GPU上

因为我们要在GPU上进行计算，所以必须将数据上传至GPU，上传的速度取决于

CPU的速度
host与device之间的通信带宽

与malloc()类似，可以使用cudaMalloc()在GPU上分配空间，分配完空间之后，可以将host上的数据拷贝到GPU上，当然，也可以将GPU上的数据拷贝到host上，完成这一操作所需要的函数是cudaMemcpy(device_x, host_x, n * sizeof(float), cudaMemcpyHostToDevice)，所给的例子是将host_x拷贝到GPU上，device_x和host_x均需要为指针类型。最后一项参数代表着传输的方向，可以改变，如下表所示。

名称	代表的方向
cudaMemcpyHostToDevice	主机到显卡
cudaMemcpyDeviceToHost	显卡到主机
cudaMemcpyDeviceToDevice	显卡到显卡

统一内存（unified memory）

使用上述方法可能会频繁的拷贝数据，在编写程序的时候不是很方便，万幸的是，CUDA支持统一内存，也就是说，只需要使用统一内存，那么host和device都可以访问，这样在编写程序的时候会更方便简单一些。下面介绍一下如何分配统一内存。

使用__host__cudaError_t cudaMallocManaged ( void** devPtr, size_t size, unsigned int flags = cudaMemAttachGlobal )即可，例如

cudaMallocManaged(&x, N*sizeof(float)); // 分配x使用统一内存管理系统

虽然写起来更容易了，但是却更容易造成一些更复杂的bug，难以解决。所以本文采用前者的方法来分配GPU空间。

我们先从内存中读取出数据，先在host上存储，接着给GPU分配空间，将host上的数据传到GPU上，代码如下

float *host_A = readMatrix("MyMatrix.txt");   // A'shape = m * n
float *host_x = matrixOnes(n);         // x'shape = n * 1
float *host_b = (float*)malloc(sizeof(float) * m);
float *device_b;   // b'shape = m * 1
float *device_x;   // x'shape = n * 1
float *device_A;   // A'shape = m * n
cudaMalloc((void**)&device_x, n * sizeof(float));
cudaMalloc((void**)&device_b, m * sizeof(float));
cudaMalloc((void**)&device_A, m * n * sizeof(float));
cudaMemcpy(device_A, host_A, m * n * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(device_x, host_x, n * sizeof(float), cudaMemcpyHostToDevice);

3.4 矩阵运算

接下来，我们要计算 $b = A x$ ，现在已知 $A$ 和 $x$ ，求解 $b$ ，注意，矩阵 $b$ 和 $x$ 实际上只是向量（vector），因为他们都是一维的，所以这里我们使用的函数是cublasSgemv()，这个函数比较复杂，参数也很多，其中S代表单精度，而最后两个字母mv代表矩阵和向量相乘，我将在下一篇中着重讲解该函数，在这里，直接看我怎么使用就好。

我们的步骤如下：

设定矩阵和向量
配置参数
调用cublasSgemv()函数进行矩阵运算

具体代码如下

cublasSetMatrix(m, n, sizeof(float), host_A, m, device_A, m);
cublasSetVector(n, sizeof(float), host_x, 1, device_x, 1);
float alpha = 1.0f;
float beta = 0.0f;
cublas_status = cublasSgemv(cublasH, CUBLAS_OP_N, m, n, &alpha, device_A, m, device_x, 1, &beta, device_b, 1);

这部分代码所作的事情就是 $b = A x$ 。

3.5 求解矩阵A的SVD

接下来，我们的任务是求解出 $A$ 的SVD分解，在MATLAB当中，只需要调用内置函数svd(matrix)即可，CUDA当中有对应的函数吗？答案是有的，事实上，在上一步过程中，我们用到了cublas，其实这个里面还有很多实用的功能。现在，我们要用的是cusolver，它同样提供了使用的功能，封装了很多已经高效优化过的算法，例如SVD，FFT等。必须要说的是，cusolverDnSgesvd()同样非常复杂，如果想知道每一个参数的含义，需要查阅官网提供的文档，建议直接看本例。

和上一步类似，步骤如下

分配好空间，设定好存储结果的矩阵
为SVD计算分配空间
调用cusolverDnSgesvd()求解SVD