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 ) – 向量
返回：	x和y 的点积

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

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

参数：	x ( python.array ) – 向量 y ( python.array ) – 向量
返回：	x和y 的点积

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

对向量元素x和y应用由余弦元素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 = a2 + b2 z – 用于重建c和s。有关详细信息，请参阅 cuBLAS 文档。 c – 余弦元素。 s – 正弦元素。

a – 列向量的第一个元素
b – 列向量的第二个元素

元组 (r, z, c, s)

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

z – 用于重建c和s。: 有关详细信息，请参阅 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的标志。其余元素对应于H的h11, 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仅适用于唯一的矩阵参数。 transa和transb 分别适用于矩阵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其中 A有kl 条子对角线和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)