1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 定义reader
# 定义buf_size和batch_size大小
buf_size = 1000
batch_size = 256

# 训练集reader
train_reader = fluid.io.batch(
    reader=paddle.reader.shuffle(
        reader=read_data(TRAIN_SET),
        buf_size=buf_size
    ),
    batch_size=batch_size
)
# 测试集reader
test_reader = fluid.io.batch(
    reader=paddle.reader.shuffle(
        reader=read_data(TEST_SET),
        buf_size=buf_size
    ),
    batch_size=batch_size
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 定义飞桨动态图工作环境
with fluid.dygraph.guard():
    # 实例化模型
    # Softmax分类器
    model = SoftmaxRegression('catornocat')
    
    # 开启模型训练模式
    model.train()
    # 使用Adam优化器
    # 学习率为0.01
    opt = fluid.optimizer.Adam(learning_rate=0.01, parameter_list=model.parameters())
    # 迭代次数设为200
    EPOCH_NUM = 200

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph import Linear
from the_functions import *
from the_third_regression import *
import numpy as np


# 按间距中的绿色按钮以运行脚本。
if __name__ == '__main__':
    #加载数据
    np.set_printoptions(threshold=np.inf)
    TRAIN_SET,TEST_SET,DATA_DIM,CLASSES=get_data()
    #print(TRAIN_SET)
    #定义reader
    #定义内存大小和批次数量
    buf_size=500
#批次的尺寸是256，也就是一批里面又256条数据，但是这个数据集一共209条数据，所以就一个批次
    batch_size=120
    #训练集reader生成器
    #这个可以理解为输入输出io的batch（训练集数据，批次大小为256）把1000条数据打乱，再256一批的训练
    train_reader = fluid.io.batch(
        reader=paddle.reader.shuffle(
            reader=read_data(TRAIN_SET),
            buf_size=buf_size
        ),
        batch_size=batch_size
    )
    print(train_reader)
    print(type(train_reader))
    # 测试集reader，测试集数据生成器
    test_reader = fluid.io.batch(
        reader=paddle.reader.shuffle(
            reader=read_data(TEST_SET),
            buf_size=buf_size
        ),
        batch_size=batch_size
    )
    #定义飞桨动态图工作环境
    with fluid.dygraph.guard():
        model=SoftmaxRegression('catornocat')
        model.train()
        #定义优化器Adam
        opt=fluid.optimizer.Adam(learning_rate=0.01,parameter_list=model.parameters())
        EPOCH_NUM=3

    with fluid.dygraph.guard():
        costs=[]
        print('train_reader的类型是：',type(train_reader()))
        for pass_num in range(EPOCH_NUM):
            print('第{}次'.format(pass_num))
            #print(pass_num)
            #定义内层循环,训练集大概是500条数据，分成了两批
            for batch_id,data in enumerate(train_reader()):
                #调整数据shape使之适合模型
                print('batch_id为{},'.format(batch_id))
                images=np.array([x[0].reshape(DATA_DIM) for x in data],np.float32)
                print(images.shape)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
with fluid.dygraph.guard():
    # 记录每次的损失值，用于绘图
    costs = []
    # 定义外层循环
    for pass_num in range(EPOCH_NUM):
        # 定义内层循环
        for batch_id,data in enumerate(train_reader()):
            # 调整数据shape使之适合模型
            images = np.array([x[0].reshape(DATA_DIM) for x in data],np.float32)
            labels = np.array([x[1] for x in data]).astype('int64').reshape(-1,1)
            
            # 将numpy数据转为飞桨动态图variable形式
            image = fluid.dygraph.to_variable(images)
            label = fluid.dygraph.to_variable(labels)
            
            # 前向计算
            predict = model(image)

            # 计算损失
            # 使用交叉熵损失函数
            loss = fluid.layers.cross_entropy(predict,label)
            avg_loss = fluid.layers.mean(loss)

            # 计算精度
            # acc = fluid.layers.accuracy(predict,label)
            
            # 绘图
            costs.append(avg_loss.numpy()[0])
            draw_line(costs, 0.01)

            # 反向传播
            avg_loss.backward()
            # 最小化loss,更新参数
            opt.minimize(avg_loss)
            # 清除梯度
            model.clear_gradients()

    # 保存模型文件到指定路径
    fluid.save_dygraph(model.state_dict(), 'catornocat')