目录
【pytorch】torch.normal() 离散正态分布
【pytorch】torch.linespace() 线性间距向量
torch.mul
点乘都是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.Tensor([1,2,3]).reshape((3,1))
>>> b
tensor([[1.],
[2.],
[3.]])
>>> torch.mul(a, b)
tensor([[1., 1., 1., 1.],
[2., 2., 2., 2.],
[3., 3., 3., 3.]])
当a, b维度不一致时，会自动填充到相同维度相点乘。
矩阵相乘有torch.mm和torch.matmul两个函数。其中前一个是针对二维矩阵，后一个是高维。当torch.mm用于大于二维时将报错。
torch.mm
>>> a = torch.ones(3,4)
>>> b = torch.ones(4,2)
>>> torch.mm(a, b)
tensor([[4., 4.],
[4., 4.],
[4., 4.]])
torch.matmul
>>> a = torch.ones(3,4)
>>> b = torch.ones(5,4,2)
>>> torch.matmul(a, b).shape
torch.Size([5, 3, 2])
>>> a = torch.ones(5,4,2)
>>> b = torch.ones(5,2,3)
>>> torch.matmul(a, b).shape
torch.Size([5, 4, 3])
>>> a = torch.ones(5,4,2)
>>> b = torch.ones(5,2,3)
>>> torch.matmul(b, a).shape
报错。
【pytorch】torch.rand() 均匀分布
torch.rand(*sizes, out=None) → Tensor返回一个张量，包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。
参数:
- sizes (int…) - 整数序列，定义了输出张量的形状
- out (Tensor, optinal) - 结果张量
import torch
torch.rand(2, 3)
tensor([[0.3423, 0.6812, 0.0086],
[0.1165, 0.3162, 0.0455]])
【pytorch】torch.randn() 标准正态分布
torch.randn(*sizes, out=None) → Tensor返回一个张量，包含了从标准正态分布（均值为0，方差为1，即高斯白噪声）中抽取的一组随机数。张量的形状由参数sizes定义。
参数:
- sizes (int…) - 整数序列，定义了输出张量的形状
- out (Tensor, optinal) - 结果张量
import torch
torch.randn(2, 3)
tensor([[-0.6150, -0.5125, -0.6214],
[-0.2230, -0.1409, 0.3014]])
【pytorch】torch.normal() 离散正态分布
torch.normal(means, std, out=None) → → Tensorv返回一个张量，包含了从指定均值means和标准差std的离散正态分布中抽取的一组随机数。
标准差std是一个张量，包含每个输出元素相关的正态分布标准差。
参数:
- means (float, optional) - 均值
- 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]
【pytorch】torch.linespace() 线性间距向量
torch.linspace(start, end, steps=100, out=None) → Tensor返回一个1维张量，包含在区间start和end上均匀间隔的step个点。
输出张量的长度由steps决定。
参数：
- start (float) - 区间的起始点
- end (float) - 区间的终点
- steps (int) - 在start和end间生成的样本数
- out (Tensor, optional) - 结果张量
import torch
torch.linspace(3, 10, steps=5)
tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])
【pytorch】unsqueeze()
1. 首先初始化一个a
a = torch.arange(0,6)
b = a.view(2,3)
print(b)
tensor([[0, 1, 2],
[3, 4, 5]])可以看出a的维度为（2，3）
2. 在第二维增加一个维度，使其维度变为（2，1，3）
print(b.unsqueeze(1))
print(b.unsqueeze(1).size())
tensor([[[0, 1, 2]],
[[3, 4, 5]]])
torch.Size([2, 1, 3])可以看出a的维度已经变为（2，1，3）了，同样如果需要在倒数第二个维度上增加一个维度，那么使用b.unsqueeze(-2)
【pytorch】squeeze()
1. 首先得到一个维度为（1，2，3）的tensor（张量）
c = b.unsqueeze(0)
c
tensor([[[0, 1, 2],
[3, 4, 5]]])由图中可以看出c的维度为（1，2，3）
2.下面使用squeeze()函数将第一维去掉
c.squeeze(-3)
tensor([[0, 1, 2],
[3, 4, 5]])3.另外
c.squeeze(-2)
tensor([[[0, 1, 2],
[3, 4, 5]]])可以看出维度并没有变化，仍然为（1，2，3），这是因为只有维度为1时才会去掉。
c.squeeze(0)
tensor([[0, 1, 2],
[3, 4, 5]])isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法
以下是 isinstance() 方法的语法:
isinstance(object, classinfo)参数
- object -- 实例对象。
- classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True
Trueclass A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns Falsetorch.nn.Parameter()
torch.nn.Parameter是继承自torch.Tensor的子类，其主要作用是作为nn.Module中的可训练参数使用。
它与torch.Tensor的区别就是nn.Parameter会自动被认为是module的可训练参数，即加入到parameter()这个迭代器中去；
而module中非nn.Parameter()的普通tensor是不在parameter中的。
注意到，nn.Parameter的对象的requires_grad属性的默认值是True，即是可被训练的，这与torth.Tensor对象的默认值相反。
在nn.Module类中，pytorch也是使用nn.Parameter来对每一个module的参数进行初始化的。
def pairwise_distances(x, y):
def pairwise_distances(x, y):
'''
Input: x is a Nxd matrix
y is a Mxd matirx
Output: dist is a NxM matrix where dist[i,j] is the square norm between x[i,:] and y[j,:]
i.e. dist[i,j] = ||x[i,:]-y[j,:]||^2
Advantage: Less memory requirement O(M*d + N*d + M*N) instead of O(N*M*d)
Computationally more expensive? Maybe, Not sure.
adapted from: https://discuss.pytorch.org/t/efficient-distance-matrix-computation/9065/2
'''
x_norm = (x ** 2).sum(1).view(-1, 1)
y_norm = (y ** 2).sum(1).view(1, -1)
y_t = torch.transpose(y, 0, 1)
# a^2 + b^2 - 2ab
dist = x_norm + y_norm - 2.0 * torch.mm(x, y_t)
# dist[dist != dist] = 0 # replace nan values with 0
return distassert
def testAssert():
try:
int_var = int(input("please enter a positive number:"))
# 如果输入的数值不大于0，断言失败，抛出异常
assert int_var > 0
except:
print(f"sorry, please enter a positive number")
print(f"what you enter is: {int_var}")
if __name__ == "__main__":
testAssert()
torch.max(input, dim):
output = torch.max(input, dim)
输入
input是softmax函数输出的一个tensordim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值
输出
- 函数会返回两个
tensor，第一个tensor是每行的最大值，softmax的输出中最大的是1，所以第一个tensor是全1的tensor；第二个tensor是每行最大值的索引。
我们通过一个实例可以更容易理解这个函数的用法。
import torch
a = torch.tensor([[1,5,62,54], [2,6,2,6], [2,65,2,6]])
print(a)
tensor([[ 1, 5, 62, 54],
[ 2, 6, 2, 6],
[ 2, 65, 2, 6]])索引每行的最大值：
torch.max(a, 1)输出：
torch.return_types.max(
values=tensor([62, 6, 65]),
indices=tensor([2, 3, 1]))torch.cat()
torch.cat是将两个张量（tensor）拼接在一起，cat是concatnate的意思，即拼接，联系在一起。
- 使用torch.cat((A,B),dim)时，除拼接维数dim数值可不同外其余维数数值需相同，方能对齐。
C = torch.cat( (A,B),0 ) #按维数0拼接（竖着拼）
C = torch.cat( (A,B),1 ) #按维数1拼接（横着拼）
>>> 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])
3120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
