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数值可不同外其余维数数值需相同,方能对齐。

     

     

    展开全文
  • 深度学习环境配置2——windows下的torch=1.2.0环境配置

    万次阅读 多人点赞 2020-05-10 16:05:23
    神经网络学习小记录48——windows下的torch=1.2.0环境配置学习前言环境内容Anaconda安装下载Cudnn和CUDA配置torch环境安装VSCODE 学习前言 好多人问环境怎么配置,还是出个教程吧。 环境内容 torch:1.2.0 ...

    注意事项

    一、2021/9/11更新

    安装CUDA前需要安装Visual Studio,我安装的版本为Visual Studio 2017,视频与视频中未提及,请小伙伴们注意。

    30系列显卡不适合该教程,30系列显卡仅支持CUDA11.0,可以参考博客https://blog.csdn.net/weixin_44791964/article/details/120668551进行配置。

    博文中显示的安装环境为tensorflow,这是因为我讲pytorch和tensorflow装在一起了,所以不用管,大家自己安装激活的环境是pytorch。

    二、2021/7/8更新

    许多粉丝反馈,报TypeError: array() takes 1 positional argument but 2 were given错误,可以修改pillow版本解决。

    pip install pillow==8.2.0
    

    学习前言

    好多人问环境怎么配置,还是出个教程吧。

    pytorch-cpu版本的环境配置博客为https://blog.csdn.net/weixin_44791964/article/details/120655098
    在这里插入图片描述

    环境内容

    torch:1.2.0
    torchvision:0.4.0

    环境配置

    一、Anaconda安装

    Anaconda的安装主要是为了方便环境管理,可以同时在一个电脑上安装多种环境,不同环境放置不同框架:pytorch、tensorflow、keras可以在不同的环境下安装,只需要使用conda create –n创建新环境即可。

    1、Anaconda的下载

    同学们可以选择安装新版Anaconda和旧版的Anaconda,安装步骤没有什么区别。

    旧版本anaconda的下载:
    新版本的Anaconda没有VSCODE,如果大家为了安装VSCODE方便可以直接安装旧版的Anaconda,百度网盘连接如下。也可以装新版然后分开装VSCODE。
    链接: https://pan.baidu.com/s/12tW0Oad_Tqn7jNs8RNkvFA 提取码: i83n

    新版本anaconda的下载:
    如果想要安装最新的Anaconda,首先登录Anaconda的官网:https://www.anaconda.com/distribution/。直接下载对应安装包就可以。
    在这里插入图片描述
    在这里插入图片描述
    一般是下载64位的,下载完成后打开。

    2、Anaconda的安装

    在这里插入图片描述
    选择安装的位置,可以不安装在C盘。
    在这里插入图片描述
    我选择了Add Anaconda to my PATH environment variable,这样会自动将anaconda装到系统的环境变量中,配置会更加方便一些。
    在这里插入图片描述
    等待安装完之后,Anaconda的安装就结束了。

    二、Cudnn和CUDA的下载和安装

    我这里使用的是torch=1.2.0,官方推荐的Cuda版本是10.0,因此会用到cuda10.0,与cuda10.0对应的cudnn是7.4.1。

    1、Cudnn和CUDA的下载

    网盘下载:
    链接: https://pan.baidu.com/s/1znYSRDtLNFLufAuItOeoyQ
    提取码: 8ggr

    官网下载:
    cuda10.0官网的地址是:
    cuda10.0官网地址
    cudnn官网的地址是:需要大家进去后寻找7.4.1.5。
    cudnn官网地址

    下载完之后得到这两个文件。
    在这里插入图片描述
    在这里插入图片描述

    2、Cudnn和CUDA的安装

    下载好之后可以打开exe文件进行安装。
    在这里插入图片描述
    这里选择自定义。
    不
    然后直接点下一步就行了。
    在这里插入图片描述
    安装完后在C盘这个位置可以找到根目录。
    C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0
    然后大家把Cudnn的内容进行解压。
    在这里插入图片描述
    把这里面的内容直接复制到C盘的根目录下就可以了。
    在这里插入图片描述

    三、配置torch环境

    1、pytorch环境的创建与激活

    Win+R启动cmd,在命令提示符内输入以下命令:

    conda create –n pytorch python=3.6
    
    activate pytorch
    

    这里一共存在两条指令:
    前面一条指令用于创建一个名为pytorch的环境,该环境的python版本为3.6。
    后面一条指令用于激活一个名为pytorch的环境。

    2、pytorch库的安装

    由于我们所有的操作都要在对应环境中进行,所以在进行库的安装前需要先激活环境。

    activate pytorch 
    

    此时cmd窗口的样子为:
    在这里插入图片描述

    a、官方推荐安装方法(推荐)

    打开pytorch的官方安装方法:
    https://pytorch.org/get-started/previous-versions/
    官网推荐的安装代码如下,我使用的是Cuda10的版本,不太懂为什么要写3个=才能正确定位,两个=会定位到cuda92的whl:

    # CUDA 10.0
    pip install torch===1.2.0 torchvision===0.4.0 -f https://download.pytorch.org/whl/torch_stable.html
    

    这是pytorch官方提供的指令,用于安装torch和torchvision。

    b、先下载whl后安装

    需要注意的是,直接这样安装似乎特别慢,因此我们可以进入如下网址:
    https://download.pytorch.org/whl/torch_stable.html
    找到自己需要的轮子下载。下载的时候使用迅雷下载就行了,速度还是比较快的!
    在这里插入图片描述
    在这里插入图片描述
    下载完成后找到安装路径:
    在这里插入图片描述
    在cmd定位过来后利用文件全名进行安装就行了!
    在这里插入图片描述
    这里我也传一个百度网盘的版本。
    链接: https://pan.baidu.com/s/14-QVk7Kb_CVwaVZxVPIgtw
    提取码: rg2e
    全部安装完成之后重启电脑。

    3、其它依赖库的安装

    但如果想要跑深度学习模型,还有一些其它的依赖库需要安装。具体如下:

    scipy==1.2.1
    numpy==1.17.0
    matplotlib==3.1.2
    opencv_python==4.1.2.30
    torch==1.2.0
    torchvision==0.4.0
    tqdm==4.60.0
    Pillow==8.2.0
    h5py==2.10.0
    

    如果想要更便捷的安装可以在桌面或者其它地方创建一个requirements.txt文件,复制上述内容到txt文件中。
    在这里插入图片描述
    使用如下指令安装即可。下述指令中,requirements.txt前方的路径是我将文件放在桌面的路径,各位同学根据自己的电脑修改。

    pip install -r C:\Users\33232\Desktop\requirements.txt
    

    4、安装较慢请注意换源

    需要注意的是,如果在pip中下载安装比较慢可以换个源,可以到用户文件夹下,创建一个pip文件夹,然后在pip文件夹里创建一个txt文件。
    在这里插入图片描述
    修改txt文件的内容,并且把后缀改成ini

    [global]
    index-url = http://pypi.mirrors.ustc.edu.cn/simple
    [install]
    use-mirrors =true
    mirrors =http://pypi.mirrors.ustc.edu.cn/simple/
    trusted-host =pypi.mirrors.ustc.edu.cn
    

    在这里插入图片描述
    在这里插入图片描述
    全部安装完成之后重启电脑。

    四、安装VSCODE

    我个人喜欢VSCODE,所以就安装它啦。其它的编辑软件也可以,个人喜好罢了。

    1、下载安装包安装(推荐)

    最新版本的Anaconda没有VSCODE因此可以直接百度VSCODE进行安装。

    a、VSCODE的下载

    直接加载VSCODE的官网https://code.visualstudio.com/,点击Download for Windows即可下载。
    在这里插入图片描述

    b、VSCODE的安装

    首先同意协议,点一下步。
    在这里插入图片描述
    其他里面的几个勾要打起来,因为这样就可以右键文件夹用VSCODE打开,非常方便。下一步。
    在这里插入图片描述
    继续下一步安装即可。
    在这里插入图片描述

    安装完成后在左下角更改自己的环境就行了。
    在这里插入图片描述

    2、anaconda上安装

    打开anaconda,切换环境。
    在这里插入图片描述
    安装VSCODE,安装完就可以launch一下了,之后就可以把VScode固定到任务栏上,方便打开。
    在这里插入图片描述

    展开全文
  • 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.no_grad() 是一个上下文管理器,被该语句 wrap 起来的部分将不会track 梯度。

    例如:

    a = torch.tensor([1.1], requires_grad=True)
    b = a * 2
    

    打印b可看到其 grad_fn 为 mulbackward 表示是做的乘法。

    b
    Out[63]: tensor([2.2000], grad_fn=<MulBackward0>)
    
    b.add_(2)
    Out[64]: tensor([4.2000], grad_fn=<AddBackward0>)
    

    可以看到不被wrap的情况下,b.grad_fn 为 addbackward 表示这个add 操作被track了

    with torch.no_grad():
        b.mul_(2)
    

    在被包裹的情况下可以看到 b.grad_fn 还是为 add,mul 操作没有被 track. 但是注意,乘法操作是被执行了的。(4.2 -> 8.4)

    b
    Out[66]: tensor([8.4000], grad_fn=<AddBackward0>)
    

    所以如果有不想被track的计算部分可以通过这么一个上下文管理器包裹起来。这样可以执行计算,但该计算不会在反向传播中被记录。

    同时 torch.no_grad() 还可以作为一个装饰器。
    比如在网络测试的函数前加上

    @torch.no_grad()
    def eval():
    	...
    

    扩展:
    同样还可以用 torch.set_grad_enabled()来实现不计算梯度。
    例如:

    def eval():
    	torch.set_grad_enabled(False)
    	...	# your test code
    	torch.set_grad_enabled(True)
    
    展开全文
  • Pytorch错误:Torch not compiled with CUDA enabled

    万次阅读 多人点赞 2020-04-24 12:20:57
      在用Pytorch炼丹的过程中,很意外地碰到了一个错误提示AssertionError: Torch not compiled with CUDA enabled,如下图所示。 错误提示   代码本身可以确定是没有问题的,因为只是在往日已经跑过的代码上加入...
  • list转torch tensor

    万次阅读 2018-09-24 11:50:39
    bbb=torch.tensor(pick, dtype=torch.long) 这种的比较快 img = cv2.imread('d:/bgs.jpg') start=time.time() # tensor = torch.Tensor(img) tensor= torch.from_numpy(img) import torch a...
  • 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.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和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...
  • torch.argmax函数说明

    万次阅读 多人点赞 2019-06-18 19:29:44
    torch.argmax()函数 argmax函数:torch.argmax(input, dim=None, keepdim=False)返回指定维度最大值的序号,dim给定的定义是:the demention to reduce.也就是把dim这个维度的,变成这个维度的最大值的index。 1)...
  • torch.mul、torch.mm、torch.bmm、torch.matmul的区别

    千次阅读 多人点赞 2020-02-05 15:08:42
    torch.mul、torch.mm、torch.bmm、torch.matmul的区别
  • 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==...
  • 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.ones(),torch.add(),torch.zeros(),torch.squeeze()

    万次阅读 多人点赞 2020-01-07 16:38:20
    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...
  • 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中的几种乘法。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 torchvision 下载安装与使用

    万次阅读 2021-03-09 19:53:20
    torch和torchvision版本对应关系表 torch 下载 官方下载地址:https://download.pytorch.org/whl/torch_stable.html 选择对应版本下载即可 torch 安装 安装命令: pip install torch-1.5.1+cpu-cp36-cp36...
  • TORCH MAXIMUM

    2021-02-17 11:17:14
    import torch a = torch.tensor((1, 2, -1)) b = torch.tensor((3, 0, 4)) torch.maximum(a, b) 结果应该是: tensor([3, 2, 4]) AttributeError: module 'torch' has no attribute 'maximum' torch版本:1.6.0...
  • pytorch学习 中 torch.squeeze() 和torch.unsqueeze()的用法

    万次阅读 多人点赞 2018-06-26 20:09:52
    先看torch.squeeze() 这个函数主要对数据的维度进行压缩,去掉维数为1的的维度,比如是一行或者一列这种,一个一行三列(1,3)的数去掉第一个维数为一的维度之后就变成(3)行。squeeze(a)就是将a中所有为1的维度...
  • torch.mul 用法 torch.mul(input1, input2, out=None) 功能 1、两个对位相乘,可以广播 举例 torch.mm torch.bmm torch.matmul
  • torch.bmm() 与 torch.matmul()

    万次阅读 多人点赞 2020-01-07 18:26:57
    torch.bmm() torch.matmul() torch.bmm()强制规定维度和大小相同 torch.matmul()没有强制规定维度和大小,可以用利用广播机制进行不同维度的相乘操作 当进行操作的两个tensor都是3D时,两者等同。 torch.bmm() ...
  • 最近在学一个关于GNN的项目,需要安装torch_scatter,torch-sparse,torch-cluster,torch-spline-conv,torch-geometric。可以说安装这个花费了将近一天的时间,所以将安装的心路记录下来,如果下次再次安装,可以少踩...
  • torch.randn() 产生大小为指定的,正态分布的采样点,数据类型是tensor torch.mean() torch.mean(input) 输出input 各个元素的的均值,不指定任何参数就是所有元素的算术平均值,指定参数可以计算每一行或者 每一...
  • 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 ...
  • torch1.0.0安装

    2018-12-08 17:59:06
    最新torch安装版本1.0.0,适合windows,python3.6,pip,none cuda安装轮子
  • 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.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,则去掉。第二维度同理。 若参数...
  • torch.load()

    万次阅读 2020-06-09 17:20:57
    torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/opt/conda/lib/python3.6/pickle.py'>, **pickle_load_args)[source] 从文件中加载一个用torch.save()保存的对象。 load()使用...
  • torch.from_numpy VS torch.Tensor

    千次阅读 多人点赞 2020-04-08 11:02:52
    torch.from_numpy与torch.Tensor的区别,小朋友(指的是我自己),你是否有很多问号

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,164
精华内容 74,465
关键字:

torch