CenterLossTest

CenterLossTest

• class torch.nn.PReLU(num_paramenter=1, init=0.25)

  对输入的每一个元素运用函数 $PReLU(x) = max(0,x) + a*min(0, x)$，a是一个可学习参数。当没有声明时，nn.PReLU()在所有的输入中只有一个参数a；如果是nn.PReLU(nChannels)，a将应用到每个输入。

  **注意：**当为了表现更加的模型而学习参数a时不要使用权重衰减

  参数：

  • num_parameters：需要学习的a的个数，默认等于1
  • init：a的初始值，默认等于0.25

  shape：

  • 输入：$(N, )$，代表任意数目附加维度
  • 输出：$(N,*)$，与输入拥有同样的shape属性

• nn.Linear(in_features, out_features, bias=True)

  具体形式为：y = wx + b

  weight = Parameter(torch.Tensor(out_features, in_features))

  bias = Parameter(torch.Tensor(out_features))

  bias如果设置为False，则图层不会学习附加偏差。默认值：True

• self.v = torch.nn.Parameters()

  可以把这个函数理解为类型转换函数，讲一个不可训练的类型Tensor转换成可以训练的类型parameter，并将这个parameter绑定到这个module里面(net.parameter()中就有这个绑定的parameter，所以在参数优化的时候可以进行优化的)，所以经过类型转换这个self.v变成了模型的一部分，成为了模型中根据训练可以改动的参数了。使用这个函数的目的也是想让某些变量在学习的过程中不断的修改其值以达到最优化

• torch.pow()

  这里对应的矩阵乘法只是每一位上的乘法

  例如：

  import torch 
  a = torch.rand(2, 2)
  print(a)
  b = torch.pow(a)
  print(b)
  """
  output：
  tensor([[-0.6702,  0.1811],
          [-0.7064, -0.3418]])
  tensor([[0.4491, 0.0328],
          [0.4990, 0.1168]])
  0.4491 = (-0.6702)*(-0.6702)        
  """

• torch.sum(input, dim, out=None) ---->Tensor

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

  参数：

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

  import torch 
  a = torch.randn(4, 4)
  print(a)
  print(torch.sum(a, 1))
  print(torch.sum(a))
  print(torch.sum(a, dim=1, keepdim=True))
  """
  output:
  tensor([[-0.9850, -0.6207, -0.6559, -0.1220],
          [-1.0619,  0.0158, -1.0086,  0.3370],
          [ 0.5729, -1.7753,  1.2464, -1.6284],
          [-0.3275, -0.5711, -0.6691,  1.2357]])
          
  tensor([-2.3836, -1.7177, -1.5843, -0.3320])	# 变成了行向量
  
  tensor(-6.0177)
  
  tensor([[-2.3836],
          [-1.7177],
          [-1.5843],
          [-0.3320]])	# 仍然保持了列向量
  """

• expand

  扩展某个size为1的维度。如(2, 2, 1)扩展为(2, 2, 3)

  举例：

  import torch 
  x = torch.randn(2, 2, 1)
  print(x)
  y = x.expand(2, 2, 3)
  print(y)
  """
  output:
  tensor([[[ 0.3814],
           [ 1.4493]],
  
          [[-0.0204],
           [-0.9141]]])
       
  tensor([[[ 0.3814,  0.3814,  0.3814],
           [ 1.4493,  1.4493,  1.4493]],
  
          [[-0.0204, -0.0204, -0.0204],
           [-0.9141, -0.9141, -0.9141]]])     
  """

• torch.squeeze()

  将维度为1的压缩掉。如size为(3, 1, 1, 2)，压缩之后为(3, 2)

  举例：

  import torch 
  a = torch.randn(2, 1, 1, 3)
  print(a)
  print(a.squeeze())
  """
  output:
  tensor([[[[ 2.2045,  0.2968,  0.2945]]],
  
  
          [[[ 0.2579,  0.9719, -0.8220]]]])
  tensor([[ 2.2045,  0.2968,  0.2945],
          [ 0.2579,  0.9719, -0.8220]])        
  """

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

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

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

  如果dim为负，则会被转换为dim + input.dim() + 1

  参数：

  • tensor(Tensor)——输入张量
  • dim(int)——插入维度的索引
  • out(Tensor, optional)——结果张量

import torch 
a = torch.randn(1, 2)
print(a)
b = a.unsqueeze(1)
print(b)
print(b.size())
"""
output:
tensor([[-0.2329,  0.0805]])
tensor([[[-0.2329,  0.0805]]])
torch.Size([1, 1, 2])
"""

• t() 转置

• torch.addmm(beta-1, mat, alpha=1, mat1, mat2, out=None) ---->Tensor

  对矩阵mat1和mat2进行矩阵乘操作，矩阵mat加到最终结果。alpha和beta分别是两个矩阵mat1×mat2和mat的比例因子，即$out=(beta * M) + (alpha * mat1 × mat2)$

  对类型为FloatTensor或DoubleTensor的输入，beta和alpha必须为实数，否则两个参数必须为整数

  举例：

  import torch 
  a = torch.randn(2, 2)
  b = torch.randn(2, 3)
  c = torch.randn(3, 2)
  print(a)
  print(b)
  print(c)
  print(a.addmm(1, 2, b, c))
  """
  output:
  tensor([[ 1.2774,  0.2344],
          [-0.2572,  0.0019]])
  tensor([[0.4277, 0.8812, 0.7919],
          [0.5476, 0.2299, 0.9781]])
  tensor([[-1.2772, -0.9458],
          [ 1.6094,  0.7200],
          [ 0.0633,  0.0571]])
  tensor([[ 3.1216,  0.7847],
          [-0.7920, -0.5911]])
  """

• torch.clamp(input, min, max, out=None) --->Tensor

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

  举例：

  import torch 
  a = torch.randint(low=0, high=10, size=(2, 3))
  print(a)
  a = torch.clamp(a, 3, 7)
  print(a)
  """
  output:
  tensor([[1, 1, 4],
          [8, 9, 2]])
  tensor([[3, 3, 4],
          [7, 7, 3]])        
  """

  $y_{i}=\left\{\begin{array}{l}{ min, x_{i} < min} \\ {x_{i}, min \leq x_{i} \leq max} \\ {max, x_{i} > max}\end{array}\right.$

• torch.eq()

  import torch 
  outputs = torch.FloatTensor([[1], [2], [3]])
  targets = torch.FloatTensor([[0], [2], [3]])
  print(targets.eq(outputs.data))	# 比较相等
  print(targets.eq(outputs.data).cpu().sum())	# 统计相等的个数
  """
  output:
  tensor([[False],
          [ True],
          [ True]])
   
  tensor(2)
  """