PaddlePaddle-百度架构师手把手带你零基础实践深度学习----第一周

PaddlePaddle-百度架构师手把手带你零基础实践深度学习----第一周

最近参加了百度AI Studio课程《百度架构师手把手带你零基础实践深度学习》，很有启发，在此分享一下第一周学习笔记。

其实自己并不是深度学习的初学者，之前也看过西瓜书和花书（看了一半），但为什么要参加这个课程呢，只因参加百度论文复现的时候发现，原来自己代码这么差啊！！！
这是大厂的免费课程，应当是为了培养使用飞桨的用户群体。有喜欢的话可以来听听：ai studio 先吹一波，这是我见过为数不多的良心课程，个人感觉比吴恩达的课程更加适合初学者。
举个例子：这是讲解的交叉熵损失的部分内容。
如 图所示。有两个外形相同的盒子，甲盒中有99个白球，1个蓝球；乙盒中有99个蓝球，1个白球。一次试验取出了一个蓝球，请问这个球应该是从哪个盒子中取出的？

相信大家简单思考后均会得出更可能是从乙盒中取出的，因为从乙盒中取出一个蓝球的概率更高(P(D∣h))(P(D|h))(P(D∣h))，所以观察到一个蓝球更可能是从乙盒中取出的(P(h∣D))。D是观测的数据，即蓝球白球；h是模型，即甲盒乙盒。这就是贝叶斯公式所表达的思想：P(h∣D)∝P(h)⋅P(D∣h)
依据贝叶斯公式，某二分类模型“生成”n个训练样本的概率：

欢迎大家一起来ai shudio学习呀 现在每天运行项目还有12小时的算力可以领取，100的GPU，https://aistudio.baidu.com/aistudio/education/group/info/1297?

#修改标签数据的格式，从float32到int64
import os
import random
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np
from PIL import Image

import gzip
import json

定义数据集读取器

def load_data(mode=‘train’):

# 数据文件
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
data = json.load(gzip.open(datafile))
train_set, val_set, eval_set = data

# 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
IMG_ROWS = 28
IMG_COLS = 28

if mode == 'train':
    imgs = train_set[0]
    labels = train_set[1]
elif mode == 'valid':
    imgs = val_set[0]
    labels = val_set[1]
elif mode == 'eval':
    imgs = eval_set[0]
    labels = eval_set[1]

imgs_length = len(imgs)

assert len(imgs) == len(labels), \
      "length of train_imgs({}) should be the same as train_labels({})".format(
              len(imgs), len(labels))

index_list = list(range(imgs_length))

# 读入数据时用到的batchsize
BATCHSIZE = 100

# 定义数据生成器
def data_generator():
    if mode == 'train':
        random.shuffle(index_list)
    imgs_list = []
    labels_list = []
    for i in index_list:
        img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
        label = np.reshape(labels[i], [1]).astype('int64')
        imgs_list.append(img) 
        labels_list.append(label)
        if len(imgs_list) == BATCHSIZE:
            yield np.array(imgs_list), np.array(labels_list)
            imgs_list = []
            labels_list = []

    # 如果剩余数据的数目小于BATCHSIZE，
    # 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
    if len(imgs_list) > 0:
        yield np.array(imgs_list), np.array(labels_list)

return data_generator

class MNIST(fluid.dygraph.Layer):
def init(self):
super(MNIST, self).init()

     # 定义一个卷积层，使用relu激活函数
     self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
     # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
     self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
     # 定义一个卷积层，使用relu激活函数
     self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
     # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
     self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
     # 定义一个全连接层，输出节点数为10 
     self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
# 定义网络的前向计算过程
 def forward(self, inputs):
     x = self.conv1(inputs)
     x = self.pool1(x)
     x = self.conv2(x)
     x = self.pool2(x)
     x = fluid.layers.reshape(x, [x.shape[0], 980])
     x = self.fc(x)
     return x

with fluid.dygraph.guard():
model = MNIST()
model.train()
#调用加载数据的函数
train_loader = load_data(‘train’)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
EPOCH_NUM = 5
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据，变得更加简洁
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)

        #前向计算的过程
        predict = model(image)
        
        #计算损失，使用交叉熵损失函数，取一个批次样本损失的平均值
        loss = fluid.layers.cross_entropy(predict, label)
        avg_loss = fluid.layers.mean(loss)
        
        #每训练了200批次的数据，打印下当前Loss的情况
        if batch_id % 200 == 0:
            print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
        
        #后向传播，更新参数的过程
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        model.clear_gradients()

#保存模型参数
fluid.save_dygraph(model.state_dict(), 'mnist')