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：\n',a)
print('維數：',a.shape)
com = np.array([a,b,c])
print('合並矩陣：\n',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 12 2 2 23 3 3 3
[torch.FloatTensor of size 3x4]
- sizes (torch.Size or int…) – 想要擴展的目標維度 eg:
-
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) – 輸出張量
- input (Tensor) – 輸入張量
剩下的函數不是很常用！
-
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：\n',a)
print('維數：',a.shape)
com = np.array([a,b,c])
print('合並矩陣：\n',com)
print('維數：',com.shape)
- 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) - 結果張量
- input (Tensor) - 輸入Tensor
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) -- 維度，沿着此維度進行分塊
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本身