cuBLAS

提供基本的线性代数积木。请参阅NVIDIA cuBLAS

cuBLAS 绑定提供了一个接受 NumPy 数组和 Numba 的 CUDA 设备数组的接口。绑定会根据需要自动将 NumPy 数组参数传输到设备。这种自动传输可能会产生一些不必要的传输,因此通过将 NumPy 阵列手动传输到设备阵列并在可能的情况下使用 cuBLAS 操作设备阵列,可能会获得最佳性能。

与 BLAS C 和 Fortran API 不同,没有使用特殊的命名约定来标识数据类型。作为 cuBLAS C API 一部分的数组存储信息的参数也不是必需的,因为 NumPy 数组和设备数组包含此信息。

所有函数都通过accelerate.cuda.blas.Blas类访问:

accelerate.cuda.blas.Blas( *args , **kws )

所有 BLAS 子程序都在 Blas 对象下可用。

参数:- 可选。一个 CUDA 流。

BLAS 级别 1

accelerate.cuda.blas.Blas.nrm2( x )

计算数组x的 L2 范数。与numpy.linalg.norm(x)相同。

参数:x ( python.array ) – 输入向量
返回:结果规范。
accelerate.cuda.blas.Blas.dot( x , y )

计算数组x和数组y的点积。与np.dot(x, y) 相同

参数:
  • x ( python.array ) – 向量
  • y ( python.array ) – 向量
返回:

xy 的点积

accelerate.cuda.blas.Blas.dotc( x , y )

使用向量元素的共轭计算仅用于复数 dtype的数组x和数组y的点积。与np.vdot(x, y) 相同

参数:
  • x ( python.array ) – 向量
  • y ( python.array ) – 向量
返回:

xy 的点积

accelerate.cuda.blas.Blas.scal(阿尔法, x )

按 alpha 就地缩放x。与x = alpha * x 相同

参数:
  • alpha – 标量
  • x ( python.array ) – 向量
accelerate.cuda.blas.Blas.axpy(阿尔法, x )

原地计算y = alpha * x + y

参数:
  • alpha – 标量
  • x ( python.array ) – 向量
accelerate.cuda.blas.Blas.amax( x )

查找数组x 中第一个最大元素的索引。与np.argmax(x)相同

参数:x ( python.array ) – 向量
返回:索引(从 0 开始)。
accelerate.cuda.blas.Blas.amin( x )

查找数组x 中第一个最大元素的索引。与np.argmin(x)相同

参数:x ( python.array ) – 向量
返回:索引(从 0 开始)。
accelerate.cuda.blas.Blas.asum( x )

计算数组x中所有元素的总和。

参数:x ( python.array ) – 向量
返回:x.sum()
accelerate.cuda.blas.Blas.rot( x , y , c , s )

对向量元素xy应用由余弦元素c和正弦元素s指定的 Givens 旋转矩阵。

x, y = c * x + s * y, -s * x + c * y

参数:
  • x ( python.array ) – 向量
  • y ( python.array ) – 向量
accelerate.cuda.blas.Blas.rotg( a , b )

使用列向量 (a, b) 构造 Givens 旋转矩阵。

参数:
  • a – 列向量的第一个元素
  • b – 列向量的第二个元素
返回:

元组 (r, z, c, s)

r – r = a**2 + b**2

z – 用于重建cs

有关详细信息,请参阅 cuBLAS 文档。

c – 余弦元素。

s – 正弦元素。

accelerate.cuda.blas.Blas.rotm( x , y ,参数)

就地应用修改后的 Givens 变换。

和...一样:

param = flag, h11, h21, h12, h22
x[i] = h11 * x[i] + h12 * y[i]
y[i] = h21 * x[i] + h22 * y[i]

有关flag的使用,请参阅 cuBLAS 文档。

参数:
  • x ( python.array ) – 向量
  • y ( python.array ) – 向量
accelerate.cuda.blas.Blas.rotmg( d1 , d2 , x1 , y1 )

构造修改后的 Givens 变换H,将列向量(d1 * x1, d2 * y1)的第二个条目清零。

参数:
  • d1 – 输入向量 x 坐标的缩放因子
  • d2 – 输入向量 y 坐标的缩放因子
  • x1 – 输入向量的 x 坐标
  • y1 – 输入向量的 y 坐标
返回:

可用于rotm 的一维数组。第一个元素是rotm的标志。其余元素对应于Hh11, h21, h12, h22 元素。

BLAS 级别 2

所有 2 级例程都遵循以下所有参数的命名约定:

  • A、B、C、AP——(二维数组)矩阵参数。

    AP意味着带状矩阵的打包存储。

  • x, y, z –(一维数组)向量参数。

  • alpha, beta –(标量)可以是浮点数或复数,具体取决于。

  • m –(标量)矩阵A的行数。

  • n –(标量)矩阵A的列数。如果不需要m

    n也表示矩阵A的行数;因此,意味着一个方阵。

  • trans, transa, transb –(字符串)

    选择要应用于矩阵的操作op

    • 'N': op(X) = X,恒等运算;
    • 'T': op(X) = X**T,转置;
    • 'C': op(X) = X**H,共轭转置。

    trans仅适用于唯一的矩阵参数。 transatransb 分别适用于矩阵A和矩阵B

  • uplo –(字符串)可以是 'U' 用于填充上三角矩阵;或 'L' 表示

    填充下三角矩阵。

  • diag – (boolean) 矩阵对角线是否有单位元素。

  • mode – (string) 'L' 表示矩阵在方程的左边。

    'R' 表示矩阵在等式的右侧。

笔记

最后一个数组参数总是被结果覆盖。

accelerate.cuda.blas.Blas.gbmv( trans , m , n , kl , ku , alpha , A , x , beta , y )

带状矩阵向量乘法y = alpha * op(A) * x + beta * y其中 Akl 条子对角线和ku 条超对角线。

accelerate.cuda.blas.Blas.gemv( trans , m , n , alpha , A , x , beta , y )

矩阵向量乘法y = alpha * op(A) * x + beta * y

accelerate.cuda.blas.Blas.trmv( uplo , trans , diag , n , A , x )

三角矩阵向量乘法x = op(A) * x

accelerate.cuda.blas.Blas.tbmv( uplo , trans , diag , n , k , A , x )

三角带状矩阵向量x = op(A) * x

accelerate.cuda.blas.Blas.tpmv( uplo , trans , diag , n , AP , x )

三角压缩矩阵向量乘法x = op(A) * x

accelerate.cuda.blas.Blas.trsv( uplo , trans , diag , n , A , x )

求解具有单个右手边的三角形线性系统。 op(A) * x = b

accelerate.cuda.blas.Blas.tpsv( uplo , trans , diag , n , AP , x )

求解具有单个右手边的紧缩三角形线性系统。 op(A) * x = b

accelerate.cuda.blas.Blas.tbsv( uplo , trans , diag , n , k , A , x )

求解具有单个右手边的三角带状线性系统。 op(A) * x = b

accelerate.cuda.blas.Blas.symv( uplo , n , alpha , A , x , beta , y )

对称矩阵向量乘法y = alpha * A * x + beta * y

accelerate.cuda.blas.Blas.hemv( uplo , n , alpha , A , x , beta , y )

Hermitian 矩阵向量乘法y = alpha * A * x + beta * y

accelerate.cuda.blas.Blas.sbmv( uplo , n , k , alpha , A , x , beta , y )

对称带状矩阵向量乘法 y = alpha * A * x + beta * y

accelerate.cuda.blas.Blas.hbmv( uplo , n , k , alpha , A , x , beta , y )

Hermitian 带状矩阵向量乘法 y = alpha * A * x + beta * y

accelerate.cuda.blas.Blas.spmv( uplo , n , alpha , AP , x , beta , y )

对称压缩矩阵向量乘法y = alpha * A * x + beta * y

accelerate.cuda.blas.Blas.hpmv( uplo , n , alpha , AP , x , beta , y )

Hermitian 压缩矩阵向量乘法y = alpha * A * x + beta * y

accelerate.cuda.blas.Blas.ger( m , n , alpha , x , y , A )

rank-1 更新A := alpha * x * y ** T + A

accelerate.cuda.blas.Blas.geru( m , n , alpha , x , y , A )

rank-1 更新A := alpha * x * y ** T + A

accelerate.cuda.blas.Blas.gerc( m , n , alpha , x , y , A )

rank-1 更新A := alpha * x * y ** H + A

accelerate.cuda.blas.Blas.syr( uplo , n , alpha , x , A )

对称秩 1 操作A := alpha * x * x ** T + A

accelerate.cuda.blas.Blas.her( uplo , n , alpha , x , A )

Hermitian rank 1 operation A := alpha * x * x ** H + A

accelerate.cuda.blas.Blas.spr( uplo , n , alpha , x , AP )

对称秩 1 运算A := alpha * x * x ** T + A

accelerate.cuda.blas.Blas.hpr( uplo , n , alpha , x , AP )

Hermitian rank 1 operation A := alpha * x * x ** H + A

accelerate.cuda.blas.Blas.syr2( uplo , n , alpha , x , y , A )

对称秩 2 更新A = alpha * x * y ** T + y * x ** T + A

accelerate.cuda.blas.Blas.her2( uplo , n , alpha , x , y , A )

Hermitian rank-2 更新A = alpha * x * y ** H + alpha * y * x ** H + A

accelerate.cuda.blas.Blas.spr2( uplo , n , alpha , x , y , A )

压缩对称秩 2 更新A = alpha * x * y ** T + y * x ** T + A

accelerate.cuda.blas.Blas.hpr2( uplo , n , alpha , x , y , A )

打包 Hermitian rank-2 更新A = alpha * x * y ** H + alpha * y * x ** H + A

BLAS 级别 3

所有级别 3 例程都遵循与级别 2 例程相同的参数命名约定。

accelerate.cuda.blas.Blas.gemm( transa , transb , m , n , k , alpha , A , B , beta , C )

矩阵-矩阵乘法C = alpha * op(A) * op(B) + beta * C

accelerate.cuda.blas.Blas.syrk( uplo , trans , n , k , alpha , A , beta , C )

对称秩 - k 更新C = alpha * op(A) * op(A) ** T + beta * C

accelerate.cuda.blas.Blas.herk( uplo , trans , n , k , alpha , A , beta , C )

Hermitian rank-k 更新C = alpha * op(A) * op(A) ** H + beta * C

accelerate.cuda.blas.Blas.symm( side , uplo , m , n , alpha , A , B , beta , C )

对称矩阵-矩阵乘法:

if  side == 'L':
    C = alpha * A * B + beta * C
else:  # side == 'R'
    C = alpha * B * A + beta * C
accelerate.cuda.blas.Blas.hemm( side , uplo , m , n , alpha , A , B , beta , C )

厄米矩阵-矩阵乘法:

if  side == 'L':
    C = alpha * A * B + beta * C
else:   #  side == 'R':
    C = alpha * B * A + beta * C
accelerate.cuda.blas.Blas.trsm( side , uplo , trans , diag , m , n , alpha , A , B )

求解具有多个右手边的三角线性系统:

if  side == 'L':
    op(A) * X = alpha * B
else:       # side == 'R'
    X * op(A) = alpha * B
accelerate.cuda.blas.Blas.trmm( side , uplo , trans , diag , m , n , alpha , A , B , C )

三角矩阵-矩阵乘法:

if  side == ':'
    C = alpha * op(A) * B
else:   # side == 'R'
    C = alpha * B * op(A)
accelerate.cuda.blas.Blas.dgmm(, m , n , A , x , C )

矩阵-矩阵乘法:

if  mode == 'R':
    C = A * x * diag(X)
else:       # mode == 'L'
    C = diag(X) * x * A
accelerate.cuda.blas.Blas.geam( transa , transb , m , n , alpha , A , beta , B , C )

矩阵-矩阵加法/转置C = alpha * op(A) + beta * op(B)