文章目录
- 一、numpy在深度学习中的经典用法
- 1、生成numpy数组
- 2、获取元素
- 3、Numpy的数学运算
- 4、数组变形
-
- 5、批量处理
- 6、通用函数
- 7、广播机制
- 二、torch基础概述
- 1、tensor概述
- 2、创建tensor
- 3、修改tensor维度
- 4、索引操作
- 5、广播机制
- 6、示例
- 三、通过pytorch构建神经网络
- 1、构建网络层
- 2、前向传播
- 3、反向传播
- 4、训练与测试模型
- 5、神经网络工具箱nn
- 5.1、nn.Module
- 5.2、nn.functional
- 6、优化器
- 7、数据处理工具
开局首先一句话
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、更改数组形状
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
- transpose
arr2 = 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)
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_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、数据处理工具
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)