百度Paddle学习日记（二）

顾名思义 这波是百度paddle学习的第二天

今天学习的是利用神经网络实现手势识别

数据和部分代码来自：https://aistudio.baidu.com
首先 把任务比作火箭🚀 神经网络就是火箭的发动机 那数据集就是 火箭的油
数据这里就暂时无法提供了 可以去aistudio自取

这里就是数据集里面已经分好类的图片了，到时候方便我们调用
下面我们来到我们的代码部分：

import os
import time
import random
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import paddle
import paddle.fluid as fluid
import paddle.fluid.layers as layers
from multiprocessing import cpu_count

from PIL._imaging import display
from paddle.fluid.dygraph import Pool2D,Conv2D
from paddle.fluid.dygraph import Linear

直接把需要的库调用出来
对于飞桨的API查找直接百度搜索飞桨进入官网查看文档即可

# 生成图像列表
data_path = 'data/data23668/Dataset'
character_folders = os.listdir(data_path)
# print(character_folders)
if (os.path.exists('./train_data.list')):
    os.remove('./train_data.list')
if (os.path.exists('./test_data.list')):
    os.remove('./test_data.list')

for character_folder in character_folders:

    with open('./train_data.list', 'a') as f_train:
        with open('./test_data.list', 'a') as f_test:
            if character_folder == '.DS_Store':
                continue
            character_imgs = os.listdir(os.path.join(data_path, character_folder))
            count = 0
            for img in character_imgs:
                if img == '.DS_Store':
                    continue
                if count % 10 == 0:
                    f_test.write(os.path.join(data_path, character_folder, img) + '\t' + character_folder + '\n')
                else:
                    f_train.write(os.path.join(data_path, character_folder, img) + '\t' + character_folder + '\n')
                count += 1
print('列表已生成')
# 定义训练集和测试集的reader
def data_mapper(sample):
    img, label = sample
    img = Image.open(img)
    img = img.resize((100, 100), Image.ANTIALIAS)
    img = np.array(img).astype('float32')
    img = img.transpose((2, 0, 1))
    img = img/255.0
    return img, label

def data_reader(data_list_path):
    def reader():
        with open(data_list_path, 'r') as f:
            lines = f.readlines()
            for line in lines:
                img, label = line.split('\t')
                yield img, int(label)
    return paddle.reader.xmap_readers(data_mapper, reader, cpu_count(), 512)
# 用于训练的数据提供器
train_reader = paddle.batch(reader=paddle.reader.shuffle(reader=data_reader('./train_data.list'), buf_size=256), batch_size=32)
# 用于测试的数据提供器
test_reader = paddle.batch(reader=data_reader('./test_data.list'), batch_size=32)

以上代码是对数据集的一些处理来帮助我们的网络进行训练

接下来就是我们神经网络的设计部分：

class DensenNet(fluid.dygraph.Layer):
    def __init__(self,training=True):
        super(DensenNet,self).__init__()
        self.conv1 = Conv2D(num_channels=3,num_filters=32,filter_size=3,act='relu')
        self.pool1 = Pool2D(pool_size=2,pool_stride=2,pool_type='max')
        self.conv2 = Conv2D(num_channels=32, num_filters=32, filter_size=3, act='relu')
        self.pool2 = Pool2D(pool_size=2, pool_stride=2,pool_type='max')
        self.conv3 = Conv2D(num_channels=32, num_filters=64, filter_size=3, act='relu')
        self.pool3 = Pool2D(pool_size=2, pool_stride=2,pool_type='max')
        self.fc1 = Linear(input_dim=6400,output_dim=8192,act='relu')
        self.drop_ratiol = 0.5 if training else 0.0
        self.fc2 = Linear(input_dim=8192,output_dim=10)

    def forward(self,input1):
        conv1 = self.conv1(input1)
        pool1 = self.pool1(conv1)
        #
        conv2 = self.conv2(pool1)
        pool2 = self.pool2(conv2)
        #
        conv3 = self.conv3(pool2)
        pool3 = self.pool3(conv3)

        rs_1 = fluid.layers.reshape(pool3,[pool3.shape[0],-1])
        fc1 = self.fc1(rs_1)
        drop1 = fluid.layers.dropout(fc1,self.drop_ratiol)
        y = self.fc2(drop1)
        return y

这是一个典型的Net神经网络
对于一些不懂的地方欢迎移步官方文档：https://www.paddlepaddle.org.cn/tutorials/projectdetail/340219#anchor-0
感觉被比我讲的好😳
神经网络设计完成后：
我们就用飞桨的动态图来完成神经网络的训练
关于动态图的解释也可以在刚刚的官网里找到

with fluid.dygraph.guard():
    model = DensenNet(True)  # 模型实例化
    model.train()  # 训练模式
    # opt = fluid.optimizer.SGDOptimizer(learning_rate=0.01,
    #                                    parameter_list=model.parameters())  # 优化器选用SGD随机梯度下降，学习率为0.001.
    opt = fluid.optimizer.Momentum(learning_rate=0.001, momentum=0.9, parameter_list=model.parameters())

    epochs_num = 100  # 迭代次数

    for pass_num in range(epochs_num):

        for batch_id, data in enumerate(train_reader()):

            images = np.array([x[0].reshape(3, 100, 100) for x in data], np.float32)

            labels = np.array([x[1] for x in data]).astype('int64')
            labels = labels[:, np.newaxis]
            # print(images.shape)
            image = fluid.dygraph.to_variable(images)
            label = fluid.dygraph.to_variable(labels)
            predict = model(image)  # 预测
            # print(predict)
            sf_predict = fluid.layers.softmax(predict)
            # loss = fluid.layers.cross_entropy(predict, label)这个问题huaiyizaizhe
            loss = fluid.layers.softmax_with_cross_entropy(predict, label)
            avg_loss = fluid.layers.mean(loss)  # 获取loss值

            acc = fluid.layers.accuracy(sf_predict, label)  # 计算精度

            if batch_id != 0 and batch_id % 50 == 0:
                print(
                    "train_pass:{},batch_id:{},train_loss:{},train_acc:{}".format(pass_num, batch_id, avg_loss.numpy(),
                                                                                  acc.numpy()))

            avg_loss.backward()
            opt.minimize(avg_loss)
            model.clear_gradients()

    fluid.save_dygraph(model.state_dict(), 'MyDNN')  # 保存模型

接下来就开始我们的模型校验：

# 模型校验
with fluid.dygraph.guard():
    accs = []
    model_dict, _ = fluid.load_dygraph('MyDNN')
    model = DensenNet()
    model.load_dict(model_dict)  # 加载模型参数
    model.eval()  # 训练模式
    for batch_id, data in enumerate(test_reader()):  # 测试集
        images = np.array([x[0].reshape(3, 100, 100) for x in data], np.float32)
        labels = np.array([x[1] for x in data]).astype('int64')
        labels = labels[:, np.newaxis]

        image = fluid.dygraph.to_variable(images)
        label = fluid.dygraph.to_variable(labels)

        predict = model(image)
        acc = fluid.layers.accuracy(predict, label)
        accs.append(acc.numpy()[0])
        avg_acc = np.mean(accs)
    print(avg_acc)

以上就完成了一个手势识别的神经网络设计和训练啦。
接下来的就是读取图片了：

# 模型校验
with fluid.dygraph.guard():
    accs = []
    model_dict, _ = fluid.load_dygraph('MyDNN')
    model = DensenNet()
    model.load_dict(model_dict)  # 加载模型参数
    model.eval()  # 训练模式
    for batch_id, data in enumerate(test_reader()):  # 测试集
        images = np.array([x[0].reshape(3, 100, 100) for x in data], np.float32)
        labels = np.array([x[1] for x in data]).astype('int64')
        labels = labels[:, np.newaxis]

        image = fluid.dygraph.to_variable(images)
        label = fluid.dygraph.to_variable(labels)

        predict = model(image)
        acc = fluid.layers.accuracy(predict, label)
        accs.append(acc.numpy()[0])
        avg_acc = np.mean(accs)
    print(avg_acc)
#读取预测图像，进行预测

这就是第二天的学习日记了，也算是完成了自己的第一个神经网络作业吧，
来看看成功训练的截图🤭

达到了 0.85还算合格，想要提高的朋友们可以尝试增加训练的次数和修改网络。
我们明天再见ヾ(￣▽￣)Bye_Bye