pytorch 的广播机制

Torch,Numpy的Broadcasting Mechanism(广播机制)

Python的pytorch 计算加速方法

以pytorch为例进行介绍

======================================================================

（For more information, please go to Alan D. Chen , upgrading~~）

Anaconda与conda区别
conda可以理解为一个工具，也是一个可执行命令，其核心功能是包管理与环境管理。包管理与pip的使用类似，环境管理则允许用户方便地安装不同版本的python并可以快速切换。
conda的设计理念——conda将几乎所有的工具、第三方包都当做package对待，甚至包括python和conda自身
Anaconda则是一个打包的集合，里面预装好了conda、某个版本的python、众多packages、科学计算工具等等。

git 怎么在仓库里面上传一个文件夹到github?

======================================================================

python是解释性语言

编译器和解释器之间有什么区别:(just
for more details)

根据他们的定义，编译器和解释器之间的区别貌似十分明显：

• 解释器：直接执行用编程语言编写的指令的程序
• 编译器：把源代码转换成（翻译）低级语言的程序

---

在pytorch中，pytorch -- 函数topk()

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

pytorch中文官网文档
沿给定dim维度返回输入张量input中 k
个最大值。如果不指定dim，则默认为input的最后一维。 如果为largest为 False
，则返回最小的 k 个值。
返回一个元组(values,indices)，其中indices是原始输入张量input中测元素下标。
如果设定布尔值sorted 为_True_，将会确保返回的 k 个值被排序。

参数:

• input (Tensor) – 输入张量
• k (int) – “top-k”中的k
• dim (int, optional) – 排序的维
• largest (bool, optional) – 布尔值，控制返回最大或最小值
• sorted (bool, optional) – 布尔值，控制返回值是否排序
• out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffer

---

pytorch 与 numpy 的数组广播机制

numpy 的文档提到数组广播机制为：
When operating on two arrays, NumPy
compares their shapes element-wise. It starts with the trailing
dimensions, and works its way forward. Two dimensions are compatible
when they are equal, or one of them is 1 If these conditions are not
met, a ValueError: frames are not aligned exception is thrown,
indicating that the arrays have incompatible shapes. The size of the
resulting array is the maximum size along each dimension of the input
arrays.

翻译过来就是，从两个数组地末尾开始算起，若轴长相等或者其中一个地维度为1，则认为是广播兼容的，否则是不兼容地。广播兼容的数组会在缺失的维度和长度为1的维度上进行。
广播机制牢记一点就可以了：从末尾开始连续找第一个不想同的维度容量开始扩充，直到扩充成维度相同。
例：
图中的第二行：[4, 3]+[1, 3] 末尾3相等， 前移一位， 4 ！=1
则把1扩充为 4 结束。
图中的第三行：[4, 1]+[1, 3] 末尾 1！=3 将1扩充为3，
迁移一位， 4！=1 把1扩充为4 结束。

---

Pytorch Tensor基本数学运算

1.加法运算 示例代码：

import torch
a = torch.rand(3, 4)
b = torch.rand(4)

c1 = a + b
c2 = torch.add(a, b)
print(c1.shape, c2.shape)
print(torch.all(torch.eq(c1, c2)))

输出结果：
torch.Size([3, 4]) torch.Size([3, 4])
tensor(1, dtype=torch.uint8) 减法运算、哈达玛积(element
wise，对应元素相乘)、除法运算、矩阵乘法（（1）二维矩阵相乘；（2）多维矩阵相乘）、幂运算、开方运算、指数与对数运算
、近似值运算（四舍五入） 、裁剪运算（即对Tensor中的元素进行范围过滤，不符合条件的可以把它变换到范围内部（边界）上，常用于梯度裁剪（gradient clipping），即在发生梯度离散或者梯度爆炸时对梯度的处理，实际使用时可以查看梯度的（L2范数）模来看看需不需要做处理：w.grad.norm(2)。）等等~~

参考链接：https://blog.csdn.net/sinat_33761963/article/details/84502938

========================================================================

Python中reshape的用法及多个二维数组合并为三维数组的方法

这里是numpy中的用法：

import numpy as np

a = np.array([[1,2,3],[4,5,6]])

b = np.array([[2,2,3],[4,5,6]])

c = np.array([[3,2,3],[4,5,6]])

print('矩阵a： ',a)

print('维数：',a.shape)

com = np.array([a,b,c])

print('合并矩阵： ',com)

print('维数：',com.shape)

输出结果为：

矩阵a：

[[1 2 3]

[4 5 6]]

维数： (2, 3)

合并矩阵：

[[[1 2 3]

[4 5 6]]

[[2 2 3]

[4 5 6]]

[[3 2 3]

[4 5 6]]]

维数： (3, 2, 3)

---

【学习笔记】pytorch中squeeze()和unsqueeze()函数介绍

• tensor.unsqueeze() 维度扩张-维度增加
• tensor.squeeze() 维度压缩-维度压缩

---

pytorch张量维度操作（拼接、维度扩展、压缩、转置、重复……）

• tensor截取：
  
  x[:, 2:4]

• torch.cat() 拼接张量
  torch.cat(seq, dim=0, out=None) → Tensor
  在指定的维度dim上对序列seq进行连接操作。
  参数：

  • seq (sequence of Tensors) - Python序列或相同类型的张量序列
  • dim (int, optional) - 沿着此维度连接张量
  • out (Tensor, optional) - 输出参数

• torch.Tensor.expand() 扩大张量
  
  返回张量的一个新视图，可以将张量的单个维度扩大为更大的尺寸。
  张量也可以扩大为更高维，新增加的维度将附在前面。
  扩大张量不需要分配新内存，仅仅是新建一个张量的视图。任意一个一维张量在不分配新内存情况下都可以扩展为任意的维度。
  传入-1则意味着维度扩大不涉及这个维度。
  参数：
  

  • sizes (torch.Size or int…) – 想要扩展的目标维度 eg:
    x = torch.Tensor([[1], [2], [3]])
x.size()
torch.Size([3, 1])
x.expand(3, 4)
1 1 1 1
2 2 2 2
3 3 3 3
[torch.FloatTensor of size 3x4]

• torch.squeeze() 压缩张量
  torch.squeeze(input, dim=None, out=None)
  → Tensor
  除去输入张量input中数值为1的维度，并返回新的张量。如果输入张量的形状为（A×1×B×C×1×D），那么输出张量的形状为
  （A×B×C×D）。
  当通过dim参数指定维度时，维度压缩操作只会在指定的维度上进行。如果输入向量的形状为（A×1×B），squeeze(input,
  0)会保持张量的维度不变，只有在执行 squeeze(input,
  1)时，输入张量的形状会被压缩至（A×B）。
  如果一个张量只有1个维度，那么它不会受到上述方法的影响。
  输出的张量与原张量共享内存，如果改变其中的一个，另一个也会改变。
  
  参数:
  

  • input (Tensor) – 输入张量
    
  • dim (int, optional) – 如果给定，则只会在给定维度压缩
    
  • out (Tensor, optional) – 输出张量

剩下的函数不是很常用！

• torch.Tensor.repeat() 重复张量

• torch.Tensor.narrow() 缩小张量

• torch.Tensor.view() 张量变形

• torch.Tensor.resize_() 重设张量尺寸

• torch.Tensor.permute() 置换张量维度

• torch.Tensor.element_size() → int 查看张量单个元素的字节数

---

python将两个二维array叠加成三维array的实现方法

这里的都是numpy 中的 array的用法，应该不能用在pytorch上~

重点是这个函数：np.array()

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
b = np.array([[2,2,3],[4,5,6]])
c = np.array([[3,2,3],[4,5,6]])
print('矩阵a： ',a)

print('维数：',a.shape)

com = np.array([a,b,c])
print('合并矩阵： ',com)

print('维数：',com.shape)

三阶张量的torch.min()和torch.max()

• torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)
  
  
  返回新的张量，其中包括输入张量input中指定维度dim中每行的最小值，同时返回每个最小值的位置索引。
  若keepdim值为True，则在输出张量中，除了被操作的dim维度值降为1，其它维度与输入张量input相同。否则，dim维度相当于被执行torch.squeeze()维度压缩操作，导致此维度消失，最终输出张量会比输入张量少一个维度。
  
  参数：
  
  • input (Tensor) - 输入Tensor
    
  • dim (int) - 指定维度
    
  • keepdim (bool) - 输出张量是否保持与输入张量有相同数量的维度
    
  • out (tuple,optional) - 结果张量

import torch

import numpy as np

a = [[[2,2,4,5],[1,4,3,8],[7,9,5,8]],

 [[3,4,5,6],[3,5,3,6],[5,7,9,10]],

 [[3,4,1,5],[5,7,4,5],[6,6,6,4]]]

a=np.array(a) # list -> numpy

a=torch.from_numpy(a) # numpy -> tensor

print("a:{}".format(a))

print("a.size:{}".format(a.size()))

b = torch.min(a,1)

c = torch.min(a,1,keepdim=True)

d = torch.min(a,0)

e = torch.min(a,2)

print("torch.min(a,1):{}".format(b))

print("b.values.size:{}".format(b[0].size()))

print("c.values.size:{}".format(c[0].size()))

print("torch.min(a,0):{}".format(d))

print("torch.min(a,2):{}".format(e))

运行结果：

a:tensor([[[ 2, 2, 4, 5],

     [ 1,  4,  3,  8],

     [ 7,  9,  5,  8]],



    [[ 3,  4,  5,  6],

     [ 3,  5,  3,  6],

     [ 5,  7,  9, 10]],



    [[ 3,  4,  1,  5],

     [ 5,  7,  4,  5],

     [ 6,  6,  6,  4]]])

a.size:torch.Size([3, 3, 4])

torch.min(a,1):torch.return_types.min(

values=tensor([[1, 2, 3, 5],

    [3, 4, 3, 6],

    [3, 4, 1, 4]]),

indices=tensor([[1, 0, 1, 0],

    [1, 0, 1, 1],

    [0, 0, 0, 2]]))

b.values.size:torch.Size([3, 4])

c.values.size:torch.Size([3, 1, 4])

torch.min(a,0):torch.return_types.min(

values=tensor([[2, 2, 1, 5],

    [1, 4, 3, 5],

    [5, 6, 5, 4]]),

indices=tensor([[0, 0, 2, 2],

    [0, 0, 1, 2],

    [1, 2, 0, 2]]))

torch.min(a,2):torch.return_types.min(

values=tensor([[2, 1, 5],

    [3, 3, 5],

    [1, 4, 4]]),

indices=tensor([[1, 0, 2],

    [0, 2, 0],

    [2, 2, 3]]))

后面还有很多内容，需要看！

---

pytorch torch.chunk(tensor, chunks, dim)

• torch.chunk(tensor, chunks, dim)
  
  说明：在给定的维度上讲张量进行分块。
  参数：
  • tensor(Tensor) -- 待分块的输入张量
  • chunks(int) -- 分块的个数
  • dim(int) -- 维度，沿着此维度进行分块

---

Numpy与Pytorch 矩阵操作

Pytorch
随机矩阵： torch.randn(d0, d1, d2, ...)
添加维度：
tensor.unsqueeze(0)
压缩维度: tensor.squeeze(0)
按维度拼接tensor：
torch.cat(inputs, dim=0, ...)
维度堆叠： torch.stack(inputs, dim=0)

张量排序索引： tensor.sort(descending=True)
返回一个tensor为排序后的tensor， 一个为index_tensor
矩阵元素夹逼：
tensor.clamp()
矩阵切割: torch.chunk(tensor, chunks, dim)
矩阵复制:
torch.repeat(*size)
生成零矩阵： torch.torch.zeros(5, 3,
dtype=torch.long)
生产同形状的随机矩阵:x = torch.randn_like(x,
dtype=torch.float)

矩阵中函数名以’’结尾的，如:y.add(x)，运算结束后会改变y本身