Tensor与numpy相互转换： torch.ones(),torch.add(),torch.zeros(),torch.squeeze()

目录

 

Tensor与numpy相互转换：

torch.ones(),torch.add(),torch.zeros(),torch.squeeze()

---

Tensor与numpy相互转换：

 
 

   
   

    
    

   
   
   
   

    
    

     
     import torch
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     x=torch.Tensor(
     
     2,
     
     3)
     
     #生成一个4*5的Tensor张量
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     将Tensor转换为numpy数组
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     y=x.numpy()
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     将numpy数组转换为Tensor
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     import numpy 
     
     as np
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     z=torch.from_numpy(x)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   
 
 

torch.ones(),torch.add(),torch.zeros(),torch.squeeze()

torch.ones()

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

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

参数:

 

• sizes (int...) – 整数序列，定义了输出形状
• out (Tensor, optional) – 结果张量 例子:

 
 

   
   

    
    

   
   
   
   

    
    

     
     >>> 
     
     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.add()

 
 

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     注意 :当两个张量形状不匹配时，输入张量的形状会作为输出张量的尺寸。
    
    
   
   
 
 

torch.zeros() 

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

 
 

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

参数:

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

例子：

 
 

   
   

    
    

   
   
   
   

    
    

     
     >>> torch.zeros(
     
     2, 
     
     3)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0  
     
     0  
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0  
     
     0  
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     [
     
     torch.FloatTensor of size 2x3]生成
     
     2*
     
     3的张量矩阵
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     >>> torch.zeros(
     
     5)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     [
     
     torch.FloatTensor of size 5]
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     x=torch.zeros(
     
     2,
     
     3,
     
     4)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     print(x)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     tensor([[[
     
     0., 
     
     0., 
     
     0., 
     
     0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     0., 0., 0., 0.]],
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             [
     
     [0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     0., 0., 0., 0.]]])生成
     
     2个
     
     3*
     
     4的矩阵
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     x=torch.zeros(
     
     2,
     
     3,
     
     4,
     
     5)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     print(x)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     tensor([[[[
     
     0., 
     
     0., 
     
     0., 
     
     0., 
     
     0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.]],
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     [0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.]],
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     [0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.]]],
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             [
     
     [[0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.]],
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     [0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.]],
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
              [
     
     [0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.],
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
               [
     
     0., 0., 0., 0., 0.]]]])
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     从后向前看，最后两位为数组的维度
     
     4*
     
     5，前一位
     
     3表示有
     
     3个
     
     4*
     
     5的矩阵，在前一位
     
     2表示，这样
     
     3个
     
     4*
     
     5的矩阵有
     
     2个，以此类推
    
    
   
   
 
 

torch.squeeze()

 
 

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     参数:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     input (Tensor) – 输入张量
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     dim (int, optional) – 如果给定，则input只会在给定维度挤压
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     out (Tensor, optional) – 输出张量
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     例子：
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

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