李沐《动手学深度学习》Pytorch实现记录(1)第一、二、三、四章

在这里插入图片描述

动手学深度学习阅读&复现

动手学深度学习在线阅读地址
动手学深度学习pytorch实现地址

第一章 深度学习简介

  • 深度学习是机器学习的一个函数形式(多层神经网络)
  • 深度学习再次兴起最终原因: 近年来发展速度:算力(P)>数据量(T)>存储空间(T),统计模型可以在优化参数上投入更多,但需要提高存储的利用效率,例如使用非线性处理单元。
  • 相对其它经典的机器学习方法而言,深度学习的不同在于:对非最优解的包容、对非凸非线性优化的使用,以及勇于尝试没有被证明过的方法。

第二章 预备知识

  • 不同的运行模式:model.eval()model.train()(dropout和batch normalization不同)
  • 矢量运算快于标量运算叠加,所以需要用矢量运算

第三章 深度学习基础

  • 简单线性回归(注意:包装数据集,参数初始化)
import torch
import numpy as np
def generatelinear(w,b,k):
    x=np.random.normal(scale=1,size=(k,len(w)))
    y=np.dot(x,w)+b
    y+=np.random.normal(scale=0.01,size=y.shape)
    x=torch.from_numpy(x).float()
    y=torch.from_numpy(y).float().reshape(-1,1)
    return x,y
truew=torch.Tensor([1,2])
trueb=3
x,y=generatelinear(truew,trueb,1000)
from torch.utils.data import TensorDataset,DataLoader
def load_array(x,y):
    dataset=TensorDataset(*(x,y))
    dataloader=DataLoader(dataset=dataset,batch_size=10,shuffle=True)
    return dataloader
data_iter=load_array(x,y)

class LinearRegressionModule(torch.nn.Module):
    def __init__(self):
        super(LinearRegressionModule,self).__init__()
        self.fc1=torch.nn.Linear(2,1,bias=True)
    def forward(self,x):
        y=self.fc1(x)
        return y
net=LinearRegressionModule()
net.fc1.weight.data=torch.Tensor(np.random.normal(size=(1,2),scale=0.01,loc=0))
net.fc1.bias.data=torch.Tensor([0])
loss=torch.nn.MSELoss(reduction='sum')
optimizer=torch.optim.SGD(net.parameters(),lr=0.03)
for i in range(3):
    for a,b in data_iter:
        l=loss(net(a),b)
        optimizer.zero_grad()
        l.backward()
        optimizer.step()
    print(i+1,':  ',loss(net(x),y))
import torch.nn as nn
def init_weights(m):
    if type(m) == nn.Linear:
        torch.nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)
net.apply(init_weights)        
  • dropout:dropout的坑
  • kaggle实战:预测房价:看完第9章回来填坑

第四章 深度学习计算

  • 定义网络的第二,三种形式:
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5)
        )
print(model)
class MySequential(nn.Sequential):
    def __init__(self):
        super(MySequential,self).__init__()
    def add_module(self,block):
        self._modules[block]=block
    def forward(self, x):
        for block in self._modules.values():
            x=block(x)
        return x
net=MySequential()
net.add_module(nn.Linear(20,256))
net.add_module(nn.ReLU())
net.add_module(nn.Linear(256,10))
x=torch.randn(2,20)
print(net(x))

也可逻辑定义:

def block1():
    net = nn.Sequential(nn.Linear(16, 32),
                        nn.ReLU(),
                        nn.Linear(32, 16),
                        nn.ReLU())
    return net
  
 def block2():
    net = nn.Sequential()
    for i in range(4):
        net.add_module('block'+str(i), block1())
    return net    
        
rgnet = nn.Sequential()
rgnet.add_module('model',block2())

 
  • 参数初始化的各种方式
  • 自定义层:
    无参数:
class Centerlayer(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self,x):
        return x-x.mean()

有参数:

class MyDense(nn.Module):
    def __init__(self, units, in_units):
        super().__init__()
        self.weight = Variable(torch.ones(in_units, units))
        self.bias = Variable(torch.ones(units,))
    def forward(self, x):
        linear = torch.matmul(x, self.weight.data) + self.bias.data
        return F.relu(linear)
  • 延迟初始化(书中讲的不清楚,略过)
  • 存储模型:
net=Net()
torch.save(net.state_dict(), 'net.params')
net2=Net()
net2.load_state_dict(torch.load("net.params"))
发布了20 篇原创文章 · 获赞 12 · 访问量 4700
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览