在GPU上的一些计算中，我需要缩放矩阵中的行，以便给定行中的所有元素总和为1.
| a1,1 a1,2 ... a1,N | | alpha1*a1,1 alpha1*a1,2 ... alpha1*a1,N | | a2,1 a2,2 ... a2,N | => | alpha2*a2,1 alpha2*a2,2 ... alpha2*a2,N | | . . | | . . | | aN,1 aN,2 ... aN,N | | alphaN*aN,1 alphaN*aN,2 ... alphaN*aN,N |
其中
alphai = 1.0/(ai,1 + ai,2 + ... + ai,N)
我需要alpha的向量，以及缩放的矩阵，我想尽可能少的blas调用。该代码将在nvidia CUDA硬件上运行。有谁知道有任何聪明的方法吗？
答案 0 :(得分：6)
Cublas 5.0引入了类似blas的例程，名为cublas（Type）dgmm，它是矩阵乘以对角矩阵（由向量表示）。
有一个左选项（可以缩放行）或一个缩放列的右选项。
有关详细信息，请参阅CUBLAS 5.0文档。
所以在你的问题中，你需要创建一个包含GPU上所有alpha的向量，并使用带有左选项的cublasdgmm。
答案 1 :(得分：2)
如果您将BLAS gemv与单位向量一起使用，则结果将是您需要的缩放因子（1 / alpha）倒数的向量。这是容易的部分。
逐行应用因子有点困难，因为标准BLAS没有像您可以使用的Hadamard产品运算符那样的东西。另外因为你提到BLAS，我认为你正在为你的矩阵使用列主要订单存储，这对于行式操作来说并不是那么简单。 真的很慢这样做的方法是每行上有BLAS scal，但这需要每行一次BLAS调用和调整内存由于对合并和L1缓存一致性的影响，访问将终止性能。
我的建议是使用你自己的内核进行第二次操作。它不一定非常复杂，也许只有这样：
template<typename T>
__global__ void rowscale(T * X, const int M, const int N, const int LDA,
const T * ralpha)
{
for(int row=threadIdx.x; row<M; row+=gridDim.x) {
const T rscale = 1./ralpha[row];
for(int col=blockIdx.x; col<N; col+=blockDim.x)
X[row+col*LDA] *= rscale;
}
}
只有一堆块逐列地逐行排列，随着它们的进行缩放。应适用于任何大小的列主要有序矩阵。内存访问应该合并，但根据您对性能的担忧程度，您可以尝试一些优化。它至少给出了如何做的一般概念。
答案 2 :(得分：2)
我想更新上面的答案，并考虑使用CUDA Thrust的thrust::transform和cuBLAS的{{1}}。我正在跳过缩放因子cublas<t>dgmm的计算，因为这已经在
和
Reduce matrix columns with CUDA
以下是一个完整的例子：
alpha #include <thrust/device_vector.h>
#include <thrust/reduce.h>
#include <thrust/random.h>
#include <thrust/sort.h>
#include <thrust/unique.h>
#include <thrust/equal.h>
#include <cublas_v2.h>
#include "Utilities.cuh"
#include "TimingGPU.cuh"
/**************************************************************/
/* CONVERT LINEAR INDEX TO ROW INDEX - NEEDED FOR APPROACH #1 */
/**************************************************************/
template <typename T>
struct linear_index_to_row_index : public thrust::unary_function<T,T> {
T Ncols; // --- Number of columns
__host__ __device__ linear_index_to_row_index(T Ncols) : Ncols(Ncols) {}
__host__ __device__ T operator()(T i) { return i / Ncols; }
};
/***********************/
/* RECIPROCAL OPERATOR */
/***********************/
struct Inv: public thrust::unary_function<float, float>
{
__host__ __device__ float operator()(float x)
{
return 1.0f / x;
}
};
/********/
/* MAIN */
/********/
int main()
{
/**************************/
/* SETTING UP THE PROBLEM */
/**************************/
const int Nrows = 10; // --- Number of rows
const int Ncols = 3; // --- Number of columns
// --- Random uniform integer distribution between 0 and 100
thrust::default_random_engine rng;
thrust::uniform_int_distribution<int> dist1(0, 100);
// --- Random uniform integer distribution between 1 and 4
thrust::uniform_int_distribution<int> dist2(1, 4);
// --- Matrix allocation and initialization
thrust::device_vector<float> d_matrix(Nrows * Ncols);
for (size_t i = 0; i < d_matrix.size(); i++) d_matrix[i] = (float)dist1(rng);
// --- Normalization vector allocation and initialization
thrust::device_vector<float> d_normalization(Nrows);
for (size_t i = 0; i < d_normalization.size(); i++) d_normalization[i] = (float)dist2(rng);
printf("\n\nOriginal matrix\n");
for(int i = 0; i < Nrows; i++) {
std::cout << "[ ";
for(int j = 0; j < Ncols; j++)
std::cout << d_matrix[i * Ncols + j] << " ";
std::cout << "]\n";
}
printf("\n\nNormlization vector\n");
for(int i = 0; i < Nrows; i++) std::cout << d_normalization[i] << "\n";
TimingGPU timerGPU;
/*********************************/
/* ROW NORMALIZATION WITH THRUST */
/*********************************/
thrust::device_vector<float> d_matrix2(d_matrix);
timerGPU.StartCounter();
thrust::transform(d_matrix2.begin(), d_matrix2.end(),
thrust::make_permutation_iterator(
d_normalization.begin(),
thrust::make_transform_iterator(thrust::make_counting_iterator(0), linear_index_to_row_index<int>(Ncols))),
d_matrix2.begin(),
thrust::divides<float>());
std::cout << "Timing - Thrust = " << timerGPU.GetCounter() << "\n";
printf("\n\nNormalized matrix - Thrust case\n");
for(int i = 0; i < Nrows; i++) {
std::cout << "[ ";
for(int j = 0; j < Ncols; j++)
std::cout << d_matrix2[i * Ncols + j] << " ";
std::cout << "]\n";
}
/*********************************/
/* ROW NORMALIZATION WITH CUBLAS */
/*********************************/
d_matrix2 = d_matrix;
cublasHandle_t handle;
cublasSafeCall(cublasCreate(&handle));
timerGPU.StartCounter();
thrust::transform(d_normalization.begin(), d_normalization.end(), d_normalization.begin(), Inv());
cublasSafeCall(cublasSdgmm(handle, CUBLAS_SIDE_RIGHT, Ncols, Nrows, thrust::raw_pointer_cast(&d_matrix2[0]), Ncols,
thrust::raw_pointer_cast(&d_normalization[0]), 1, thrust::raw_pointer_cast(&d_matrix2[0]), Ncols));
std::cout << "Timing - cuBLAS = " << timerGPU.GetCounter() << "\n";
printf("\n\nNormalized matrix - cuBLAS case\n");
for(int i = 0; i < Nrows; i++) {
std::cout << "[ ";
for(int j = 0; j < Ncols; j++)
std::cout << d_matrix2[i * Ncols + j] << " ";
std::cout << "]\n";
}
return 0;
}
和Utilities.cu个文件被隐藏here，此处省略。 Utilities.cuh和TimingGPU.cu维护here，也会被省略。
我在Kepler K20c上测试了上述代码，结果如下：
TimingGPU.cuh在 Thrust cuBLAS
2500 x 1250 0.20ms 0.25ms
5000 x 2500 0.77ms 0.83ms
时间，我排除了cuBLAS时间。即便如此，CUDA Thrust版本似乎更方便。