GPU阵列#
向量类型#
- class pycuda.gpuarray.vec#
所有CUDA支持的向量类型,例如 float3 和 long4 可用作
numpy
此类中的数据类型。这些numpy.dtype
实例的字段名为 x , y , z 和 w 就像他们的cuda对手一样。它们既可以用于参数传递到内核,也可以用于在内核和python代码之间来回传递数据。对于每种类型,a make_type 还提供了功能(例如 make_float3(x,y,z) )
这个 GPUArray
数组类#
- class pycuda.gpuarray.GPUArray(shape, dtype, *, allocator=None, order='C')#
A
numpy.ndarray
存储数据并在计算设备上执行计算的类似工作。 形状 和 D型 工作完全一样numpy
. 中的算术方法GPUArray
支持标量的广播。(例如) array+5 如果分配器 是一个可调用的,当调用一个要分配的字节数的参数时,返回一个可以被转换为一个对象的对象。
int
表示新分配内存的地址。注意两个pycuda.driver.mem_alloc()
和pycuda.tools.DeviceMemoryPool.alloc()
是这个接口的一个模型。除此之外的所有论据 分配器 只应视为关键字。
- gpudata#
这个
pycuda.driver.DeviceAllocation
为支持此操作的内存创建的实例GPUArray
.
- shape#
数组中每个维度长度的元组。
- dtype#
这个
numpy.dtype
GPU数组中的项。
- mem_size#
数组中存在的条目总数,包括填充。例如,由于通过
pycuda.driver.mem_alloc_pitch()
.
- strides#
遍历数组时要在每个维度中单步执行的字节元组。
- flags#
返回具有属性的对象 c_contiguous , f_contiguous 和 forc ,可用于查询类似于
numpy.ndarray.flags
.
- __cuda_array_interface__#
返回一个 CUDA Array Interface 描述此数组数据的字典。
- __len__()#
返回的前导维度的大小 self .
- reshape(shape, order='C')#
返回包含具有新形状的相同数据的数组。
- ravel()#
返回包含相同数据的展平数组。
- view(dtype=None)#
返回具有相同数据的数组视图。如果 D型 与当前数据类型不同,将重新解释内存的实际字节数。
- squeeze(dtype=None)#
返回已删除长度为1的数组的视图。
- set(ary)#
将内容转移到
numpy.ndarray
对象 ary 在设备上。ary 必须具有与 self .
- set_async(ary, stream=None)#
异步传输内容
numpy.ndarray
对象 ary 在设备上,可以选择在 流动 .ary 必须具有与 self .
- get(ary=None, pagelocked=False)#
转移的内容 self 进入之内 ary 或新分配的
numpy.ndarray
.如果 ary 给定时,它必须具有相同的形状和数据类型。如果没有提供,则 页面锁定 指定是否为新数组分配页锁定。在 2015.2 版本发生变更: ary 不同的形状被弃用。
- get_async(stream=None, ary=None)#
转移的内容 self 进入之内 ary 或新分配的
numpy.ndarray
.如果 ary 给定时,它必须具有正确的大小(不一定是形状)和数据类型。如果没有提供,则 page-locked 数组是新分配的。
- copy()#
在 2013.1 版本加入.
- mul_add(self, selffac, other, otherfac, add_timer=None, stream=None):
返回 selffac*self + otherfac*other . add_timer ,如果给定,则使用
pycuda.driver.Function.prepared_timed_call()
.
- __add__(other)#
- __sub__(other)#
- __iadd__(other)#
- __isub__(other)#
- __neg__(other)#
- __mul__(other)#
- __div__(other)#
- __rdiv__(other)#
- __pow__(other)#
- fill(scalar, stream=None)#
在数组中填充 标量 .
- astype(dtype, stream=None)#
返回 self 铸成 D型 .
- any(stream=None, allocator=None)#
- all(stream=None, allocator=None)#
- real#
返回的实际部分 self 或 self 如果是真的。
在 0.94 版本加入.
- imag#
返回的虚部 self 或 zeros_like(self) 如果是真的。
- conj(out=None)#
返回的复共轭 self ,或 self 如果这是真的。如果 out 未给予,则新分配的
GPUArray
威尔回来了。使用 out=self 把共轭放在合适的位置。在 2020.1.1 版本发生变更: 添加 out 参数
- bind_to_texref(texref, allow_offset=False)#
Bind self to the
pycuda.driver.TextureReference
texref.由于对齐要求,有效的纹理绑定地址可能与请求的地址相差一个偏移量。此方法返回此偏移量,单位为 self 的数据类型。如果 allow_offset 是
False
,此偏移量的非零值将导致引发异常。备注
建议使用
bind_to_texref_ext()
而不是这种方法。
- bind_to_texref_ext(texref, channels=1, allow_double_hack=False, allow_offset=False)#
Bind self to the
pycuda.driver.TextureReference
texref. In addition, set the texture reference's format to matchdtype
and its channel count to channels. This routine also sets the texture reference'spycuda.driver.TRSF_READ_AS_INTEGER
flag, if necessary.由于对齐要求,有效的纹理绑定地址可能与请求的地址相差一个偏移量。此方法返回此偏移量,单位为 self 的数据类型。如果 allow_offset 是
False
,此偏移量的非零值将导致引发异常。在 0.93 版本加入.
在撰写本文时,CUDA纹理本身不支持双精度浮点数据。为了弥补这一缺陷,PycUDA包含一个解决方案,它可以通过 True 为了允许你的双重攻击。在这种情况下,请在内核代码中使用以下代码进行纹理访问:
#include <pycuda-helpers.hpp> texture<fp_tex_double, 1, cudaReadModeElementType> my_tex; __global__ void f() { ... fp_tex1Dfetch(my_tex, threadIdx.x); ... }
(此解决方案在版本0.94中添加)。
构造 GPUArray
实例#
- pycuda.gpuarray.to_gpu(ary, allocator=None)#
返回A
GPUArray
那是numpy.ndarray
实例 ary .见
GPUArray
为了…的意义 分配器 .
- pycuda.gpuarray.to_gpu_async(ary, allocator=None, stream=None)#
返回A
GPUArray
那是numpy.ndarray
实例 ary . 复制是异步完成的,可以选择顺序为 流动 .见
GPUArray
为了…的意义 分配器 .
- pycuda.gpuarray.zeros(shape, dtype=np.float64, *, allocator=None, order='C')#
- pycuda.gpuarray.ones(shape, dtype=np.float64, *, allocator=None, order='C')#
- pycuda.gpuarray.empty_like(other_ary, dtype=None, order='K')#
创建新的、未初始化的
GPUArray
具有与 other_ary . 这个 D型 和 秩序 属性允许这些方面独立于 other_ary . 为了 秩序 如果输入是Fortran连续的,则“A”表示保留Fortran顺序,否则使用“C”顺序。默认情况下, 秩序 或者“k”试图与 other_ary 尽可能接近。
- pycuda.gpuarray.zeros_like(other_ary, dtype=None, order='K')#
创建一个新的、初始化为零的
GPUArray
具有与 other_ary . 这个 D型 和 秩序 属性允许这些方面独立于 other_ary . 为了 秩序 如果输入是Fortran连续的,则“A”表示保留Fortran顺序,否则使用“C”顺序。默认情况下, 秩序 或者“k”试图与 other_ary 尽可能接近。
- pycuda.gpuarray.ones_like(other_ary, dtype=None, order='K')#
创建一个新的,已初始化的
GPUArray
具有与 other_ary . 这个 D型 和 秩序 属性允许这些方面独立于 other_ary . 为了 秩序 如果输入是Fortran连续的,则“A”表示保留Fortran顺序,否则使用“C”顺序。默认情况下, 秩序 或者“k”试图与 other_ary 尽可能接近。
- pycuda.gpuarray.arange(start, stop, step, dtype=None, stream=None)#
创建一个
GPUArray
填充数字间隔 step 分开,从 start 结束于 stop .对于浮点参数,结果的长度为 ceil((stop - start)/step) . 此规则可能导致结果的最后一个元素大于 stop .
D型 ,如果未指定,则被视为 开始 , stop 和 step .
- pycuda.gpuarray.take(a, indices, stream=None)#
返回
GPUArray
[a[indices[0]], ..., a[indices[n]]]
. 就目前而言, a 必须是可以绑定到纹理的类型。
- pycuda.gpuarray.concatenate(arrays, axis=0, allocator=None)#
沿现有轴合并数组序列。
- pycuda.gpuarray.stack(arrays, axis=0, allocator=None)#
沿新的轴合并一系列数组。
- pycuda.gpuarray.logical_and(x1, x2, /, out=None, * allocator=None)#
返回的元素式逻辑AND值 x1 和 x2 。
- pycuda.gpuarray.logical_or(x1, x2, /, out=None, * allocator=None)#
返回的元素式逻辑或值 x1 和 x2 。
- pycuda.gpuarray.logical_not(x, /, out=None, * allocator=None)#
返回元素形式的逻辑NOT OF x 。
条件句#
- pycuda.gpuarray.if_positive(criterion, then_, else_, out=None, stream=None)#
返回类似于 then_ ,对于索引处的元素 i 包含 [then_[i]] 如果 [criterion[i]>0] ,否则 [else_[i]] . (在0.94中添加)
- pycuda.gpuarray.maximum(a, b, out=None, stream=None)#
返回元素的最大值 a 和 b . (在0.94中添加)
- pycuda.gpuarray.minimum(a, b, out=None, stream=None)#
返回元素的最小值 a 和 b . (在0.94中添加)
约简#
- pycuda.gpuarray.sum(a, dtype=None, stream=None)#
- pycuda.gpuarray.any(a, stream=None, allocator=None)#
- pycuda.gpuarray.all(a, stream=None, allocator=None)#
- pycuda.gpuarray.subset_sum(subset, a, dtype=None, stream=None)#
在 2013.1 版本加入.
- pycuda.gpuarray.dot(a, b, dtype=None, stream=None)#
- pycuda.gpuarray.subset_dot(subset, a, b, dtype=None, stream=None)#
- pycuda.gpuarray.max(a, stream=None)#
- pycuda.gpuarray.min(a, stream=None)#
- pycuda.gpuarray.subset_max(subset, a, stream=None)#
- pycuda.gpuarray.subset_min(subset, a, stream=None)#
上的元素级函数 GPUArray
实例#
这个 pycuda.cumath
模块包含包含 math
.
舍入和绝对值#
- pycuda.cumath.fabs(array, *, out=None, stream=None)#
- pycuda.cumath.ceil(array, *, out=None, stream=None)#
- pycuda.cumath.floor(array, *, out=None, stream=None)#
指数、对数和根#
- pycuda.cumath.exp(array, *, out=None, stream=None)#
- pycuda.cumath.log(array, *, out=None, stream=None)#
- pycuda.cumath.log10(array, *, out=None, stream=None)#
- pycuda.cumath.sqrt(array, *, out=None, stream=None)#
三角函数#
- pycuda.cumath.sin(array, *, out=None, stream=None)#
- pycuda.cumath.cos(array, *, out=None, stream=None)#
- pycuda.cumath.tan(array, *, out=None, stream=None)#
- pycuda.cumath.asin(array, *, out=None, stream=None)#
- pycuda.cumath.acos(array, *, out=None, stream=None)#
- pycuda.cumath.atan(array, *, out=None, stream=None)#
双曲函数#
- pycuda.cumath.sinh(array, *, out=None, stream=None)#
- pycuda.cumath.cosh(array, *, out=None, stream=None)#
- pycuda.cumath.tanh(array, *, out=None, stream=None)#
浮点分解与汇编#
- pycuda.cumath.fmod(arg, mod, stream=None)#
返回除法的浮点余数 arg/mod ,对于中的每个元素 arg 和 mod .
- pycuda.cumath.frexp(arg, stream=None)#
返回元组 (significands, exponents) 这样的话 arg == significand * 2**exponent .
- pycuda.cumath.ldexp(significand, exponent, stream=None)#
返回一个新的浮点值数组,该数组由 significand 和 exponent ,配对为 result = significand * 2**exponent .
- pycuda.cumath.modf(arg, stream=None)#
返回元组 (fracpart, intpart) 包含 arg .
生成随机数数组#
- pycuda.curandom.rand(shape, dtype=numpy.float32, stream=None)#
返回一个数组 shape 填充随机值 dtype 在[0,1]范围内。
备注
这个函数的用例是“我需要一些随机数。它使用了一个非常糟糕的基于md5的生成器,甚至不尝试缓存生成的代码。
如果您对非玩具随机数生成器感兴趣,请使用下面基于curand的功能。
警告
以下类使用在GPU上运行的随机数生成器。每个线程都使用自己的生成器。创建这些生成器比随后生成的随机数需要更多的资源。在实验之后,特斯拉设备上的最大活动发电机数量(计算能力为1.x)看起来是256个。费米装置允许创建1024个发电机没有任何问题。如果创建类pseudorandomNumberGenerator或quasirandomNumberGenerator的对象时出现问题,请减少创建的生成器的数量(从而减少活动线程的数量)。
伪随机数列满足真正随机数列的大多数统计特性,但由确定性算法生成。利用均匀填充n维空间的确定性算法生成n维点的拟irandom序列。
类星体数字的生成成本更高。
- pycuda.curandom.get_curand_version()#
获取PyCUDA编译的Curand版本。返回3元组整数作为 (主要、次要、修订) .
- pycuda.curandom.seed_getter_uniform(N)#
返回一
GPUArray
充满一个随机的 int32 重复的 N 可以用作XOWOW发生器的种子的时间。
- pycuda.curandom.seed_getter_unique(N)#
返回一
GPUArray
充满 N 随机的 int32 可以作为XOWOW发生器的种子使用。
- class pycuda.curandom.XORWOWRandomNumberGenerator(seed_getter=None, offset=0)#
- 参数:
seed_getter -- 一个给定整数计数的函数,它将产生一个 int32
GPUArray
种子的offset -- 给定种子,开始索引到xorwow序列。
提供伪随机数。生成至少包含周期的序列 \(2^190\) .
CUDA 3.2及以上。
在 2011.1 版本加入.
- fill_uniform(data, stream=None)#
Fills in
GPUArray
data with uniformly distributed pseudorandom values.
- gen_uniform(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。
- fill_normal(data, stream=None)#
Fills in
GPUArray
data with normally distributed pseudorandom values.
- gen_normal(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。
- fill_log_normal(data, mean, stddev, stream=None)#
Fills in
GPUArray
data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.CUDA 4.0及以上。
在 2012.2 版本加入.
- gen_log_normal(shape, dtype, mean, stddev, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。CUDA 4.0及以上。
在 2012.2 版本加入.
- fill_poisson(data, lambda_value=None, stream=None)#
Fills in
GPUArray
data with Poisson distributed pseudorandom values.如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。
如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。
CUDA 5.0及以上。
在 2013.1 版本加入.
- gen_poisson(shape, dtype, lambda_value, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。CUDA 5.0及以上。
在 2013.1 版本加入.
- call_skip_ahead(i, stream=None)#
强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。
- call_skip_ahead_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少个值。
- call_skip_ahead_sequence(i, stream=None)#
强制所有生成器跳过子序列。相当于生成* \(2^67\) 值和丢弃结果,但要快得多。
- call_skip_ahead_sequence_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少子序列。
- class pycuda.curandom.MRG32k3aRandomNumberGenerator(seed_getter=None, offset=0)#
- 参数:
seed_getter -- 一个给定整数计数的函数,它将产生一个 int32
GPUArray
种子的offset -- 给定种子,开始索引到xorwow序列。
提供伪随机数。生成至少包含周期的序列 \(2^190\) .
CUDA 4.1及以上。
在 2013.1 版本加入.
- fill_uniform(data, stream=None)#
Fills in
GPUArray
data with uniformly distributed pseudorandom values.
- gen_uniform(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。
- fill_normal(data, stream=None)#
Fills in
GPUArray
data with normally distributed pseudorandom values.
- gen_normal(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。
- fill_log_normal(data, mean, stddev, stream=None)#
Fills in
GPUArray
data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.
- gen_log_normal(shape, dtype, mean, stddev, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。
- fill_poisson(data, lambda_value, stream=None)#
Fills in
GPUArray
data with Poisson distributed pseudorandom values.如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。
如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。
CUDA 5.0及以上。
在 2013.1 版本加入.
- gen_poisson(shape, dtype, lambda_value, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。CUDA 5.0及以上。
在 2013.1 版本加入.
- call_skip_ahead(i, stream=None)#
强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。
- call_skip_ahead_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少个值。
- call_skip_ahead_sequence(i, stream=None)#
强制所有生成器跳过子序列。相当于生成* \(2^67\) 值和丢弃结果,但要快得多。
- call_skip_ahead_sequence_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少子序列。
- pycuda.curandom.generate_direction_vectors(count, direction=direction_vector_set.VECTOR_32)#
返回一
GPUArray
count 填充用于初始化sobol生成器的方向向量。
- pycuda.curandom.generate_scramble_constants32(count)#
返回A
GPUArray
充满 count' 32-bit unsigned integer numbers used to initialize :class: 加扰双簧管32和数字发电机`
- pycuda.curandom.generate_scramble_constants64(count)#
返回A
GPUArray
充满 count' 64-bit unsigned integer numbers used to initialize :class: 随机数发生器`
- class pycuda.curandom.Sobol32RandomNumberGenerator(dir_vector=None, offset=0)#
- 参数:
dir_vector -- 一
GPUArray
共32个元素 int32 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量offset -- 开始索引到sobol32序列,给定方向向量。
提供类irandom数。生成周期为的序列 \(2^32\) .
CUDA 3.2及以上。
在 2011.1 版本加入.
- fill_uniform(data, stream=None)#
Fills in
GPUArray
data with uniformly distributed quasirandom values.
- gen_uniform(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。
- fill_normal(data, stream=None)#
Fills in
GPUArray
data with normally distributed quasirandom values.
- gen_normal(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。
- fill_log_normal(data, mean, stddev, stream=None)#
Fills in
GPUArray
data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.CUDA 4.0及以上。
在 2012.2 版本加入.
- gen_log_normal(shape, dtype, mean, stddev, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。CUDA 4.0及以上。
在 2012.2 版本加入.
- fill_poisson(data, lambda_value, stream=None)#
Fills in
GPUArray
data with Poisson distributed pseudorandom values.如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。
如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。
CUDA 5.0及以上。
在 2013.1 版本加入.
- gen_poisson(shape, dtype, lambda_value, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。CUDA 5.0及以上。
在 2013.1 版本加入.
- call_skip_ahead(i, stream=None)#
强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。
- call_skip_ahead_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少个值。
- class pycuda.curandom.ScrambledSobol32RandomNumberGenerator(dir_vector=None, scramble_vector=None, offset=0)#
- 参数:
dir_vector -- 一
GPUArray
共32个元素 uint32 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量scramble_vector -- 一
GPUArray
属于 uint32 用于初始化Quasirandom生成器的元素;每个初始化生成器必须包含一个数字offset -- 开始索引到sobol32序列,给定方向向量。
提供类irandom数。生成周期为的序列 \(2^32\) .
CUDA 4.0及以上。
在 2011.1 版本加入.
- fill_uniform(data, stream=None)#
Fills in
GPUArray
data with uniformly distributed quasirandom values.
- gen_uniform(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。
- fill_normal(data, stream=None)#
Fills in
GPUArray
data with normally distributed quasirandom values.
- gen_normal(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。
- fill_log_normal(data, mean, stddev, stream=None)#
Fills in
GPUArray
data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.CUDA 4.0及以上。
在 2012.2 版本加入.
- gen_log_normal(shape, dtype, mean, stddev, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。CUDA 4.0及以上。
在 2012.2 版本加入.
- fill_poisson(data, lambda_value, stream=None)#
Fills in
GPUArray
data with Poisson distributed pseudorandom values.如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。
如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。
CUDA 5.0及以上。
在 2013.1 版本加入.
- gen_poisson(shape, dtype, lambda_value, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。CUDA 5.0及以上。
在 2013.1 版本加入.
- call_skip_ahead(i, stream=None)#
强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。
- call_skip_ahead_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少个值。
- class pycuda.curandom.Sobol64RandomNumberGenerator(dir_vector=None, offset=0)#
- 参数:
dir_vector -- 一
GPUArray
共64个元素 uint64 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量offset -- 给定方向向量,开始索引到sobol64序列。
提供类irandom数。生成周期为的序列 \(2^64\) .
CUDA 4.0及以上。
在 2011.1 版本加入.
- fill_uniform(data, stream=None)#
Fills in
GPUArray
data with uniformly distributed quasirandom values.
- gen_uniform(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。
- fill_normal(data, stream=None)#
Fills in
GPUArray
data with normally distributed quasirandom values.
- gen_normal(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。
- fill_log_normal(data, mean, stddev, stream=None)#
Fills in
GPUArray
data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.CUDA 4.0及以上。
在 2012.2 版本加入.
- gen_log_normal(shape, dtype, mean, stddev, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。CUDA 4.0及以上。
在 2012.2 版本加入.
- fill_poisson(data, lambda_value, stream=None)#
Fills in
GPUArray
data with Poisson distributed pseudorandom values.如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。
如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。
CUDA 5.0及以上。
在 2013.1 版本加入.
- gen_poisson(shape, dtype, lambda_value, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。CUDA 5.0及以上。
在 2013.1 版本加入.
- call_skip_ahead(i, stream=None)#
强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。
- call_skip_ahead_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少个值。
- class pycuda.curandom.ScrambledSobol64RandomNumberGenerator(dir_vector=None, scramble_vector=None, offset=0)#
- 参数:
dir_vector -- 一
GPUArray
共64个元素 uint64 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量scramble_vector -- 一
GPUArray
属于 uint64 用于初始化类irandom生成器的向量;每个初始化生成器必须包含一个向量offset -- 在给定方向向量的情况下,开始索引到加扰双簧管64序列。
提供类irandom数。生成周期为的序列 \(2^64\) .
CUDA 4.0及以上。
在 2011.1 版本加入.
- fill_uniform(data, stream=None)#
Fills in
GPUArray
data with uniformly distributed quasirandom values.
- gen_uniform(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用均匀分布的伪随机值填充它,并返回新创建的对象。
- fill_normal(data, stream=None)#
Fills in
GPUArray
data with normally distributed quasirandom values.
- gen_normal(shape, dtype, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用正态分布的伪随机值填充它,并返回新创建的对象。
- fill_log_normal(data, mean, stddev, stream=None)#
Fills in
GPUArray
data with log-normally distributed pseudorandom values with mean mean and standard deviation stddev.CUDA 4.0及以上。
在 2012.2 版本加入.
- gen_log_normal(shape, dtype, mean, stddev, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用对数正态分布的伪随机值填充 mean 和标准偏差 标准偏差 ,并返回新创建的对象。CUDA 4.0及以上。
在 2012.2 版本加入.
- fill_poisson(data, lambda_value, stream=None)#
Fills in
GPUArray
data with Poisson distributed pseudorandom values.如果 lambda_value 不是无,而是用作lambda,并且 data 必须是32位无符号int类型。
如果 lambda_value 为“无”,则从每个 data 数组元素(类似于numpy.random.poisson),数组被伪随机值覆盖。 data 必须是32位无符号整型、32位或64位浮点型。
CUDA 5.0及以上。
在 2013.1 版本加入.
- gen_poisson(shape, dtype, lambda_value, stream=None)#
创建对象
GPUArray
给予 形状 和 D型 ,用poisson分布的伪随机值填充 lambda_value ,并返回新创建的对象。 D型 必须是32位无符号整数。CUDA 5.0及以上。
在 2013.1 版本加入.
- call_skip_ahead(i, stream=None)#
强制所有生成器跳过i值。相当于生成i值并丢弃结果,但速度要快得多。
- call_skip_ahead_array(i, stream=None)#
接受整数值数组i,告诉每个生成器要跳过多少个值。
单程自定义表达式求值#
计算上涉及的表达式 GPUArray
实例可能有点低效,因为为每个中间结果创建了一个新的临时。模块中的功能 pycuda.elementwise
包含有助于生成内核的工具,这些内核在一次传递中对一个或多个操作数计算多级表达式。
- class pycuda.elementwise.ElementwiseKernel(arguments, operation, name='kernel', keep=False, options=[], preamble='')#
生成一个核,该核接受多个标量或向量 参数 并执行标量 操作 在其参数的每个条目上,如果该参数是向量。
参数 指定为格式化为C参数列表的字符串。 操作 指定为C赋值语句,不带分号。向量在 操作 应该由变量索引 i .
name 指定编译内核的名称, keep 和 选项 未经修改传递给
pycuda.compiler.SourceModule
.序言 指定在ElementWise内核规范之前包含的一些源代码。您可以使用它来包含其他文件和/或定义 操作 .
- __call__(*args, range=None, slice=None)#
调用生成的标量内核。参数可以是标量或
GPUArray
实例。如果 范围 是的,一定是
slice
对象并指定索引的范围。 i 为此 操作 执行。如果 片 是的,一定是
slice
对象并指定索引的范围。 i 为此 操作 执行,截断到容器。也, 片 可能包含相对于数组结尾的负索引。如果 流动 是的,一定是
pycuda.driver.Stream
对象,执行将在其中序列化。
下面是一个用法示例:
import pycuda.gpuarray as gpuarray
import pycuda.driver as cuda
import pycuda.autoinit
import numpy
from pycuda.curandom import rand as curand
a_gpu = curand((50,))
b_gpu = curand((50,))
from pycuda.elementwise import ElementwiseKernel
lin_comb = ElementwiseKernel(
"float a, float *x, float b, float *y, float *z",
"z[i] = a*x[i] + b*y[i]",
"linear_combination")
c_gpu = gpuarray.empty_like(a_gpu)
lin_comb(5, a_gpu, 6, b_gpu, c_gpu)
import numpy.linalg as la
assert la.norm((c_gpu - (5*a_gpu+6*b_gpu)).get()) < 1e-5
(你可以找到这个例子 examples/demo_elementwise.py
在Pycuda分布中。)
自定义缩减#
- class pycuda.reduction.ReductionKernel(dtype_out, neutral, reduce_expr, map_expr=None, arguments=None, name='reduce_kernel', keep=False, options=[], preamble='', allocator=None)#
生成一个核,该核接受多个标量或向量 参数 (至少一个向量参数),执行 map_expr 在向量参数的每个条目上,然后 reduce_expr 关于结果。 中立的 作为初始值。 序言 提供了在实际的缩减内核代码之前添加预处理器指令和其他代码(如助手函数)的可能性。
向量在 map_expr 应该由变量索引 i . reduce_expr 使用形式值“a”和“b”指示二进制缩减操作的两个操作数。如果未指定 map_expr ,“在 [i] “——因此只存在一个输入参数——是自动假定的。 reduce_expr 必须是关联的。
dtype_out 指定
numpy.dtype
其中执行缩减并返回结果。 中立的 指定为浮点或格式为字符串的整数。 reduce_expr 和 map_expr 指定为字符串格式的操作和 参数 指定为格式化为C参数列表的字符串。 name 指定编译内核的名称, keep 和 选项 未经修改传递给pycuda.compiler.SourceModule
. 序言 指定为代码字符串。- __call__(*args, stream=None, out=None)#
调用生成的缩减内核。参数可以是标量,也可以是
GPUArray
实例。将对第一个向量参数的每个条目进行缩减。如果 流动 是的,一定是
pycuda.driver.Stream
对象,执行将在其中序列化。用 out 生成的单个条目
GPUArray
可以指定。因为支持偏移,所以可以在任何地方存储结果(例如out=a [3] )
下面是一个用法示例:
a = gpuarray.arange(400, dtype=numpy.float32)
b = gpuarray.arange(400, dtype=numpy.float32)
krnl = ReductionKernel(numpy.float32, neutral="0",
reduce_expr="a+b", map_expr="x[i]*y[i]",
arguments="float *x, float *y")
my_dot_prod = krnl(a, b).get()
或通过指定输出:
from pycuda.curandom import rand as curand
a = curand((10, 200), dtype=np.float32)
red = ReductionKernel(np.float32, neutral=0,
reduce_expr="a+b",
arguments="float *in")
a_sum = gpuarray.empty(10, dtype=np.float32)
for i in range(10):
red(a[i], out=a_sum[i])
assert(np.allclose(a_sum.get(), a.get().sum(axis=1)))
并行扫描/前缀和#
- class pycuda.scan.ExclusiveScanKernel(dtype, scan_expr, neutral, name_prefix='scan', options=[], preamble='')#
生成一个可以计算 prefix sum 使用任何关联操作 scan_expr . scan_expr 使用形式值“a”和“b”指示关联二进制运算的两个操作数。 中立的 是中性元素 scan_expr 服从 scan_expr(a, neutral) == a .
D型 指定要操作的数组的类型。 name_prefix 用于内核名称,以确保配置文件和日志中的可识别性。 选项 是生成时要使用的编译器选项的列表。 序言 指定在实际内核之前插入的代码字符串。
- __call__(self, input_ary, output_ary=None, allocator=None, queue=None)#
- class pycuda.scan.InclusiveScanKernel(dtype, scan_expr, neutral=None, name_prefix='scan', options=[], preamble='', devices=None)#
作品像
ExclusiveScanKernel
. 与独家案件不同, 中立的 不是必需的。
下面是一个用法示例:
knl = InclusiveScanKernel(np.int32, "a+b")
n = 2**20-2**18+5
host_data = np.random.randint(0, 10, n).astype(np.int32)
dev_data = gpuarray.to_gpu(queue, host_data)
knl(dev_data)
assert (dev_data.get() == np.cumsum(host_data, axis=0)).all()
缩小和扫描中的自定义数据类型#
如果要在扫描和缩减中使用自己的(struct/union/whatever)数据类型,请在 序言 使用此函数让pycuda知道它们:
- pycuda.tools.register_dtype(dtype, name)#
D型 是一个
numpy.dtype()
.
gpgpu算法#
博格丹奥潘丘克 reikna 提供了多种基于gpu的算法(fft、rng、矩阵乘法),可用于 pycuda.gpuarray.GPUArray
物体。