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 流。

amax( x ) ¶: 与 np.argmax(x) 相同

amin( x ) ¶: 与 np.argmin(x) 相同

asum( x ) ¶: 与 np.sum(x) 相同

axpy( alpha , x , y ) ¶: 与 y = alpha * x + y 相同

dgmm( side , m , n , A:r , x:r , C:w ) ¶

dot( x , y ) ¶: 与 np.dot 相同

dotc( x , y ) ¶: 与 np.vdot 相同

gbmv( trans , m , n , kl , ku , alpha , A:r , x:r , beta , y:w ) ¶

geam( transa , transb , m , n , alpha , A:r , beta , B:r , C:w ) ¶

gemm( transa , transb , m , n , k , alpha , A:r , B:r , beta , C:w ) ¶

gemv( trans , m , n , alpha , A:r , x:r , beta , y:w ) ¶

ger( m , n , alpha , x:r , y:r , A:w ) ¶

gerc( m , n , alpha , x:r , y:r , A:w ) ¶

geru( m , n , alpha , x:r , y:r , A:w ) ¶

hbmv( uplo , n , k , alpha , A:r , x:r , beta , y:w ) ¶

hemm( side , uplo , m , n , alpha , A:r , B:r , beta , C:w ) ¶

hemv( uplo , n , alpha , A:r , x:r , beta , y:w ) ¶

her( uplo , n , alpha , x:r , A:w ) ¶

her2( uplo , n , alpha , x:r , y:r , A:w ) ¶

herk( uplo , trans , n , k , alpha , A:r , beta , C:w ) ¶

hpmv( uplo , n , alpha , AP:r , x:r , beta , y:w ) ¶

hpr( uplo , n , alpha , x:r , AP:w ) ¶

hpr2( uplo , n , alpha , x:r , y:r , A:w ) ¶

nrm2( x ) ¶: 与 np.linalg.norm 相同

rot( x , y , c , s ) ¶: 同 x, y = c * x + s * y, -s * x + c * y

rotg( a , b ) ¶

给定列向量 (a, b) 计算给定的旋转矩阵。返回 r、z、c、s。

r — r = a ** 2 + b ** 2 z — 用于恢复 c 和 s。

如果 abs(z) < 1：

c, s = 1 - z ** 2, z

elif abs(z) == 1:

c, s = 0, 1

别的：

c, s = 1 / z, 1 - z ** 2

c — 旋转矩阵的余弦元素。s — 旋转矩阵的正弦元素。

rotm( x , y ,参数) ¶

应用修改后的 Givens 变换。

x, y = h11 * x + h12 * y, h21 * x + h22 * y

参数 — [flag, h11, h21, h12, h22]

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

rotmg( d1 , d2 , x1 , y1 ) ¶

构造修改后的 Givens 变换。

返回可在 rotm 中使用的参数。

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

sbmv( uplo , n , k , alpha , A:r , x:r , beta , y:w ) ¶

scal(阿尔法, x ) ¶: 与 x = alpha * x 相同

spmv( uplo , n , alpha , AP:r , x:r , beta , y:w ) ¶

spr( uplo , n , alpha , x:r , AP:w ) ¶

spr2( uplo , n , alpha , x:r , y:r , A:w ) ¶

symm( side , uplo , m , n , alpha , A:r , B:r , beta , C:w ) ¶

symv( uplo , n , alpha , A:r , x:r , beta , y:w ) ¶

syr( uplo , n , alpha , x:r , A:w ) ¶

syr2( uplo , n , alpha , x:r , y:r , A:w ) ¶

syrk( uplo , trans , n , k , alpha , A:r , beta , C:w ) ¶

tbmv( uplo , trans , diag , n , k , A:r , x:w ) ¶

tbsv( uplo , trans , diag , n , k , A:r , x:w ) ¶

tpmv( uplo , trans , diag , n , AP:r , x:w ) ¶

tpsv( uplo , trans , diag , n , AP:r , x:w ) ¶

trmm( side , uplo , trans , diag , m , n , alpha , A:r , B:r , C:w ) ¶

trmv( uplo , trans , diag , n , A:r , x:w ) ¶

trsm( side , uplo , trans , diag , m , n , alpha , A:r , B:w ) ¶

trsv( uplo , trans , diag , n , A:r , x:w ) ¶

BLAS 级别 1 ¶

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

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

参数：	x ( array ) – 输入向量
返回：	结果规范。

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

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

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

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

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

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

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

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

参数：	alpha – 标量 x (数组) – 向量

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

原地计算y = alpha * x + y。

参数：	alpha – 标量 x (数组) – 向量

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

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

参数：	x (数组) – 向量
返回：	索引（从 0 开始）。

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

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

参数：	x (数组) – 向量
返回：	索引（从 0 开始）。

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

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

参数：	x (数组) – 向量
返回：	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 (数组) – 向量 y (数组) – 向量

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 变换。

和...一样：

参数 = 标志,  h11 ,  h21 ,  h12 ,  h22 
x [ i ]  =  h11  *  x [ i ]  +  h12  *  y [ i ] 
y [ i ]  =  h21  *  x [ i ]  +  h22  *  y [ i ]

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

参数：	x (数组) – 向量 y (数组) – 向量

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（侧面，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（侧面，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 )

三角矩阵-矩阵乘法：

如果边 == ':'
    C = alpha * op(A) * B
其他：#边=='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)