Pytorch基础知识

生成张量x和y

x=torch.tensor([[1,2],[3,4]])
y=torch.tensor([[5,6],[7,8]])

张量加法                                                   

z=x+y#加法
z
tensor([[ 6,  8],
        [10, 12]])

减法

z=x-y#减法
z
tensor([[-4, -4],
        [-4, -4]])

张量中每个数求和                             

z=x.sum()
z
tensor(10)

张量每个数平方

z=x.pow(2)
z
tensor([[ 1,  4],
        [ 9, 16]])

维度增减，squeeze去掉长度为1的维度，unsqueeze增加一个维度，且长度为1

x = torch.zeros([1, 2, 3])
x#1*2*3维张量
tensor([[[0., 0., 0.],
         [0., 0., 0.]]])
x=x.squeeze(dim=0)
x.shape
torch.Size([2, 3])

x=x.unsqueeze(dim=0)
x.shape
torch.Size([1, 2, 3])

张量拼接

#张量拼接
x = torch.zeros([2, 1, 3])
y = torch.zeros([2, 3, 3])
z = torch.zeros([2, 2, 3])
w = torch.cat([x, y, z], dim=1)
w.shape
w
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.]]])

维度重构

x=torch.tensor([[1,2],[3,4]])
x.reshape(4,1)
tensor([[1],
        [2],
        [3],
        [4]])

降至一维

x=torch.tensor([[1,2],[3,4]])
y=x.view(-1)#降至一维
y.shape
torch.Size([4])

梯度计算

#Check if your computer has NVIDIA GPU
torch.cuda.is_available()
True
x = torch.tensor([[1., 0.], [-1., 1.]], requires_grad=True)
z = x.pow(2).sum()
z.backward()
x.grad
tensor([[ 2.,  0.],
        [-2.,  2.]])

生成由随机数组成的张量：

x = torch.randn(4,5)
tensor([[ 0.6943, -0.5611, -0.0806, -1.3583,  0.8251],
        [ 0.0767,  0.9962,  1.2139, -0.6798, -0.6962],
        [-0.2992, -0.2030,  0.4768,  0.7013, -0.4247],
        [-0.1476, -0.4150, -1.6605, -0.8300, -0.1804]])

得到张量x中的最大值：               

m = torch.max(x)
print(m)
tensor(1.2139)

得到张量中每一列的最大值（dim=0）并返回对应索引

m, idx = torch.max(x,0)
print(m)
print(idx)
tensor([0.6943, 0.9962, 1.2139, 0.7013, 0.8251])
tensor([0, 1, 1, 2, 0])

按行：

m, idx = torch.max(input=x,dim=1)
tensor([ 0.8251,  1.2139,  0.7013, -0.1476])
tensor([4, 2, 3, 0])

keepdim 表示是否需要保持输出的维度与输入一样，keepdim=True表示输出和输入的维度一样，keepdim=False表示输出的维度被压缩了，也就是输出会比输入低一个维度。 

m, idx = torch.max(x,dim=1,keepdim=True)
print(m)
print(idx)
m.shape
tensor([[ 0.8251],
        [ 1.2139],
        [ 0.7013],
        [-0.1476]])
tensor([[4],
        [2],
        [3],
        [0]])
torch.Size([4, 1])

m, idx = torch.max(x,dim=1,keepdim=False)
print(m)
print(idx)
m.shape
tensor([ 0.8251,  1.2139,  0.7013, -0.1476])
tensor([4, 2, 3, 0])
torch.Size([4])

 输出赋值给元组p

p = (m,idx)
torch.max(x,0,False,out=p)
print(p[0])
print(p[1])
tensor([0.6943, 0.9962, 1.2139, 0.7013, 0.8251])
tensor([0, 1, 1, 2, 0])

找出两个维度相同的张量间的最大值

t = torch.max(x,y)
print(t)
tensor([[ 0.6943, -0.5611,  0.0300,  1.7928,  0.8251],
        [ 0.0767,  0.9962,  1.2139,  0.2867,  1.7733],
        [-0.2992, -0.2030,  0.8119,  0.7013, -0.4247],
        [ 1.0753,  0.4340,  1.3726, -0.2577, -0.1477]])

维度互换（0代表0维）

z=torch.zeros(4,5)
z.transpose(0,1)
tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])

#全连接网络nn.Linear(in_features,out_features)
layer=torch.nn.Linear(32,64)
layer.weight.shape#神经网络权重矩阵

torch.Size([64, 32])

layer.bias.shape
torch.Size([64])

 类的一些知识：

在方法中定义的参数，一般来说只能在当前方法中使用(作用域)
（1）如果想要一个方法中的参数能在其他方法中使用，那么就可以使用"self."来将这个参数变成一个实例变量(实例变量后面介绍，这里主要是遇到了这种写法
（2）name参数：在方法中使用了"self.name = name"，这步就相当于是将这个name参数变成了一个实例变量，因此可以在所有方法中使用(这种写法了解即可，没啥意义，因为一个实例变量最好直接定义在__init__方法中)
（3）age参数：age参数就没有使用name参数那样的写法，仅仅是在setname()方法中定义并使用，因此age参数就只能在setname()方法中使用，而不能在kick()方法中使用，即使他们是在同一个类中(经常遇到的是这种写法)
 

class Ball:
    def setname(self,name,age):
        self.name = name
        print(age)
 
    def kick(self):
        return "我叫%s" % self.name
 
a = Ball()
b = Ball()
c = Ball()
 
a.setname("A",1)
b.setname("B",2)
c.setname("C",3)
 
print(a.kick())
print(b.kick())
print(c.kick())

输出：

1
2
3
我叫A
我叫B
我叫C

Pytorch是python里的机器学习框架，可以在GPU上进行N维张量的计算，可用于训练深度神经网络。

训练神经网络分为三个步骤：

1.定义神经网络

2.损失函数

3.优化算法

在定义神经网络部分，需要进行数据预处理，使用torch.data.Dataset以及torch.utils.data.Dataloder将数据处理成所要求的格式

Dataset:存储数据样本和预测值

DataLoder:将数据合并成batch,并且可以进行并行处理

在使用Dataloder时，我们经常喜欢打乱数据。 这就是 torch.utils.data.DataLoader 派上用场的地方。 如果从torch.utils.data.DataLoader 的角度来看，每个数据都是一个索引（0,1,2...），则可以通过对索引数组进行改组来打乱数据。

torch.utils.data.Dataset 通过 __len__() 和 __getitem__() 两个函数提供信息来支持

import torch.utils.data 
class ExampleDataset(torch.utils.data.Dataset):
  def __init__(self):
    self.data = "abcdefghijklmnopqrstuvwxyz"
  
  def __getitem__(self,idx): # index即idx与self._len_()大小有关
    if idx >= len(self.data): # if the index >= 26, return upper case letter
      return self.data[idx%26].upper()
    else: # if the index < 26, return lower case, return lower case letter
      return self.data[idx]
  
  def __len__(self): # What is the length of the dataset
    return 2 * len(self.data) # The length is now twice as large

dataset1 = ExampleDataset() # create the dataset
dataloader = torch.utils.data.DataLoader(dataset = dataset1,shuffle = False,batch_size = 6)
print(dataset1.__getitem__(51))
print(dataset1.__len__())
for datapoint in dataloader:
  print(datapoint)

 输出：

Z
52
['a', 'b', 'c', 'd', 'e', 'f']
['g', 'h', 'i', 'j', 'k', 'l']
['m', 'n', 'o', 'p', 'q', 'r']
['s', 't', 'u', 'v', 'w', 'x']
['y', 'z', 'A', 'B', 'C', 'D']
['E', 'F', 'G', 'H', 'I', 'J']
['K', 'L', 'M', 'N', 'O', 'P']
['Q', 'R', 'S', 'T', 'U', 'V']
['W', 'X', 'Y', 'Z']