torch 订阅
TORCH为多义词:指可导致先天性宫内感染及围产期感染而引起围产儿畸形的病原体,它是一组病原微生物的英文名称缩写,其中T(Toxoplasma)是弓形虫,O(Others)是其他病原微生物,如梅毒螺旋体、带状疱疹病毒、细小病毒B19、柯萨奇病毒等,R(Rubella.Virus)是风疹病毒,C(Cytomegalo.Virus)是巨细胞病毒,H(Herpes.Virus)即是单纯疱疹I/II型。 展开全文
TORCH为多义词:指可导致先天性宫内感染及围产期感染而引起围产儿畸形的病原体,它是一组病原微生物的英文名称缩写,其中T(Toxoplasma)是弓形虫,O(Others)是其他病原微生物,如梅毒螺旋体、带状疱疹病毒、细小病毒B19、柯萨奇病毒等,R(Rubella.Virus)是风疹病毒,C(Cytomegalo.Virus)是巨细胞病毒,H(Herpes.Virus)即是单纯疱疹I/II型。
信息
性    质
病原体
造    成
母婴感染
含    义
一组病原微生物的英文名称缩写
中文名
TORCH
TORCH基本信息
这组微生物感染有着共同的特征,即可造成母婴感染。孕妇由于内分泌改变和免疫力下降易发生原发感染,既往感染的孕妇体内潜在的病毒也容易被激活而发生复发感染。孕妇发生病毒血症时,病毒可通过胎盘或产道传播感染胎儿,引起早产、流产、死胎或畸胎等,以及引起新生儿多个系统、多个器官的损害,造成不同程度的智力障碍等症状。特别在怀孕初的三个月胚胎处于器官形成期,此时受病毒感染,可破坏细胞或抑制细胞的分裂和增殖。器官形成期以后感染病毒,可破坏组织和器官结构,并可形成持续感染,出生后继续排毒,能引起相应的病变。TORCH的感染影响着人口素质,与优生优育有重要关系。
收起全文
精华内容
下载资源
问答
  • Torch

    千次阅读 2018-11-29 16:50:44
    Torch torch包含了多维张量的数据结构以及基于其上的多种数学运算。此外,它也提供了多种实用工具,其中一些可以更有效地对张量和任意类型进行序列化的工具。 它具有CUDA的对应实现,可以在NVIDIA GPU上进行张量...

    Torch

    torch包含了多维张量的数据结构以及基于其上的多种数学运算。此外,它也提供了多种实用工具,其中一些可以更有效地对张量和任意类型进行序列化的工具。

    它具有CUDA的对应实现,可以在NVIDIA GPU上进行张量运算(计算能力>=3.0)。

    张量 Tensors

    torch.is_tensor(obj)

    判断是否为张量,如果是pytorch张量,则返回True

    • 参数: obj (Object) – 判断对象
    torch.is_storage(obj)

    判断是否为pytorch Storage,如何是,则返回True

    • 参数: input (Object) – 判断对象
    torch.set_default_tensor_type(t)
    torch.numel(input)->int

    返回input 张量中的元素个数

    • 参数: input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1,2,3,4,5)
    >>> torch.numel(a)
    120
    >>> a = torch.zeros(4,4)
    >>> torch.numel(a)
    16
    torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)

    设置打印选项。 完全参考自 Numpy

    参数:

    • precision – 浮点数输出的精度位数 (默认为8 )
    • threshold – 阈值,触发汇总显示而不是完全显示(repr)的数组元素的总数 (默认为1000)
    • edgeitems – 每个维度的开头和结尾的摘要中的数组项目数(默认为3)。
    • linewidth – 用于插入行间隔的每行字符数(默认为80)。阈值矩阵将忽略此参数。
    • profile – pretty打印的完全默认值。 可以覆盖上述所有选项 (默认为short, full)

    创建操作 Creation Ops

    torch.eye(n, m=None, out=None)

    返回一个2维张量,对角线数字为1,其它位置为0

    参数:

    • n (int) – 行数
    • m (int, 可选) – 列数.如果为None,则默认为n
    • out (Tensor,可选) - 输出张量

    返回值: 2维张量,对角线为1,其它为0

    返回类型: Tensor

    例子:

    >>> torch.eye(3)
     1  0  0
     0  1  0
     0  0  1
    [torch.FloatTensor of size 3x3]
    torch.from_numpy(ndarray) → Tensor

    numpy.ndarray转换为Tensor。 返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能调整大小。

    例子:

    >>> a = numpy.array([1, 2, 3])
    >>> t = torch.from_numpy(a)
    >>> t
    torch.LongTensor([1, 2, 3])
    >>> t[0] = -1
    >>> a
    array([-1,  2,  3])
    torch.linspace(start, end, steps=100, out=None) → Tensor

    返回start和end之间长度为steps的一维张量 参数:

    • start (float) – 点集的起始值
    • end (float) – 点集的最终值
    • steps (int) – 在startend间的采样数,即返回多少个数
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> torch.linspace(1.0,10.0,steps=5,out=None)
    
      1.0000
      3.2500
      5.5000
      7.7500
     10.0000
    [torch.FloatTensor of size 5]
    
    >>> torch.linspace(-10, 10, steps=5)
    
    -10
     -5
      0
      5
     10
    [torch.FloatTensor of size 5]
    
    >>> torch.linspace(start=-10, end=10, steps=5)
    
    -10
     -5
      0
      5
     10
    [torch.FloatTensor of size 5]
    torch.logspace(start, end, steps=100, out=None) → Tensor

    返回一个1维张量,包含在区间10^start和10^end上以对数刻度均匀间隔的steps个点。 输出1维张量的长度为steps

    参数:

    • start (float) – 该点集的起始点
    • end (float) – 该点集的最终值
    • steps (int) – 在startend间生成的样本数
    • out (Tensor, 可选) – 结果张量

    例子:

    >>> torch.logspace(start=-10, end=10, steps=5)
    
     1.0000e-10
     1.0000e-05
     1.0000e+00
     1.0000e+05
     1.0000e+10
    [torch.FloatTensor of size 5]
    
    >>> torch.logspace(start=0.1, end=1.0, steps=5)
    
      1.2589
      2.1135
      3.5481
      5.9566
     10.0000
    [torch.FloatTensor of size 5]
    torch.ones(*sizes, out=None) → Tensor

    返回一个全为1的张量,形状由可变参数sizes定义。

    参数:

    • sizes (int...) – 整数序列,定义了输出形状,如:(5,5),(2)
    • out (Tensor, 可选) – 结果张量

    例子:

    >>> torch.ones(2, 3)
    
     1  1  1
     1  1  1
    [torch.FloatTensor of size 2x3]
    
    >>> torch.ones(5)
    
     1
     1
     1
     1
     1
    [torch.FloatTensor of size 5]
    torch.rand(*sizes, out=None) → Tensor

    返回一个张量,填充在[0,1]区间的一组均匀分布随机数。 Tensor的形状由变量sizes定义。

    参数:

    • sizes (int...) – 整数序列,定义了输出形状
    • out (Tensor, 可选) - 结果张量

    例子:

    >>> torch.rand(4)
    
     0.9193
     0.3347
     0.3232
     0.7715
    [torch.FloatTensor of size 4]
    
    >>> torch.rand(2, 3,out=None)
    
     0.5010  0.5140  0.0719
     0.1435  0.5636  0.0538
    [torch.FloatTensor of size 2x3]
    torch.randn(*sizes, out=None) → Tensor

    返回一个张量,包含了从正态分布(均值为0,方差为 1,即高斯白噪声)中抽取一组随机数。 Tensor的形状由变量sizes定义。

    参数:

    • sizes (int...) – 整数序列,定义了输出形状
    • `out (Tensor, 可选) - 结果张量

    例子::

    >>> torch.randn(4)
    
    -0.1145
     0.0094
    -1.1717
     0.9846
    [torch.FloatTensor of size 4]
    
    >>> torch.randn(2, 3)
    
     1.4339  0.3351 -1.0999
     1.5458 -0.9643 -0.3558
    [torch.FloatTensor of size 2x3]
    torch.randperm(n, out=None) → LongTensor

    输入参数n,返回一个从0n -1的随机整数排列。

    参数:

    • n(int) – 上限(独占),即最大值

    例子:

    >>> torch.randperm(4)
    
     2
     1
     3
     0
    [torch.LongTensor of size 4]
    torch.arange(start, end, step=1, out=None) → Tensor

    返回一个1维张量,长度为floor((end−start)/step),floor代表向下取整。包含从startend,以step为步长的一组序列值(默认步长为1)。

    参数:

    • start (float) – 该点集的起始点
    • end (float) – 该点集的终止点
    • step (float) – 相邻点的间隔大小
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> torch.arange(1, 4)
    
     1
     2
     3
    [torch.FloatTensor of size 3]
    
    >>> torch.arange(1, 2.5, 0.5)
    
     1.0000
     1.5000
     2.0000
    [torch.FloatTensor of size 3]
    torch.range(start, end, step=1, out=None) → Tensor

    返回一个1维张量,长度为floor((end−start)/step)+1,其中floor代表向下取整数。从start开始,end为结尾,以step为步长的一组值。 step 是两个值之间的间隔,即 Xi+1=Xi+step

    参数:

    • start (float) – 该点集的起始点
    • end (float) – 该点集的最终值
    • step (int) – 相邻点之间的间隔大小
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> torch.range(1, 4)
    
     1
     2
     3
     4
    [torch.FloatTensor of size 4]
    
    >>> torch.range(1, 4, 0.5)
    
     1.0000
     1.5000
     2.0000
     2.5000
     3.0000
     3.5000
     4.0000
    [torch.FloatTensor of size 7]
    torch.zeros(*sizes, out=None) → Tensor

    返回一个全0的张量,形状由可变参数sizes定义。

    参数:

    • sizes (int...) – 整数序列,定义了输出形状
    • out (Tensor, 可选) – 结果张量

    例子:

    >>> torch.zeros(2, 3)
    
     0  0  0
     0  0  0
    [torch.FloatTensor of size 2x3]
    
    >>> torch.zeros(5)
    
     0
     0
     0
     0
     0
    [torch.FloatTensor of size 5]

    索引,切片,连接,变异操作

    torch.cat(seq, dim=0, out=None) → Tensor

    在给定维度上对输入的张量序列seq 进行连接操作。

    torch.cat()可以看做 torch.split()torch.chunk()的逆运算。

    cat()函数可以通过下面例子很好的的理解。

    参数:

    • seq(Tensors的序列) - 可以是相同类型的Tensor的任何python序列。
    • dim(int,可选) - 张量连接的尺寸
    • out(Tensor,可选) - 输出参数

      例子:

      
      >>> x = torch.randn(2, 3)
      >>> x
      
      0.5983 -0.0341  2.4918
      1.5981 -0.5265 -0.8735
      [torch.FloatTensor of size 2x3]

    torch.cat((x, x, x), 0)

    0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 [torch.FloatTensor of size 6x3]

    torch.cat((x, x, x), 1)

    0.5983 -0.0341 2.4918 0.5983 -0.0341 2.4918 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 1.5981 -0.5265 -0.8735 1.5981 -0.5265 -0.8735 [torch.FloatTensor of size 2x9]

    
    ```python
    torch.chunk(tensor, chunks, dim=0)

    将张量沿着给定维度分解成的多个块。

    参数:

    • tensor (Tensor) – 待分块的输入张量
    • chunks (int) – 分块的个数
    • dim (int) – 沿着此维度进行分块
    torch.gather(input, dim, index, out=None) → Tensor

    沿给定轴dim,将输入索引张量index指定位置的值进行聚合。

    对一个3维张量,输出可以定义为:

    out[i][j][k] = tensor[index[i][j][k]][j][k]  # dim=0
    out[i][j][k] = tensor[i][index[i][j][k]][k]  # dim=1
    out[i][j][k] = tensor[i][j][index[i][j][k]]  # dim=3

    如果输入是一个n维张量((x0,x1...,xi−1,xi,xi+1,...,xn−1)和暗=我,然后指数必须是一个n维张量的大小(x0,x1,...,xi−1,y,xi+1,...,xn−1)其中y > = 1和有同样大小的指标。

    参数:

    • input(Tensor) - 源张量
    • dim(int) - 要索引的轴
    • index(LongTensor) - 要收集的元素的索引
    • out(Tensor,可选) - 目的张量

    例子:

    >>> t = torch.Tensor([[1,2],[3,4]])
    >>> torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]]))
     1  1
     4  3
    [torch.FloatTensor of size 2x2]
    torch.index_select(input, dim, index, out=None) → Tensor

    返回一个新的张量,其索引input 张量沿尺寸 dim使用的条目中index这是一个LongTensor。

    返回的Tensor具有与原始Tensor相同数量的尺寸。

    注意: 返回的张量不与原始张量共享内存空间。

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 索引的轴
    • index (LongTensor) – 包含索引下标的一维张量
    • out (Tensor, 可选的) – 目标张量

    例子:

    >>> x = torch.randn(3, 4)
    >>> x
    
     1.2045  2.4084  0.4001  1.1372
     0.5596  1.5677  0.6219 -0.7954
     1.3635 -1.2313 -0.5414 -1.8478
    [torch.FloatTensor of size 3x4]
    
    >>> indices = torch.LongTensor([0, 2])
    >>> torch.index_select(x, 0, indices)
    
     1.2045  2.4084  0.4001  1.1372
     1.3635 -1.2313 -0.5414 -1.8478
    [torch.FloatTensor of size 2x4]
    
    >>> torch.index_select(x, 1, indices)
    
     1.2045  0.4001
     0.5596  0.6219
     1.3635 -0.5414
    [torch.FloatTensor of size 3x2]

    torch.masked_select(input, mask, out=None) → Tensor

    根据掩码张量mask中的二元值,取输入张量中的指定项( mask为一个 ByteTensor),将取值返回到一个新的1D张量,

    张量 mask须跟input张量有相同数量的元素数目,但形状或维度不需要相同。 注意: 返回的张量不与原始张量共享内存空间。

    参数:

    • input (Tensor) – 输入张量
    • mask (ByteTensor) – 掩码张量,包含了二元索引值
    • out (Tensor, 可选的) – 目标张量

    例子:

    >>> x = torch.randn(3, 4)
    >>> x
    
     1.2045  2.4084  0.4001  1.1372
     0.5596  1.5677  0.6219 -0.7954
     1.3635 -1.2313 -0.5414 -1.8478
    [torch.FloatTensor of size 3x4]
    
    >>> indices = torch.LongTensor([0, 2])
    >>> torch.index_select(x, 0, indices)
    
     1.2045  2.4084  0.4001  1.1372
     1.3635 -1.2313 -0.5414 -1.8478
    [torch.FloatTensor of size 2x4]
    
    >>> torch.index_select(x, 1, indices)
    
     1.2045  0.4001
     0.5596  0.6219
     1.3635 -0.5414
    [torch.FloatTensor of size 3x2]

    torch.nonzero

    torch.nonzero(input, out=None) → LongTensor

    返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。

    如果输入inputn维,则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。

    参数:

    • input (Tensor) – 源张量
    • out (LongTensor, 可选的) – 包含索引值的结果张量

    例子:

    >>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))
    
     0
     1
     2
     4
    [torch.LongTensor of size 4x1]
    
    >>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
    ...                             [0.0, 0.4, 0.0, 0.0],
    ...                             [0.0, 0.0, 1.2, 0.0],
    ...                             [0.0, 0.0, 0.0,-0.4]]))
    
     0  0
     1  1
     2  2
     3  3
    [torch.LongTensor of size 4x2]

    torch.split

    torch.split(tensor, split_size, dim=0)

    将输入张量分割成相等形状的chunks(如果可分)。 如果沿指定维的张量形状大小不能被split_size 整分, 则最后一个分块会小于其它分块。

    参数:

    • tensor (Tensor) – 待分割张量
    • split_size (int) – 单个分块的形状大小
    • dim (int) – 沿着此维进行分割

    torch.squeeze

    torch.squeeze(input, dim=None, out=None)

    将输入张量形状中的1 去除并返回。 如果输入是形如\((A \times 1\times B \times 1 \times C \times 1 \times D) \),那么输出形状就为: \((A \times B \times C \times D) \)

    当给定dim时,那么挤压操作只在给定维度上。例如,输入形状为: \((A \times 1 \times B) \), squeeze(input, 0) 将会保持张量不变,只有用 squeeze(input, 1),形状会变成 \( (A \times B )\)。

    注意: 返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个。

    参数:

    • input (Tensor) – 输入张量
    • dim (int, 可选的) – 如果给定,则input只会在给定维度挤压
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> x = torch.zeros(2,1,2,1,2)
    >>> x.size()
    (2L, 1L, 2L, 1L, 2L)
    >>> y = torch.squeeze(x)
    >>> y.size()
    (2L, 2L, 2L)
    >>> y = torch.squeeze(x, 0)
    >>> y.size()
    (2L, 1L, 2L, 1L, 2L)
    >>> y = torch.squeeze(x, 1)
    >>> y.size()
    (2L, 2L, 1L, 2L)

    torch.stack[source]

    torch.stack(sequence, dim=0)

    沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。

    参数:

    • sqequence (Sequence) – 待连接的张量序列
    • dim (int) – 插入的维度。必须介于 0 与 待连接的张量序列数之间。

    torch.t

    torch.t(input, out=None) → Tensor

    输入一个矩阵(2维张量),并转置0, 1维。 可以被视为函数transpose(input, 0, 1)的简写函数。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 结果张量

      
      >>> x = torch.randn(2, 3)
      >>> x
      
      0.4834  0.6907  1.3417
      -0.1300  0.5295  0.2321
      [torch.FloatTensor of size 2x3]

    torch.t(x)

    0.4834 -0.1300 0.6907 0.5295 1.3417 0.2321 [torch.FloatTensor of size 3x2]

    
    ### torch.transpose
    ```python
    torch.transpose(input, dim0, dim1, out=None) → Tensor

    返回输入矩阵input的转置。交换维度dim0dim1。 输出张量与输入张量共享内存,所以改变其中一个会导致另外一个也被修改。

    参数:

    • input (Tensor) – 输入张量
    • dim0 (int) – 转置的第一维
    • dim1 (int) – 转置的第二维
    >>> x = torch.randn(2, 3)
    >>> x
    
     0.5983 -0.0341  2.4918
     1.5981 -0.5265 -0.8735
    [torch.FloatTensor of size 2x3]
    
    >>> torch.transpose(x, 0, 1)
    
     0.5983  1.5981
    -0.0341 -0.5265
     2.4918 -0.8735
    [torch.FloatTensor of size 3x2]

    torch.unbind

    torch.unbind(tensor, dim=0)[source]

    移除指定维后,返回一个元组,包含了沿着指定维切片后的各个切片

    参数:

    • tensor (Tensor) – 输入张量
    • dim (int) – 删除的维度

    torch.unsqueeze

    torch.unsqueeze(input, dim, out=None)

    返回一个新的张量,对输入的制定位置插入维度 1

    注意: 返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个。

    如果dim为负,则将会被转化\( dim+input.dim()+1 \)

    参数:

    • tensor (Tensor) – 输入张量
    • dim (int) – 插入维度的索引
    • out (Tensor, 可选的) – 结果张量
    >>> x = torch.Tensor([1, 2, 3, 4])
    >>> torch.unsqueeze(x, 0)
     1  2  3  4
    [torch.FloatTensor of size 1x4]
    >>> torch.unsqueeze(x, 1)
     1
     2
     3
     4
    [torch.FloatTensor of size 4x1]

    随机抽样 Random sampling

    torch.manual_seed

    torch.manual_seed(seed)

    设定生成随机数的种子,并返回一个 _torch.C.Generator 对象.

    参数: seed (int or long) – 种子.

    torch.initial_seed

    torch.initial_seed()

    返回生成随机数的原始种子值(python long)。

    torch.get_rng_state

    torch.get_rng_state()[source]

    返回随机生成器状态(ByteTensor)

    torch.set_rng_state

    torch.set_rng_state(new_state)[source]

    设定随机生成器状态 参数: new_state (torch.ByteTensor) – 期望的状态

    torch.default_generator

    torch.default_generator = <torch._C.Generator object>

    torch.bernoulli

    torch.bernoulli(input, out=None) → Tensor

    从伯努利分布中抽取二元随机数(0 或者 1)。

    输入张量须包含用于抽取上述二元随机值的概率。 因此,输入中的所有值都必须在[0,1]区间,即 \( 0<=input_i<=1 \)

    输出张量的第i个元素值, 将会以输入张量的第i个概率值等于1

    返回值将会是与输入相同大小的张量,每个值为0或者1 参数:

    • input (Tensor) – 输入为伯努利分布的概率值
    • out (Tensor, 可选的) – 输出张量(可选)

    例子:

    >>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
    >>> a
    
     0.7544  0.8140  0.9842
     0.5282  0.0595  0.6445
     0.1925  0.9553  0.9732
    [torch.FloatTensor of size 3x3]
    
    >>> torch.bernoulli(a)
    
     1  1  1
     0  0  1
     0  1  1
    [torch.FloatTensor of size 3x3]
    
    >>> a = torch.ones(3, 3) # probability of drawing "1" is 1
    >>> torch.bernoulli(a)
    
     1  1  1
     1  1  1
     1  1  1
    [torch.FloatTensor of size 3x3]
    
    >>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
    >>> torch.bernoulli(a)
    
     0  0  0
     0  0  0
     0  0  0
    [torch.FloatTensor of size 3x3]

    torch.multinomial

    torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor

    返回一个张量,每行包含从input相应行中定义的多项分布中抽取的num_samples个样本。

    当抽取样本时,依次从左到右排列(第一个样本对应第一列)。

    如果输入input是一个向量,输出out也是一个相同长度num_samples的向量。如果输入input是有 \(m \)行的矩阵,输出out是形如\( m \times n \)的矩阵。

    如果参数replacementTrue, 则样本抽取可以重复。否则,一个样本在每行不能被重复抽取。

    参数num_samples必须小于input长度(即,input的列数,如果是input是一个矩阵)。

    参数:

    • input (Tensor) – 包含概率值的张量
    • num_samples (int) – 抽取的样本数
    • replacement (bool, 可选的) – 布尔值,决定是否能重复抽取
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
    >>> torch.multinomial(weights, 4)
    
     1
     2
     0
     0
    [torch.LongTensor of size 4]
    
    >>> torch.multinomial(weights, 4, replacement=True)
    
     1
     2
     1
     2
    [torch.LongTensor of size 4]

    torch.normal()

    torch.normal(means, std, out=None)

    返回一个张量,包含从给定参数means,std的离散正态分布中抽取随机数。 均值means是一个张量,包含每个输出元素相关的正态分布的均值。 std是一个张量,包含每个输出元素相关的正态分布的标准差。 均值和标准差的形状不须匹配,但每个张量的元素个数须相同。

    参数:

    • means (Tensor) – 均值
    • std (Tensor) – 标准差
    • out (Tensor) – 可选的输出张量
    torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))
    
     1.5104
     1.6955
     2.4895
     4.9185
     4.9895
     6.9155
     7.3683
     8.1836
     8.7164
     9.8916
    [torch.FloatTensor of size 10]
    torch.normal(mean=0.0, std, out=None)

    与上面函数类似,所有抽取的样本共享均值。

    参数:

    • means (Tensor,可选的) – 所有分布均值
    • std (Tensor) – 每个元素的标准差
    • out (Tensor) – 可选的输出张量

    例子:

    >>> torch.normal(mean=0.5, std=torch.arange(1, 6))
    
      0.5723
      0.0871
     -0.3783
     -2.5689
     10.7893
    [torch.FloatTensor of size 5]
    
    torch.normal(means, std=1.0, out=None)

    与上面函数类似,所有抽取的样本共享标准差。

    参数:

    • means (Tensor) – 每个元素的均值
    • std (float, 可选的) – 所有分布的标准差
    • out (Tensor) – 可选的输出张量

    例子:

    >>> torch.normal(means=torch.arange(1, 6))
    
     1.1681
     2.8884
     3.7718
     2.5616
     4.2500
    [torch.FloatTensor of size 5]

    序列化 Serialization

    torch.saves[source]

    torch.save(obj, f, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>, pickle_protocol=2)

    保存一个对象到一个硬盘文件上 参考: Recommended approach for saving a model 参数:

    • obj – 保存对象
    • f - 类文件对象 (返回文件描述符)或一个保存文件名的字符串
    • pickle_module – 用于pickling元数据和对象的模块
    • pickle_protocol – 指定pickle protocal 可以覆盖默认参数

    torch.load[source]

    torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>)

    从磁盘文件中读取一个通过torch.save()保存的对象。 torch.load() 可通过参数map_location 动态地进行内存重映射,使其能从不动设备中读取文件。一般调用时,需两个参数: storage 和 location tag. 返回不同地址中的storage,或着返回None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话,意味着其是从文件的地址标记到当前系统的地址标记的映射。 默认情况下, location tags中 "cpu"对应host tensors,‘cuda:device_id’ (e.g. ‘cuda:2’) 对应cuda tensors。 用户可以通过register_package进行扩展,使用自己定义的标记和反序列化方法。

    参数:

    • f – 类文件对象 (返回文件描述符)或一个保存文件名的字符串
    • map_location – 一个函数或字典规定如何remap存储位置
    • pickle_module – 用于unpickling元数据和对象的模块 (必须匹配序列化文件时的pickle_module )

    例子:

    >>> torch.load('tensors.pt')
    # Load all tensors onto the CPU
    >>> torch.load('tensors.pt', map_location=lambda storage, loc: storage)
    # Map tensors from GPU 1 to GPU 0
    >>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'})

    并行化 Parallelism

    torch.get_num_threads

    torch.get_num_threads() → int

    获得用于并行化CPU操作的OpenMP线程数

    torch.set_num_threads

    torch.set_num_threads(int)

    设定用于并行化CPU操作的OpenMP线程数

    数学操作Math operations

    Pointwise Ops

    torch.abs

    torch.abs(input, out=None) → Tensor

    计算输入张量的每个元素绝对值

    例子:

    >>> torch.abs(torch.FloatTensor([-1, -2, 3]))
    FloatTensor([1, 2, 3])

    torch.acos(input, out=None) → Tensor

    torch.acos(input, out=None) → Tensor

    返回一个新张量,包含输入张量每个元素的反余弦。 参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.acos(a)
     2.2608
     1.2956
     1.1075
        nan
    [torch.FloatTensor of size 4]

    torch.add()

    torch.add(input, value, out=None)

    对输入张量input逐元素加上标量值value,并返回结果到一个新的张量out,即 \( out = tensor + value \)。

    如果输入input是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

    • input (Tensor) – 输入张量
    • value (Number) – 添加到输入每个元素的数
    • out (Tensor, 可选的) – 结果张量
    >>> a = torch.randn(4)
    >>> a
    
     0.4050
    -1.2227
     1.8688
    -0.4185
    [torch.FloatTensor of size 4]
    
    >>> torch.add(a, 20)
    
     20.4050
     18.7773
     21.8688
     19.5815
    [torch.FloatTensor of size 4]
    torch.add(input, value=1, other, out=None)

    other 张量的每个元素乘以一个标量值value,并加到iput 张量上。返回结果到输出张量out。即,\( out=input+(other∗value ) \)

    两个张量 input and other的尺寸不需要匹配,但元素总数必须一样。

    如果other是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 第一个输入张量
    • value (Number) – 用于第二个张量的尺寸因子
    • other (Tensor) – 第二个输入张量
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> import torch
    >>> a = torch.randn(4)
    >>> a
    
    -0.9310
     2.0330
     0.0852
    -0.2941
    [torch.FloatTensor of size 4]
    
    >>> b = torch.randn(2, 2)
    >>> b
    
     1.0663  0.2544
    -0.1513  0.0749
    [torch.FloatTensor of size 2x2]
    
    >>> torch.add(a, 10, b)
     9.7322
     4.5770
    -1.4279
     0.4552
    [torch.FloatTensor of size 4]

    torch.addcdiv

    torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor

    tensor2tensor1逐元素相除,然后乘以标量值value 并加到tensor

    张量的形状不需要匹配,但元素数量必须一致。

    如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

    参数:

    • tensor (Tensor) – 张量,对 tensor1 ./ tensor 进行相加
    • value (Number, 可选的) – 标量,对 tensor1 ./ tensor2 进行相乘
    • tensor1 (Tensor) – 张量,作为被除数(分子)
    • tensor2 (Tensor) –张量,作为除数(分母)
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> t = torch.randn(2, 3)
    >>> t1 = torch.randn(1, 6)
    >>> t2 = torch.randn(6, 1)
    >>> torch.addcdiv(t, 0.1, t1, t2)
    
     0.0122 -0.0188 -0.2354
     0.7396 -1.5721  1.2878
    [torch.FloatTensor of size 2x3]

    torch.addcmul

    torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor

    tensor2tensor1逐元素相乘,并对结果乘以标量值value然后加到tensor。 张量的形状不需要匹配,但元素数量必须一致。 如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

    参数:

    • tensor (Tensor) – 张量,对tensor1 ./ tensor 进行相加
    • value (Number, 可选的) – 标量,对 tensor1 . tensor2 进行相乘
    • tensor1 (Tensor) – 张量,作为乘子1
    • tensor2 (Tensor) –张量,作为乘子2
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> t = torch.randn(2, 3)
    >>> t1 = torch.randn(1, 6)
    >>> t2 = torch.randn(6, 1)
    >>> torch.addcmul(t, 0.1, t1, t2)
    
     0.0122 -0.0188 -0.2354
     0.7396 -1.5721  1.2878
    [torch.FloatTensor of size 2x3]

    torch.asin

    torch.asin(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的反正弦函数

    参数:

    • tensor (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.asin(a)
    -0.6900
     0.2752
     0.4633
        nan
    [torch.FloatTensor of size 4]

    torch.atan

    torch.atan(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的反正切函数

    参数:

    • tensor (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.atan(a)
    -0.5669
     0.2653
     0.4203
     0.9196
    [torch.FloatTensor of size 4]

    torch.atan2

    torch.atan2(input1, input2, out=None) → Tensor

    返回一个新张量,包含两个输入张量input1input2的反正切函数

    参数:

    • input1 (Tensor) – 第一个输入张量
    • input2 (Tensor) – 第二个输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.atan2(a, torch.randn(4))
    -2.4167
     2.9755
     0.9363
     1.6613
    [torch.FloatTensor of size 4]

    torch.ceil

    torch.ceil(input, out=None) → Tensor

    天井函数,对输入input张量每个元素向上取整, 即取不小于每个元素的最小整数,并返回结果到输出。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> torch.ceil(a)
    
     2
     1
    -0
    -0
    [torch.FloatTensor of size 4]

    torch.clamp

    torch.clamp(input, min, max, out=None) → Tensor

    将输入input张量每个元素的夹紧到区间 \([min, max] \),并返回结果到一个新张量。

    操作定义如下:

          | min, if x_i < min
    y_i = | x_i, if min <= x_i <= max
          | max, if x_i > max

    如果输入是FloatTensor or DoubleTensor类型,则参数min max 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 输入张量
    • min (Number) – 限制范围下限
    • max (Number) – 限制范围上限
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> torch.clamp(a, min=-0.5, max=0.5)
    
     0.5000
     0.3912
    -0.5000
    -0.5000
    [torch.FloatTensor of size 4]
    torch.clamp(input, *, min, out=None) → Tensor

    将输入input张量每个元素的限制到不小于min ,并返回结果到一个新张量。

    如果输入是FloatTensor or DoubleTensor类型,则参数 value 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 输入张量
    • value (Number) – 限制范围下限
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> torch.clamp(a, min=0.5)
    
     1.3869
     0.5000
     0.5000
     0.5000
    [torch.FloatTensor of size 4]
    torch.clamp(input, *, max, out=None) → Tensor

    将输入input张量每个元素的限制到不大于max ,并返回结果到一个新张量。

    如果输入是FloatTensor or DoubleTensor类型,则参数 value 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 输入张量
    • value (Number) – 限制范围上限
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> torch.clamp(a, max=0.5)
    
     0.5000
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]

    torch.cos

    torch.cos(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的余弦。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.cos(a)
     0.8041
     0.9633
     0.9018
     0.2557
    [torch.FloatTensor of size 4]

    torch.cosh

    torch.cosh(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的双曲余弦。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.cosh(a)
     1.2095
     1.0372
     1.1015
     1.9917
    [torch.FloatTensor of size 4]

    torch.div()

    torch.div(input, value, out=None)

    input逐元素除以标量值value,并返回结果到输出张量out。 即 \( out=tensor/value \)

    如果输入是FloatTensor or DoubleTensor类型,则参数 value 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 输入张量
    • value (Number) – 除数
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(5)
    >>> a
    
    -0.6147
    -1.1237
    -0.1604
    -0.6853
     0.1063
    [torch.FloatTensor of size 5]
    
    >>> torch.div(a, 0.5)
    
    -1.2294
    -2.2474
    -0.3208
    -1.3706
     0.2126
    [torch.FloatTensor of size 5]
    torch.div(input, other, out=None)

    两张量inputother逐元素相除,并将结果返回到输出。即, \( out_i= input_i / other_i \)

    两张量形状不须匹配,但元素数须一致。

    注意:当形状不匹配时,input的形状作为输出张量的形状。

    参数:

    • input (Tensor) – 张量(分子)
    • other (Tensor) – 张量(分母)
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4,4)
    >>> a
    
    -0.1810  0.4017  0.2863 -0.1013
     0.6183  2.0696  0.9012 -1.5933
     0.5679  0.4743 -0.0117 -0.1266
    -0.1213  0.9629  0.2682  1.5968
    [torch.FloatTensor of size 4x4]
    
    >>> b = torch.randn(8, 2)
    >>> b
    
     0.8774  0.7650
     0.8866  1.4805
    -0.6490  1.1172
     1.4259 -0.8146
     1.4633 -0.1228
     0.4643 -0.6029
     0.3492  1.5270
     1.6103 -0.6291
    [torch.FloatTensor of size 8x2]
    
    >>> torch.div(a, b)
    
    -0.2062  0.5251  0.3229 -0.0684
    -0.9528  1.8525  0.6320  1.9559
     0.3881 -3.8625 -0.0253  0.2099
    -0.3473  0.6306  0.1666 -2.5381
    [torch.FloatTensor of size 4x4]

    torch.exp

    torch.exp(tensor, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的指数。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量
      >>> torch.exp(torch.Tensor([0, math.log(2)]))
      torch.FloatTensor([1, 2])

      torch.floor

    torch.floor(input, out=None) → Tensor

    床函数: 返回一个新张量,包含输入input张量每个元素的floor,即不小于元素的最大整数。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> torch.floor(a)
    
     1
     0
    -1
    -1
    [torch.FloatTensor of size 4]

    torch.fmod

    torch.fmod(input, divisor, out=None) → Tensor

    计算除法余数。 除数与被除数可能同时含有整数和浮点数。此时,余数的正负与被除数相同。

    参数:

    • input (Tensor) – 被除数
    • divisor (Tensor or float) – 除数,一个数或与被除数相同类型的张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
    torch.FloatTensor([-1, -0, -1, 1, 0, 1])
    >>> torch.fmod(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
    torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

    参考: torch.remainder(), 计算逐元素余数, 相当于python 中的 % 操作符。

    torch.frac

    torch.frac(tensor, out=None) → Tensor

    返回每个元素的分数部分。

    例子:

    >>> torch.frac(torch.Tensor([1, 2.5, -3.2])
    torch.FloatTensor([0, 0.5, -0.2])

    torch.lerp

    torch.lerp(start, end, weight, out=None)

    对两个张量以startend做线性插值, 将结果返回到输出张量。

    即,\( out_i=start_i+weight∗(end_i−start_i) \)

    参数:

    • start (Tensor) – 起始点张量
    • end (Tensor) – 终止点张量
    • weight (float) – 插值公式的weight
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> start = torch.arange(1, 5)
    >>> end = torch.Tensor(4).fill_(10)
    >>> start
    
     1
     2
     3
     4
    [torch.FloatTensor of size 4]
    
    >>> end
    
     10
     10
     10
     10
    [torch.FloatTensor of size 4]
    
    >>> torch.lerp(start, end, 0.5)
    
     5.5000
     6.0000
     6.5000
     7.0000
    [torch.FloatTensor of size 4]
    

    torch.log

    torch.log(input, out=None) → Tensor

    计算input 的自然对数

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(5)
    >>> a
    
    -0.4183
     0.3722
    -0.3091
     0.4149
     0.5857
    [torch.FloatTensor of size 5]
    
    >>> torch.log(a)
    
        nan
    -0.9883
        nan
    -0.8797
    -0.5349
    [torch.FloatTensor of size 5]

    torch.log1p

    torch.log1p(input, out=None) → Tensor

    计算 \( input +1 \)的自然对数 \( y_i=log(x_i+1) \)

    注意:对值比较小的输入,此函数比torch.log()更准确。

    如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(5)
    >>> a
    
    -0.4183
     0.3722
    -0.3091
     0.4149
     0.5857
    [torch.FloatTensor of size 5]
    
    >>> torch.log1p(a)
    
    -0.5418
     0.3164
    -0.3697
     0.3471
     0.4611
    [torch.FloatTensor of size 5]

    torch.mul

    torch.mul(input, value, out=None)

    用标量值value乘以输入input的每个元素,并返回一个新的结果张量。 \( out=tensor ∗ value \)

    如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

    参数:

    • input (Tensor) – 输入张量
    • value (Number) – 乘到每个元素的数
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(3)
    >>> a
    
    -0.9374
    -0.5254
    -0.6069
    [torch.FloatTensor of size 3]
    
    >>> torch.mul(a, 100)
    
    -93.7411
    -52.5374
    -60.6908
    [torch.FloatTensor of size 3]
    torch.mul(input, other, out=None)

    两个张量input,other按元素进行相乘,并返回到输出张量。即计算\( out_i=input_i ∗ other_i \)

    两计算张量形状不须匹配,但总元素数须一致。

    参数:

    • input (Tensor) – 第一个相乘张量
    • other (Tensor) – 第二个相乘张量
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4,4)
    >>> a
    
    -0.7280  0.0598 -1.4327 -0.5825
    -0.1427 -0.0690  0.0821 -0.3270
    -0.9241  0.5110  0.4070 -1.1188
    -0.8308  0.7426 -0.6240 -1.1582
    [torch.FloatTensor of size 4x4]
    
    >>> b = torch.randn(2, 8)
    >>> b
    
     0.0430 -1.0775  0.6015  1.1647 -0.6549  0.0308 -0.1670  1.0742
    -1.2593  0.0292 -0.0849  0.4530  1.2404 -0.4659 -0.1840  0.5974
    [torch.FloatTensor of size 2x8]
    
    >>> torch.mul(a, b)
    
    -0.0313 -0.0645 -0.8618 -0.6784
     0.0934 -0.0021 -0.0137 -0.3513
     1.1638  0.0149 -0.0346 -0.5068
    -1.0304 -0.3460  0.1148 -0.6919
    [torch.FloatTensor of size 4x4]

    torch.neg

    torch.neg(input, out=None) → Tensor

    返回一个新张量,包含输入input 张量按元素取负。 即, \( out=−1∗input \)

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(5)
    >>> a
    
    -0.4430
     1.1690
    -0.8836
    -0.4565
     0.2968
    [torch.FloatTensor of size 5]
    
    >>> torch.neg(a)
    
     0.4430
    -1.1690
     0.8836
     0.4565
    -0.2968
    [torch.FloatTensor of size 5]

    torch.pow

    torch.pow(input, exponent, out=None)

    对输入input的按元素求exponent次幂值,并返回结果张量。 幂值exponent 可以为单一 float 数或者与input相同元素数的张量。

    当幂值为标量时,执行操作: $$ out_i=x^{exponent} $$

    当幂值为张量时,执行操作: $$ out_i=x^{exponent_i} $$

    参数:

    • input (Tensor) – 输入张量
    • exponent (float or Tensor) – 幂值
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
    -0.5274
    -0.8232
    -2.1128
     1.7558
    [torch.FloatTensor of size 4]
    
    >>> torch.pow(a, 2)
    
     0.2781
     0.6776
     4.4640
     3.0829
    [torch.FloatTensor of size 4]
    
    >>> exp = torch.arange(1, 5)
    >>> a = torch.arange(1, 5)
    >>> a
    
     1
     2
     3
     4
    [torch.FloatTensor of size 4]
    
    >>> exp
    
     1
     2
     3
     4
    [torch.FloatTensor of size 4]
    
    >>> torch.pow(a, exp)
    
       1
       4
      27
     256
    [torch.FloatTensor of size 4]
    torch.pow(base, input, out=None)

    base 为标量浮点值,input为张量, 返回的输出张量 out 与输入张量相同形状。

    执行操作为: $$ out_i=base^{input_i} $$

    参数:

    • base (float) – 标量值,指数的底
    • input ( Tensor) – 幂值
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> exp = torch.arange(1, 5)
    >>> base = 2
    >>> torch.pow(base, exp)
    
      2
      4
      8
     16
    [torch.FloatTensor of size 4]

    torch.reciprocal

    torch.reciprocal(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的倒数,即 1.0/x。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> torch.reciprocal(a)
    
     0.7210
     2.5565
    -1.1583
    -1.8289
    [torch.FloatTensor of size 4]

    torch.remainder

    torch.remainder(input, divisor, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的除法余数。 除数与被除数可能同时包含整数或浮点数。余数与除数有相同的符号。

    参数:

    • input (Tensor) – 被除数
    • divisor (Tensor or float) – 除数,一个数或者与除数相同大小的张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> torch.remainder(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
    torch.FloatTensor([1, 0, 1, 1, 0, 1])
    >>> torch.remainder(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
    torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

    torch.round

    torch.round(input, out=None) → Tensor

    返回一个新张量,将输入input张量每个元素舍入到最近的整数。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.2290
     1.3409
    -0.5662
    -0.0899
    [torch.FloatTensor of size 4]
    
    >>> torch.round(a)
    
     1
     1
    -1
    -0
    [torch.FloatTensor of size 4]

    torch.rsqrt

    torch.rsqrt(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的平方根倒数。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.2290
     1.3409
    -0.5662
    -0.0899
    [torch.FloatTensor of size 4]
    
    >>> torch.rsqrt(a)
    
     0.9020
     0.8636
        nan
        nan
    [torch.FloatTensor of size 4]

    torch.sigmoid

    torch.sigmoid(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的sigmoid值。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
    -0.4972
     1.3512
     0.1056
    -0.2650
    [torch.FloatTensor of size 4]
    
    >>> torch.sigmoid(a)
    
     0.3782
     0.7943
     0.5264
     0.4341
    [torch.FloatTensor of size 4]

    torch.sign

    torch.sign(input, out=None) → Tensor

    符号函数:返回一个新张量,包含输入input张量每个元素的正负。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.sign(a)
    
    -1
     1
     1
     1
    [torch.FloatTensor of size 4]

    torch.sin

    torch.sin(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的正弦。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.sin(a)
    -0.5944
     0.2684
     0.4322
     0.9667
    [torch.FloatTensor of size 4]

    torch.sinh

    torch.sinh(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的双曲正弦。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.sinh(a)
    -0.6804
     0.2751
     0.4619
     1.7225
    [torch.FloatTensor of size 4]

    torch.sqrt

    torch.sqrt(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的平方根。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.2290
     1.3409
    -0.5662
    -0.0899
    [torch.FloatTensor of size 4]
    
    >>> torch.sqrt(a)
    
     1.1086
     1.1580
        nan
        nan
    [torch.FloatTensor of size 4]

    torch.tan

    torch.tan(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的正切。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.tan(a)
    -0.7392
     0.2786
     0.4792
     3.7801
    [torch.FloatTensor of size 4]

    torch.tanh

    torch.tanh(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的双曲正切。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    -0.6366
     0.2718
     0.4469
     1.3122
    [torch.FloatTensor of size 4]
    
    >>> torch.tanh(a)
    -0.5625
     0.2653
     0.4193
     0.8648
    [torch.FloatTensor of size 4]

    torch.trunc

    torch.trunc(input, out=None) → Tensor

    返回一个新张量,包含输入input张量每个元素的截断值(标量x的截断值是最接近其的整数,其比x更接近零。简而言之,有符号数的小数部分被舍弃)。

    参数:

    • input (Tensor) – 输入张量
    • out (Tensor, 可选的) – 输出张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
    -0.4972
     1.3512
     0.1056
    -0.2650
    [torch.FloatTensor of size 4]
    
    >>> torch.trunc(a)
    
    -0
     1
     0
    -0
    [torch.FloatTensor of size 4]

    Reduction Ops

    torch.cumprod

    torch.cumprod(input, dim, out=None) → Tensor

    返回输入沿指定维度的累积积。例如,如果输入是一个N 元向量,则结果也是一个N 元向量,第i 个输出元素值为\( yi=x1∗x2∗x3∗...∗xi \)

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 累积积操作的维度
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(10)
    >>> a
    
     1.1148
     1.8423
     1.4143
    -0.4403
     1.2859
    -1.2514
    -0.4748
     1.1735
    -1.6332
    -0.4272
    [torch.FloatTensor of size 10]
    
    >>> torch.cumprod(a, dim=0)
    
     1.1148
     2.0537
     2.9045
    -1.2788
    -1.6444
     2.0578
    -0.9770
    -1.1466
     1.8726
    -0.8000
    [torch.FloatTensor of size 10]
    
    >>> a[5] = 0.0
    >>> torch.cumprod(a, dim=0)
    
     1.1148
     2.0537
     2.9045
    -1.2788
    -1.6444
    -0.0000
     0.0000
     0.0000
    -0.0000
     0.0000
    [torch.FloatTensor of size 10]

    torch.cumsum

    torch.cumsum(input, dim, out=None) → Tensor

    返回输入沿指定维度的累积和。例如,如果输入是一个N元向量,则结果也是一个N元向量,第i 个输出元素值为 \( yi=x1+x2+x3+...+xi\)

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 累积和操作的维度
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(10)
    >>> a
    
    -0.6039
    -0.2214
    -0.3705
    -0.0169
     1.3415
    -0.1230
     0.9719
     0.6081
    -0.1286
     1.0947
    [torch.FloatTensor of size 10]
    
    >>> torch.cumsum(a, dim=0)
    
    -0.6039
    -0.8253
    -1.1958
    -1.2127
     0.1288
     0.0058
     0.9777
     1.5858
     1.4572
     2.5519
    [torch.FloatTensor of size 10]

    torch.dist

    torch.dist(input, other, p=2, out=None) → Tensor

    返回 (input - other) 的 p范数 。

    参数:

    • input (Tensor) – 输入张量
    • other (Tensor) – 右侧输入张量
    • p (float, 可选的) – 所计算的范数
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> x = torch.randn(4)
    >>> x
    
     0.2505
    -0.4571
    -0.3733
     0.7807
    [torch.FloatTensor of size 4]
    
    >>> y = torch.randn(4)
    >>> y
    
     0.7782
    -0.5185
     1.4106
    -2.4063
    [torch.FloatTensor of size 4]
    
    >>> torch.dist(x, y, 3.5)
    3.302832063224223
    >>> torch.dist(x, y, 3)
    3.3677282206393286
    >>> torch.dist(x, y, 0)
    inf
    >>> torch.dist(x, y, 1)
    5.560028076171875

    torch.mean

    torch.mean(input) → float

    返回输入张量所有元素的均值。

    参数: input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
    -0.2946 -0.9143  2.1809
    [torch.FloatTensor of size 1x3]
    
    >>> torch.mean(a)
    0.32398951053619385
    torch.mean(input, dim, out=None) → Tensor

    返回输入张量给定维度dim上每行的均值。

    输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – the dimension to reduce
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4, 4)
    >>> a
    
    -1.2738 -0.3058  0.1230 -1.9615
     0.8771 -0.5430 -0.9233  0.9879
     1.4107  0.0317 -0.6823  0.2255
    -1.3854  0.4953 -0.2160  0.2435
    [torch.FloatTensor of size 4x4]
    
    >>> torch.mean(a, 1)
    
    -0.8545
     0.0997
     0.2464
    -0.2157
    [torch.FloatTensor of size 4x1]

    torch.median

    torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

    返回输入张量给定维度每行的中位数,同时返回一个包含中位数的索引的LongTensor

    dim值默认为输入张量的最后一维。 输出形状与输入相同,除了给定维度上为1.

    注意: 这个函数还没有在torch.cuda.Tensor中定义

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 缩减的维度
    • values (Tensor, 可选的) – 结果张量
    • indices (Tensor, 可选的) – 返回的索引结果张量
    >>> a
    
     -0.6891 -0.6662
     0.2697  0.7412
     0.5254 -0.7402
     0.5528 -0.2399
    [torch.FloatTensor of size 4x2]
    
    >>> a = torch.randn(4, 5)
    >>> a
    
     0.4056 -0.3372  1.0973 -2.4884  0.4334
     2.1336  0.3841  0.1404 -0.1821 -0.7646
    -0.2403  1.3975 -2.0068  0.1298  0.0212
    -1.5371 -0.7257 -0.4871 -0.2359 -1.1724
    [torch.FloatTensor of size 4x5]
    
    >>> torch.median(a, 1)
    (
     0.4056
     0.1404
     0.0212
    -0.7257
    [torch.FloatTensor of size 4x1]
    ,
     0
     2
     4
     1
    [torch.LongTensor of size 4x1]
    )

    torch.mode

    torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

    返回给定维dim上,每行的众数值。 同时返回一个LongTensor,包含众数职的索引。dim值默认为输入张量的最后一维。

    输出形状与输入相同,除了给定维度上为1.

    注意: 这个函数还没有在torch.cuda.Tensor中定义

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 缩减的维度
    • values (Tensor, 可选的) – 结果张量
    • indices (Tensor, 可选的) – 返回的索引张量

    例子:

    >>> a
    
     -0.6891 -0.6662
     0.2697  0.7412
     0.5254 -0.7402
     0.5528 -0.2399
    [torch.FloatTensor of size 4x2]
    
    >>> a = torch.randn(4, 5)
    >>> a
    
     0.4056 -0.3372  1.0973 -2.4884  0.4334
     2.1336  0.3841  0.1404 -0.1821 -0.7646
    -0.2403  1.3975 -2.0068  0.1298  0.0212
    -1.5371 -0.7257 -0.4871 -0.2359 -1.1724
    [torch.FloatTensor of size 4x5]
    
    >>> torch.mode(a, 1)
    (
    -2.4884
    -0.7646
    -2.0068
    -1.5371
    [torch.FloatTensor of size 4x1]
    ,
     3
     4
     2
     0
    [torch.LongTensor of size 4x1]
    )

    torch.norm

    torch.norm(input, p=2) → float

    返回输入张量input 的p 范数。

    参数:

    • input (Tensor) – 输入张量
    • p (float,可选的) – 范数计算中的幂指数值

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
    -0.4376 -0.5328  0.9547
    [torch.FloatTensor of size 1x3]
    
    >>> torch.norm(a, 3)
    1.0338925067372466
    torch.norm(input, p, dim, out=None) → Tensor

    返回输入张量给定维dim 上每行的p 范数。 输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量
    • p (float) – 范数计算中的幂指数值
    • dim (int) – 缩减的维度
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4, 2)
    >>> a
    
    -0.6891 -0.6662
     0.2697  0.7412
     0.5254 -0.7402
     0.5528 -0.2399
    [torch.FloatTensor of size 4x2]
    
    >>> torch.norm(a, 2, 1)
    
     0.9585
     0.7888
     0.9077
     0.6026
    [torch.FloatTensor of size 4x1]
    
    >>> torch.norm(a, 0, 1)
    
     2
     2
     2
     2
    [torch.FloatTensor of size 4x1]

    torch.prod

    torch.prod(input) → float

    返回输入张量input 所有元素的积。

    参数:input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
     0.6170  0.3546  0.0253
    [torch.FloatTensor of size 1x3]
    
    >>> torch.prod(a)
    0.005537458061418483
    torch.prod(input, dim, out=None) → Tensor

    返回输入张量给定维度上每行的积。 输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 缩减的维度
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4, 2)
    >>> a
    
     0.1598 -0.6884
    -0.1831 -0.4412
    -0.9925 -0.6244
    -0.2416 -0.8080
    [torch.FloatTensor of size 4x2]
    
    >>> torch.prod(a, 1)
    
    -0.1100
     0.0808
     0.6197
     0.1952
    [torch.FloatTensor of size 4x1]

    torch.std

    torch.std(input) → float

    返回输入张量input 所有元素的标准差。

    参数:- input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
    -1.3063  1.4182 -0.3061
    [torch.FloatTensor of size 1x3]
    
    >>> torch.std(a)
    1.3782334731508061
    torch.std(input, dim, out=None) → Tensor

    返回输入张量给定维度上每行的标准差。 输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 缩减的维度
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4, 4)
    >>> a
    
     0.1889 -2.4856  0.0043  1.8169
    -0.7701 -0.4682 -2.2410  0.4098
     0.1919 -1.1856 -1.0361  0.9085
     0.0173  1.0662  0.2143 -0.5576
    [torch.FloatTensor of size 4x4]
    
    >>> torch.std(a, dim=1)
    
     1.7756
     1.1025
     1.0045
     0.6725
    [torch.FloatTensor of size 4x1]

    torch.sum

    torch.sum(input) → float

    返回输入张量input 所有元素的和。

    输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
     0.6170  0.3546  0.0253
    [torch.FloatTensor of size 1x3]
    
    >>> torch.sum(a)
    0.9969287421554327
    torch.sum(input, dim, out=None) → Tensor

    返回输入张量给定维度上每行的和。 输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 缩减的维度
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4, 4)
    >>> a
    
    -0.4640  0.0609  0.1122  0.4784
    -1.3063  1.6443  0.4714 -0.7396
    -1.3561 -0.1959  1.0609 -1.9855
     2.6833  0.5746 -0.5709 -0.4430
    [torch.FloatTensor of size 4x4]
    
    >>> torch.sum(a, 1)
    
     0.1874
     0.0698
    -2.4767
     2.2440
    [torch.FloatTensor of size 4x1]

    torch.var

    torch.var(input) → float

    返回输入张量所有元素的方差

    输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
    -1.3063  1.4182 -0.3061
    [torch.FloatTensor of size 1x3]
    
    >>> torch.var(a)
    1.899527506513334
    torch.var(input, dim, out=None) → Tensor

    返回输入张量给定维度上每行的方差。 输出形状与输入相同,除了给定维度上为1.

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – the dimension to reduce
    • out (Tensor, 可选的) – 结果张量 例子:
      
      >>> a = torch.randn(4, 4)
      >>> a

    -1.2738 -0.3058 0.1230 -1.9615 0.8771 -0.5430 -0.9233 0.9879 1.4107 0.0317 -0.6823 0.2255 -1.3854 0.4953 -0.2160 0.2435 [torch.FloatTensor of size 4x4]

    torch.var(a, 1)

    0.8859 0.9509 0.7548 0.6949 [torch.FloatTensor of size 4x1]

    
    ## 比较操作 Comparison Ops
    
    ### torch.eq
    ```python 
    torch.eq(input, other, out=None) → Tensor

    比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。

    参数:

    • input (Tensor) – 待比较张量
    • other (Tensor or float) – 比较张量或数
    • out (Tensor, 可选的) – 输出张量,须为 ByteTensor类型 or 与input同类型

    返回值: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(相等为1,不等为0 )

    返回类型: Tensor

    例子:

    >>> torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
    1  0
    0  1
    [torch.ByteTensor of size 2x2]

    torch.equal

    torch.equal(tensor1, tensor2) → bool

    如果两个张量有相同的形状和元素值,则返回True ,否则 False

    例子:

    >>> torch.equal(torch.Tensor([1, 2]), torch.Tensor([1, 2]))
    True

    torch.ge

    torch.ge(input, other, out=None) → Tensor

    逐元素比较inputother,即是否 \( input >= other \)。

    如果两个张量有相同的形状和元素值,则返回True ,否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

    参数:

    • input (Tensor) – 待对比的张量
    • other (Tensor or float) – 对比的张量或float
    • out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

    返回值: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(是否 input >= other )。 返回类型: Tensor

    例子:

    >>> torch.ge(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
     1  1
     0  1
    [torch.ByteTensor of size 2x2]

    torch.gt

    torch.gt(input, other, out=None) → Tensor

    逐元素比较inputother , 即是否\( input > other \) 如果两个张量有相同的形状和元素值,则返回True ,否则 False。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

    参数:

    • input (Tensor) – 要对比的张量
    • other (Tensor or float) – 要对比的张量或float
    • out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

    返回值: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(是否 input >= other )。 返回类型: Tensor

    例子:

    >>> torch.gt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
     0  1
     0  0
    [torch.ByteTensor of size 2x2]

    torch.kthvalue

    torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)

    取输入张量input指定维上第k 个最小值。如果不指定dim,则默认为input的最后一维。

    返回一个元组 (values,indices),其中indices是原始输入张量input中沿dim维的第 k 个最小值下标。

    参数:

    • input (Tensor) – 要对比的张量
    • k (int) – 第 k 个最小值
    • dim (int, 可选的) – 沿着此维进行排序
    • out (tuple, 可选的) – 输出元组 (Tensor, LongTensor) 可选地给定作为 输出 buffers

    例子:

    >>> x = torch.arange(1, 6)
    >>> x
    
     1
     2
     3
     4
     5
    [torch.FloatTensor of size 5]
    
    >>> torch.kthvalue(x, 4)
    (
     4
    [torch.FloatTensor of size 1]
    ,
     3
    [torch.LongTensor of size 1]
    )

    torch.le

    torch.le(input, other, out=None) → Tensor

    逐元素比较inputother , 即是否\( input <= other \) 第二个参数可以为一个数或与第一个参数相同形状和类型的张量

    参数:

    • input (Tensor) – 要对比的张量
    • other (Tensor or float ) – 对比的张量或float
    • out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

    返回值: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(是否 input >= other )。 返回类型: Tensor

    例子:

    >>> torch.le(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
     1  0
     1  1
    [torch.ByteTensor of size 2x2]

    torch.lt

    torch.lt(input, other, out=None) → Tensor

    逐元素比较inputother , 即是否 \( input < other \)

    第二个参数可以为一个数或与第一个参数相同形状和类型的张量

    参数:

    • input (Tensor) – 要对比的张量
    • other (Tensor or float ) – 对比的张量或float
    • out (Tensor, 可选的) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

    input: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(是否 tensor >= other )。 返回类型: Tensor

    例子:

    >>> torch.lt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
     0  0
     1  0
    [torch.ByteTensor of size 2x2]

    torch.max

    torch.max()

    返回输入张量所有元素的最大值。

    参数:

    • input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
     0.4729 -0.2266 -0.2085
    [torch.FloatTensor of size 1x3]
    
    >>> torch.max(a)
    0.4729
    torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

    返回输入张量给定维度上每行的最大值,并同时返回每个最大值的位置索引。

    输出形状中,将dim维设定为1,其它与输入形状保持一致。

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 指定的维度
    • max (Tensor, 可选的) – 结果张量,包含给定维度上的最大值
    • max_indices (LongTensor, 可选的) – 结果张量,包含给定维度上每个最大值的位置索引

    例子:

    >> a = torch.randn(4, 4)
    >> a
    
    0.0692  0.3142  1.2513 -0.5428
    0.9288  0.8552 -0.2073  0.6409
    1.0695 -0.0101 -2.4507 -1.2230
    0.7426 -0.7666  0.4862 -0.6628
    torch.FloatTensor of size 4x4]
    
    >>> torch.max(a, 1)
    (
     1.2513
     0.9288
     1.0695
     0.7426
    [torch.FloatTensor of size 4x1]
    ,
     2
     0
     0
     0
    [torch.LongTensor of size 4x1]
    )
    torch.max(input, other, out=None) → Tensor

    返回输入张量给定维度上每行的最大值,并同时返回每个最大值的位置索引。 即,\( out_i=max(input_i,other_i) \)

    输出形状中,将dim维设定为1,其它与输入形状保持一致。

    参数:

    • input (Tensor) – 输入张量
    • other (Tensor) – 输出张量
    • out (Tensor, 可选的) – 结果张量

    例子:

    >>> a = torch.randn(4)
    >>> a
    
     1.3869
     0.3912
    -0.8634
    -0.5468
    [torch.FloatTensor of size 4]
    
    >>> b = torch.randn(4)
    >>> b
    
     1.0067
    -0.8010
     0.6258
     0.3627
    [torch.FloatTensor of size 4]
    
    >>> torch.max(a, b)
    
     1.3869
     0.3912
     0.6258
     0.3627
    [torch.FloatTensor of size 4]

    torch.min

    torch.min(input) → float

    返回输入张量所有元素的最小值。

    参数: input (Tensor) – 输入张量

    例子:

    >>> a = torch.randn(1, 3)
    >>> a
    
     0.4729 -0.2266 -0.2085
    [torch.FloatTensor of size 1x3]
    
    >>> torch.min(a)
    -0.22663167119026184
    torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)

    返回输入张量给定维度上每行的最小值,并同时返回每个最小值的位置索引。

    输出形状中,将dim维设定为1,其它与输入形状保持一致。

    参数:

    • input (Tensor) – 输入张量
    • dim (int) – 指定的维度
    • min (Tensor, 可选的) – 结果张量,包含给定维度上的最小值
    • min_indices (LongTensor, 可选的) – 结果张量,包含给定维度上每个最小值的位置索引

    例子:

    
    >> a = torch.randn(4, 4)
    >> a
    
    0.0692  0.3142  1.2513 -0.5428
    0.9288  0.8552 -0.2073  0.6409
    1.0695 -0.0101 -2.4507 -1.2230
    0.7426 -0.7666  0.4862 -0.6628
    torch.FloatTensor of size 4x4]
    
    >> torch.min(a, 1)
    
    0.54
    展开全文
  • PyTorch的torch.cat

    万次阅读 多人点赞 2018-06-25 15:55:59
    1. 字面理解:torch.cat是将两个张量(tensor)拼接在一起,cat是concatnate的意思,即拼接,联系在一起。 2. 例子理解 &gt;&gt;&gt; import torch &gt;&gt;&gt; A=torch.ones(2,3) #2x3...

    1. 字面理解:torch.cat是将两个张量(tensor)拼接在一起,cat是concatenate的意思,即拼接,联系在一起。

    2. 例子理解

    >>> import torch
    >>> A=torch.ones(2,3) #2x3的张量(矩阵)                                     
    >>> A
    tensor([[ 1.,  1.,  1.],
            [ 1.,  1.,  1.]])
    >>> B=2*torch.ones(4,3)#4x3的张量(矩阵)                                    
    >>> B
    tensor([[ 2.,  2.,  2.],
            [ 2.,  2.,  2.],
            [ 2.,  2.,  2.],
            [ 2.,  2.,  2.]])
    >>> C=torch.cat((A,B),0)#按维数0(行)拼接
    >>> C
    tensor([[ 1.,  1.,  1.],
             [ 1.,  1.,  1.],
             [ 2.,  2.,  2.],
             [ 2.,  2.,  2.],
             [ 2.,  2.,  2.],
             [ 2.,  2.,  2.]])
    >>> C.size()
    torch.Size([6, 3])
    >>> D=2*torch.ones(2,4) #2x4的张量(矩阵)
    >>> C=torch.cat((A,D),1)#按维数1(列)拼接
    >>> C
    tensor([[ 1.,  1.,  1.,  2.,  2.,  2.,  2.],
            [ 1.,  1.,  1.,  2.,  2.,  2.,  2.]])
    >>> C.size()
    torch.Size([2, 7])
    

    上面给出了两个张量A和B,分别是2行3列,4行3列。即他们都是2维张量。因为只有两维,这样在用torch.cat拼接的时候就有两种拼接方式:按行拼接和按列拼接。即所谓的维数0维数1. 

    C=torch.cat((A,B),0)就表示按维数0(行)拼接A和B,也就是竖着拼接,A上B下。此时需要注意:列数必须一致,即维数1数值要相同,这里都是3列,方能列对齐。拼接后的C的第0维是两个维数0数值和,即2+4=6.

    C=torch.cat((A,B),1)就表示按维数1(列)拼接A和B,也就是横着拼接,A左B右。此时需要注意:行数必须一致,即维数0数值要相同,这里都是2行,方能行对齐。拼接后的C的第1维是两个维数1数值和,即3+4=7.

    从2维例子可以看出,使用torch.cat((A,B),dim)时,除拼接维数dim数值可不同外其余维数数值需相同,方能对齐

    3.实例

    在深度学习处理图像时,常用的有3通道的RGB彩色图像及单通道的灰度图。张量size为cxhxw,即通道数x图像高度x图像宽度。在用torch.cat拼接两张图像时一般要求图像大小一致而通道数可不一致,即h和w同,c可不同。当然实际有3种拼接方式,另两种好像不常见。比如经典网络结构:U-Net

                                        

    里面用到4次torch.cat,其中copy and crop操作就是通过torch.cat来实现的。可以看到通过上采样(up-conv 2x2)将原始图像h和w变为原来2倍,再和左边直接copy过来的同样h,w的图像拼接。这样做,可以有效利用原始结构信息。

    4.总结

    使用torch.cat((A,B),dim)时,除拼接维数dim数值可不同外其余维数数值需相同,方能对齐。

     

     

    展开全文
  • torch.randn和torch.rand有什么区别

    万次阅读 多人点赞 2019-05-04 17:28:28
    torch.rand和torch.randn有什么区别? y = torch.rand(5,3) y=torch.randn(5,3) 一个均匀分布,一个是标准正态分布。 均匀分布 torch.rand(*sizes, out=None)→ Tensor 返回一个张量,包含了从区间[0, 1)的均匀...

    torch.rand和torch.randn有什么区别? y = torch.rand(5,3) y=torch.randn(5,3)

    一个均匀分布,一个是标准正态分布。

    均匀分布

    torch.rand(*sizes, out=None) → Tensor

    返回一个张量,包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。

    参数:

    • sizes (int...) - 整数序列,定义了输出张量的形状
    • out (Tensor, optinal) - 结果张量

    例子:

    torch.rand(2, 3)
    0.0836 0.6151 0.6958
    0.6998 0.2560 0.0139
    [torch.FloatTensor of size 2x3]
     

     

    标准正态分布

    torch.randn(*sizes, out=None) → Tensor

    返回一个张量,包含了从标准正态分布(均值为0,方差为1,即高斯白噪声)中抽取的一组随机数。张量的形状由参数sizes定义。

    参数:

    • sizes (int...) - 整数序列,定义了输出张量的形状
    • out (Tensor, optinal) - 结果张量

    例子:

    torch.randn(2, 3)
    0.5419 0.1594 -0.0413
    -2.7937 0.9534 0.4561
    [torch.FloatTensor of size 2x3]

     其他:

    离散正态分布

    torch.normal(means, std, out=None) → → Tensor

    线性间距向量

    torch.linspace(start, end, steps=100, out=None) → Tensor

    返回一个1维张量,包含在区间start和end上均匀间隔的step个点。

    输出张量的长度由steps决定。

    参考:https://zhuanlan.zhihu.com/p/31231210

     

     

    展开全文
  • torch.Tensor的4种乘法

    万次阅读 多人点赞 2019-02-17 00:14:42
    torch.Tensor有4种常见的乘法:*, torch.mul, torch.mm, torch.matmul. 本文抛砖引玉,简单叙述一下这3种乘法的区别,具体使用还是要参照官方文档。 * a与b做*乘法,原则是如果a与b的size不同,则以某种方式将a或b...

    torch.Tensor的4种乘法

    torch.Tensor有4种常见的乘法:*, torch.mul, torch.mm, torch.matmul. 本文抛砖引玉,简单叙述一下这4种乘法的区别,具体使用还是要参照官方文档

    点乘

    a与b做*乘法,原则是如果a与b的size不同,则以某种方式将a或b进行复制,使得复制后的a和b的size相同,然后再将a和b做element-wise的乘法

    下面以*标量和*一维向量为例展示上述过程。

    * 标量

    Tensor与标量k做*乘法的结果是Tensor的每个元素乘以k(相当于把k复制成与lhs大小相同,元素全为k的Tensor).

    >>> a = torch.ones(3,4)
    >>> a
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> a * 2
    tensor([[2., 2., 2., 2.],
            [2., 2., 2., 2.],
            [2., 2., 2., 2.]])
    

    * 一维向量

    Tensor与行向量做*乘法的结果是每列乘以行向量对应列的值(相当于把行向量的行复制,成为与lhs维度相同的Tensor). 注意此时要求Tensor的列数与行向量的列数相等。

    >>> a = torch.ones(3,4)
    >>> a
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> b = torch.Tensor([1,2,3,4])
    >>> b
    tensor([1., 2., 3., 4.])
    >>> a * b
    tensor([[1., 2., 3., 4.],
            [1., 2., 3., 4.],
            [1., 2., 3., 4.]])
    

    Tensor与列向量做*乘法的结果是每行乘以列向量对应行的值(相当于把列向量的列复制,成为与lhs维度相同的Tensor). 注意此时要求Tensor的行数与列向量的行数相等。

    >>> a = torch.ones(3,4)
    >>> a
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> b = torch.Tensor([1,2,3]).reshape((3,1))
    >>> b
    tensor([[1.],
            [2.],
            [3.]])
    >>> a * b
    tensor([[1., 1., 1., 1.],
            [2., 2., 2., 2.],
            [3., 3., 3., 3.]])
    
    

    * 矩阵

    Arsmart在评论区提醒,增补一个矩阵 * 矩阵的例子,感谢Arsmart的热心评论!
    如果两个二维矩阵A与B做点积A * B,则要求A与B的维度完全相同,即A的行数=B的行数,A的列数=B的列数

    >>> a = torch.tensor([[1, 2], [2, 3]])
    >>> a * a
    tensor([[1, 4],
            [4, 9]])
    

    broadcast

    点积是broadcast的。broadcast是torch的一个概念,简单理解就是在一定的规则下允许高维Tensor和低维Tensor之间的运算。broadcast的概念稍显复杂,在此不做展开,可以参考官方文档关于broadcast的介绍. 在torch.matmul里会有关于broadcast的应用的一个简单的例子。
    这里举一个点积broadcast的例子。在例子中,a是二维Tensor,b是三维Tensor,但是a的维度与b的后两位相同,那么a和b仍然可以做点积,点积结果是一个和b维度一样的三维Tensor,运算规则是:若c = a * b, 则c[i,*,*] = a * b[i, *, *],即沿着b的第0维做二维Tensor点积,或者可以理解为运算前将a沿着b的第0维也进行了expand操作,即a = a.expand(b.size()); a * b

    >>> a = torch.tensor([[1, 2], [2, 3]])
    >>> b = torch.tensor([[[1,2],[2,3]],[[-1,-2],[-2,-3]]])
    >>> a * b
    tensor([[[ 1,  4],
             [ 4,  9]],
    
            [[-1, -4],
             [-4, -9]]])
    >>> b * a
    tensor([[[ 1,  4],
             [ 4,  9]],
    
            [[-1, -4],
             [-4, -9]]])
    

    其实,上面提到的二维Tensor点积标量、二维Tensor点积行向量,都是发生在高维向量和低维向量之间的,也可以看作是broadcast.

    torch.mul

    官方文档关于torch.mul的介绍. 用法与*乘法相同,也是element-wise的乘法,也是支持broadcast的。

    下面是几个torch.mul的例子.

    乘标量

    >>> a = torch.ones(3,4)
    >>> a
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> a * 2
    tensor([[2., 2., 2., 2.],
            [2., 2., 2., 2.],
            [2., 2., 2., 2.]])
    

    乘行向量

    >>> a = torch.ones(3,4)
    >>> a
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> b = torch.Tensor([1,2,3,4])
    >>> b
    tensor([1., 2., 3., 4.])
    >>> torch.mul(a, b)
    tensor([[1., 2., 3., 4.],
            [1., 2., 3., 4.],
            [1., 2., 3., 4.]])
    

    乘列向量

    >>> a = torch.ones(3,4)
    >>> a
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    >>> b = torch.Tensor([1,2,3]).reshape((3,1))
    >>> b
    tensor([[1.],
            [2.],
            [3.]])
    >>> torch.mul(a, b)
    tensor([[1., 1., 1., 1.],
            [2., 2., 2., 2.],
            [3., 3., 3., 3.]])
    

    乘矩阵

    例1:二维矩阵 mul 二维矩阵

    >>> a = torch.tensor([[1, 2], [2, 3]])
    >>> torch.mul(a,a)
    tensor([[1, 4],
            [4, 9]])
    

    例2:二维矩阵 mul 三维矩阵(broadcast)

    >>> a = torch.tensor([[1, 2], [2, 3]])
    >>> b = torch.tensor([[[1,2],[2,3]],[[-1,-2],[-2,-3]]])
    >>> torch.mul(a,b)
    tensor([[[ 1,  4],
             [ 4,  9]],
    
            [[-1, -4],
             [-4, -9]]])
    

    torch.mm

    官方文档关于torch.mm的介绍. 数学里的矩阵乘法,要求两个Tensor的维度满足矩阵乘法的要求.

    例子:

    >>> a = torch.ones(3,4)
    >>> b = torch.ones(4,2)
    >>> torch.mm(a, b)
    tensor([[4., 4.],
            [4., 4.],
            [4., 4.]])
    

    torch.matmul

    官方文档关于torch.matmul的介绍. torch.mm的broadcast版本.

    例子:

    >>> a = torch.ones(3,4)
    >>> b = torch.ones(5,4,2)
    >>> torch.matmul(a, b)
    tensor([[[4., 4.],
             [4., 4.],
             [4., 4.]],
    
            [[4., 4.],
             [4., 4.],
             [4., 4.]],
    
            [[4., 4.],
             [4., 4.],
             [4., 4.]],
    
            [[4., 4.],
             [4., 4.],
             [4., 4.]],
    
            [[4., 4.],
             [4., 4.],
             [4., 4.]]])
    

    同样的a和b,使用torch.mm相乘会报错

    >>> torch.mm(a, b)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    RuntimeError: matrices expected, got 2D, 3D tensors at /pytorch/aten/src/TH/generic/THTensorMath.cpp:2065
    
    展开全文
  • with torch.no_grad() 详解

    万次阅读 多人点赞 2020-04-21 15:14:39
    torch.no_grad() 是一个上下文管理器,被该语句 wrap 起来的部分将不会track 梯度。 例如: a = torch.tensor([1.1], requires_grad=True) b = a * 2 b Out[63]: tensor([2.2000], grad_fn=<MulBackward0>) b...
  • torch.max

    万次阅读 多人点赞 2018-03-31 10:55:46
    torch.max(input) → Tensor 返回输入tensor中所有元素的最大值 a = torch.randn(1, 3) &gt;&gt;0.4729 -0.2266 -0.2085 torch.max(a) &gt;&gt;0.4729     torch.max(input, dim, ...
  • torch.mul、torch.mm、torch.bmm、torch.matmul的区别
  • torch.Tensor和torch.tensor的区别

    万次阅读 多人点赞 2019-06-10 16:34:48
    在Pytorch中,Tensor和tensor都用于... a = torch.Tensor([1, 2]) >>> a tensor([1., 2.]) >>> a=torch.tensor([1,2]) >>> a tensor([1, 2]) 首先我们从根源上来看看torch.Tensor()和to...
  • PyTorch - torch.eq、torch.ne、torch.gt、torch.lt、torch.ge、torch.le flyfish torch.eq、torch.ne、torch.gt、torch.lt、torch.ge、torch.le 以上全是简写 参数是input, other, out=None 逐元素比较input和other...
  • torch-scatter, torch-cluster, torch-sparse 的版本需要与torch版本对应,不然会出现莫名其妙的错误。以下是一个可用的版本配置: torch==1.1.0 torch-scatter==1.3.2 torch-cluster==1.4.5 torch-sparse==...
  • pytorch学习 中 torch.squeeze() 和torch.unsqueeze()的用法

    万次阅读 多人点赞 2018-06-26 20:09:52
    先看torch.squeeze() 这个函数主要对数据的维度进行压缩,去掉维数为1的的维度,比如是一行或者一列这种,一个一行三列(1,3)的数去掉第一个维数为一的维度之后就变成(3)行。squeeze(a)就是将a中所有为1的维度...
  • torch中的几种乘法。torch.mm, torch.mul, torch.matmul

    万次阅读 多人点赞 2019-09-10 10:36:18
    点乘都是broadcast的,可以用torch.mul(a, b)实现,也可以直接用*实现。 >>> a = torch.ones(3,4) >>> a tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]]) >>> b = ...
  • torch.mul 用法 torch.mul(input1, input2, out=None) 功能 1、两个对位相乘,可以广播 举例 torch.mm torch.bmm torch.matmul
  • import torch x=torch.Tensor(2,3)#生成一个2*3的Tensor张量 将Tensor转换为numpy数组 y=x.numpy() 将numpy数组转换为Tensor import numpy as np z=torch.from_numpy(x) torch.ones() torch.ones(*sizes, o...
  • pip install torch安装torch失败

    千次阅读 2020-03-15 23:23:43
    改用官网的:pip install torch=1.4.0 torchvision=0.5.0 -f https://download.pytorch.org/whl/torch_stable.html 链接: https://pytorch.org/.
  • torch.mul() 和 torch.mm() 的区别

    万次阅读 多人点赞 2019-01-04 09:24:11
    torch.mul(a, b)是矩阵a和b对应位相乘,a和b的维度必须相等,比如a的维度是(1, 2),b的维度是(1, 2),返回的仍是(1, 2)的矩阵 torch.mm(a, b)是矩阵a和b矩阵相乘,比如a的维度是(1, 2),b的维度是(2, 3),返回的就是...
  • torch.view,torch.sequeeze,torch.unsequeeze

    千次阅读 2019-03-31 15:39:16
    torch.view(a,b) 将一个多维度的矩阵拼接成a×b torch.squeeze() 用于将矩阵进行压缩, 有0和1两种参数分别表示第一维度和第二维度,torch.sequeeze(0)表示若第一维度的值为1,则去掉。第二维度同理。 若参数...
  • Pytorch中的torch.gather函数的含义

    万次阅读 多人点赞 2018-05-30 20:05:56
    pytorch中的gather函数 pytorch比tensorflow更加编程友好,所以准备用pytorch试着做最近要做的一些实验。 立个flag开始学习pytorch,新开一个分类整理学习pytorch中的一些踩...b = torch.Tensor([[1,2,3],[4,5,6]...
  • torch.rand和torch.randn有什么区别? 一个均匀分布,一个是标准正态分布。 torch.rand() #rand(*size, out=None, dtype=None) t1 = torch.rand(2,3) print(t1,t1.type()) randn(*size, out=None, dtype=None)...
  • torch.ge,torch.gt,torch.le

    千次阅读 2019-01-12 14:56:41
    torch.ge,torch.gt,torch.le torch.ge torch.ge(input, other, out=None) → Tensor 逐元素比较input和other,即是否 input&gt;=otherinput&gt;=other。 如果两个张量有相同的形状和元素值,则返回True ...
  • torch.rand() torch.randn() torch.normal() torch.linespace() 在很长一段时间里我都没有区分这些方法生成的随机数究竟有什么不同,由此在做实验的时候经常会引起一些莫名其妙的麻烦。 所以在此做一个总结,以...
  • 【超简单】torch.narrow()函数

    万次阅读 2020-06-04 17:03:03
    torch.narrow(input,dim,start,length)→ Tensor Returns a new tensor that is anarrowed version ofinputtensor. The dimensiondimis input fromstarttostart+length. The returned tensor andinputtensor share ...
  • torch.randn() 产生大小为指定的,正态分布的采样点,数据类型是tensor torch.mean() torch.mean(input) 输出input 各个元素的的均值,不指定任何参数就是所有元素的算术平均值,指定参数可以计算每一行或者 每一...
  • torch.max和torch.softmax

    千次阅读 2020-03-06 12:50:55
    if __name__ == '__main__': import torch import torch.nn.functional as F input = torch.randn(2, 2) print(input) b = torch.softmax(input, dim=0) # 按列SoftMax,列和为1 print(b) ...
  • torch学习

    2018-06-04 14:46:16
    张量(tensor) ...a = torch.empty(3, 5, dtype=torch.float) numpy和tensor转换 # tensor to numpy a = torch.ones([5, 3], dtype=torch.float) b = a.numpy() # numpy to tensor a = torch.fr...
  • torch.mul(a, b)是矩阵a和b对应位相乘,a和b的维度一般相等,比如a的维度是(1, 2),b的维度是(1, 2),返回的仍是(1, 2)的矩阵 >>> a = torch.rand(1, 2) >>> b = torch.rand(1, 2) >>> ...
  • torch.rand、torch.randn区别

    千次阅读 2020-06-27 12:58:53
    torch.rand() 参考:https://pytorch.org/docs/stable/torch.html#torch.rand *torch.rand(size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor 返回在区间[0,1)[0,1)...
  • torch 数组

    2020-03-08 00:59:07
    从2*1演化而来, 2行1列就是2*1 2*2*1 就是最后维度只有1个数字,这个数字 import torch bb=torch.Tensor([[[1],[2]],[[2],[3]]]) print(bb.shape) exit() ...
  • 2.1 torch.abs 将参数传递到 torch.abs 后返回输入参数的绝对值作为输出,输入参数必须是一个 Tensor 数据类型的变量。 import torch a = torch.randn(2, 3) print a b = torch.abs(a) print b 输出结果: tensor...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,044
精华内容 16,417
关键字:

torch