深度学习numpy与tensor基础知识、关系与区别，通过pytorch构建网络加载数据

开局首先一句话

import numpy as np
import torch

一、numpy在深度学习中的经典用法

1、生成numpy数组

• 直接转换np.array(list1）
• random模块生成np.random.random([3,3])
• 创建特定形状np.zeros([3,3])
• arange/linspace模块生成np.arange(1,4,0.5)，只有一个数字的话为1-数字

2、获取元素

• 与python中类似，直接nd11[3:6]
• random.choice函数可以从指定样本中随机抽取数据

3、Numpy的数学运算

• 对应相乘：A*B/np.numtiply(a,b)
• 点乘运算：np.dot()

4、数组变形

4.1、更改数组形状

• reshape改变向量的维度（不改变向量本身）

import numpy as np
arr = np.arange(6).reshape(2,-1)

• resize改变向量的维度（修改向量本身）np.arange(6).resize(2,-1)
• T转置 np.arrange(12).reshape(3,4).T
• revel展平

import numpy as np
arr = np.arange(6).reshape(2,-1)
print(arr)
print(arr.ravel('F'))#按列优先展平
print(arr.ravel())#按行优先展平

• flatten 将矩阵转成向量，卷积与全连接层之间进行

a = np.floor(10*np.random.random((3,4)))
print(a)
print(a.flatten())

• squeeze压缩掉含1的维度arr.squeeze().shape
• transposearr2 = np.arange(24).reshape(2,3,4).transpose(1,2,0)

4.2、合并数组

• append在后面添加np.append(a,b,axis=0)0为行合并，1为列合并
• concatenate沿指定轴连接数组或者矩阵np.concatenate((a,b),axis=0)
• stack沿指定轴堆叠数组或矩阵np.stack((a,b),axis=0)

5、批量处理

import numpy as np

data_train = np.random.randn(10000,2,3)
print(data_train.shape)
np.random.shuffle(data_train)
batch_size = 100
for i in range(0,len(data_train),batch_size):
    x_batch_sum = np.sum(data_train[i:i+batch_size])
    print("第{}批次，该批次数据的和：{}".format(i,x_batch_sum))

6、通用函数

两种基本对象：ndarry和ufunc对象

• math与numpy：numpy.sin比math.sin快近10倍
• 循环与向量：向量要比循环快的多

7、广播机制

import numpy as np
A = np.arange(0,40,10).reshape(4,1)
B = np.arange(0,3)
C = A + B
print(C)

二、torch基础概述

1、tensor概述

• torch.add(x,y)和x.add(y)等价
• x.add(y)不会修改自身数据，x.add_(y)修改自身数据

2、创建tensor

import torch
torch.Tensor([1,2,3,4])
torch.Tensor(2,3)
torch.Tensor([[1,2],[3,4]])

• torch.Tensor默认浮点型数据，torch.tensor从数据中推断数据类型。
• torch.tensor(1)返回固定值1，torch.Tensor(1)返回大小为1的张量，随机初始值。

3、修改tensor维度

• 大部分与numpy类似
• 添加维度torch.unsqueeze(y,0)
• view(-1)展平数组，只能由torch.Tensor.view()来调用

4、索引操作

import torch

torch.manual_seed(100)
x = torch.randn(2,3)
x[0:]
x[:,-1]
mask = x > 0
torch.masked_select(x,mask)
torch.nonzero(mask)

5、广播机制

import torch
import numpy as np
A = np.arange(0,40,10).reshape(4,1)
B = np.arange(0,3)
A1 = torch.from_numpy(A)
B1 = torch.from_numpy(B)
C = A1 + B1

6、示例

import torch as t
from matplotlib import pyplot as plt
import numpy
t.manual_seed(100)
x = t.unsqueeze(t.linspace(-1,1,100),dim = 1)
y = 3*x.pow(2) + 2 + 0.2*t.rand(x.size())
plt.scatter(x.numpy(),y.numpy())
plt.show()

w = t.randn(1,1,requires_grad=True)
b = t.randn(1,1,requires_grad=True)

lr = 0.01
for ii in range(800):
    y_pred = x.pow(2).mm(w) + b
    loss = 0.5*(y_pred - y)**2
    loss = loss.sum()
    
    loss.backward()
    with t.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad
        
        w.grad.zero_()
        b.grad.zero_()

plt.plot(x.numpy(),y_pred.detach().numpy(),'r',label = 'predict')
plt.scatter(x.numpy(),y.numpy())
plt.xlim(-1,1)
plt.ylim(2,6)
plt.show()
print(w,b)

三、通过pytorch构建神经网络

1、构建网络层

可以借助nn工具箱class Net(torch.nn.Module)

class Net(nn.Module):
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
        super(Net, self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1))
        self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d(n_hidden_2))
        self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))
        
    def forward(self,x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x

2、前向传播

来自nn.Module的需要示例化，来自nn.fuctional的不需要实例化

    def forward(self,x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x

3、反向传播

直接让损失函数调用loss即可 loss.backward()

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

model = Net(28*28, 300, 100, 10)
model.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)

losses, acces, eval_losses, eval_acces = [],[],[],[]
for epoch in range(num_epochs):
    train_loss = 0
    train_acc = 0
    model.train()
    if epoch%5 == 0:
        optimizer.param_groups[0]['lr'] *= 0.1
    for img,label in train_loader:
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0),-1) #这里为28*28
        
        out = model(img)
        loss = criterion(out,label)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        train_loss += loss.item()
        _, pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct/img.shape[0] #这里的train_batch_size
        train_acc += acc
        
    losses.append(train_loss/len(train_loader))
    acces.append(train_acc/len(train_loader))

4、训练与测试模型

首先要记得调用module.train()，这样就可以把所有的module设置为训练模式；同样训练阶段要调用module.eval()。

optimizer.zero_grad()#缺省情况下梯度是累加的，要首先进行清零
loss.backward()#自动生成梯度
optimizer.step()#执行优化器

5、神经网络工具箱nn

可以避免手动设置requires_grad=Ture

5.1、nn.Module

nn已经实现了绝大多数层，并作为自己的子类，能自动检测到parameter

5.2、nn.functional

• nn.Xxx继承于nn.Module，需要先实例化并传入参数，然后以函数调用的方式实例化对象并传入数据，能够与nn.Sequential结合使用，nn.functional则不能。
• nn.Xxx不需要自己定义和管理weight、bias参数
• 可以通过nn.Xxx的方式定义Dropout

6、优化器

封装在torch.optim当中，各种优化方法都是继承了基类optim.Optimizer

import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)

7、数据处理工具