人工智能考核
Published in：2024-03-11 | category： 智能车
Words: 4.6k | Reading time: 22min | reading：

task1.1

对于你给出的解释，请给出相应的PaddlePaddle对应的函数，并尽可能的解释函数参数的意义

  1. 解释神经网络中卷积层的作用。
    • 把卷积核中心点周围的像素按比例附加到(对其产生影响)卷积核中心对应的像素;
    • 卷积核代表一个特征，用来提取输入数据的特定特征
      paddle.nn.Conv2D()
    • in_channels：输入特征图的通道数。
    • out_channels：输出特征图的通道数。
    • kernel_size：卷积核大小。
    • stride：卷积步长。
    • padding：填充大小。
  2. 解释神经网络中池化层的作用。

    过滤特征(减小特征图的维度)
    paddle.nn.MaxPool2D(最大池化) paddle.nn.AvgPool2D(平均池化)

    • kernel_size：池化核大小。
    • stride：池化步长。
    • padding：填充大小。
  3. 解释神经网络中连接层的作用。

    将输入的多维向量数据展平为一维向量，然后线性处理，与权重矩阵相乘，再加上偏置项，通过激活函数输出结构，可以进行分类/预测
    paddle.nn.Linear()

    • in_features：输入特征的大小。
    • out_features：输出特征的大小。
  4. 解释神经网络中激活函数层的作用。

    把连接层得到的线性结构转化为非线性结果，从而更好地拟合数据并提高模型的性能
    paddle.nn.ReLU paddle.nn.Sigmoid paddle.tanh

    • 没有参数
  5. 解释神经网络中Dropout层的作用。

    正则化，随机丢弃神经元，减少参数，降低模型复杂度，减少过拟合情况
    paddle.nn.Dropout

    • dropout_prob：丢弃概率，即要丢弃的神经元的比例。

task2.1

在一个单层感知器中，假设有两个输入特征和一个输出。

权重分别是w1 = 0.5，w2 = -0.3，偏差为b = 0.1。

输入特征为x1 = 2，x2 = -1。

计算输出（假设激活函数是阶跃函数）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 定义权重/偏差/输入特征
w1 = 0.5
w2 = -0.3
b = 0.1
x1 = 2
x2 = -1


# 定义激活函数(阶跃函数)
def step_function(x):
    if x >= 0:
        return 1
    else:
        return 0

# 计算
def perceptron_output(w1, w2, b, x1, x2):
    result = w1 * x1 + w2 * x2 + b
    return step_function(result)

# 输出
output = perceptron_output(w1, w2, b, x1, x2)
print("Output:", output)

task2.2（代码实现）

假设你有一个包含两个隐藏层的前馈神经网络，每个隐藏层分别有3个神经元。

输入层有4个特征，输出层有2个神经元。

所有的激活函数都是ReLU。

编写一个函数来计算整个网络的输出，给定输入和网络参数。

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
import numpy as np

IP = [[1, 2, 3, 4]]
W1 = [[0.32361505, -1.08053636, 1.94312927],
      [1.87599918, 0.09333858, -0.54394708],
      [0.31721595, 0.15919131, 0.75238423],
      [0.52593422, 0.39281801, 0.47263081]]
B1 = [[-0.95059911, -0.78673449, -0.27075615]]
W2 = [[-1.11562289, -1.05667625, 1.17330918],
      [1.15682221, 0.30359694, -0.32633211],
      [0.44536135, 0.31302144, -1.16012537]]
B2 = [[1.48936813, -0.50073038, -0.16725209]]
W3 = [[-0.06277751, -0.52103597],
      [-0.29022904, 1.55451498],
      [-0.80766273, -0.24495497]]
B3 = [[0.97822396, 1.32775756]]


# 定义relu函数
def relu(x):
    return np.maximum(0, x)


def Feedforward_neural_network(IP, W1, B1, W2, B2, W3, B3):
    IP = np.array(IP)
    W1 = np.array(W1)
    B1 = np.array(B1)
    W2 = np.array(W2)
    B2 = np.array(B2)
    W3 = np.array(W3)
    B3 = np.array(B3)

    out1 = np.dot(IP, W1) + B1
    in2 = relu(out1)
    out2 = np.dot(in2, W2) + B2
    in3 = relu(out2)
    out3 = np.dot(in3, W3) + B3
    output = out3
    return output


# 进行前向传播
result = Feedforward_neural_network(IP, W1, B1, W2, B2, W3, B3)
print(result)

task3.1（代码实现）

题目：线性回归模型

使用PaddlePaddle框架（Paddle Pytorch Tensorflow，或者自己手写线性回归网络都可）搭建一个简单的线性回归模型，对data.csv数据集中的数据进行训练，并预测新数据点的值。

提示

使用paddle.nn.Linear创建一个具有单个输入和单个输出的线性层。
定义损失函数和优化器。
训练模型以拟合数据。
对新数据进行预测。

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import paddle
from paddle.nn import Linear
import paddle.nn.functional as F
import numpy as np
import os
import random
import pandas as pd


def load_data():
    # 从文件导入数据
    datafile = pd.read_csv("C:/Users/lxcqm/Desktop/人工智能考核/训练数据/data.csv")
    X = datafile["X"].values.astype("float32")
    Y = datafile["y"].values.astype("float32")
    data_matrix = np.column_stack((X, Y))

    # 确保数据的总元素数量为 100000
    num_rows = 50000
    num_cols = 2

    data_matrix = data_matrix.reshape((num_rows, num_cols))


    # 将原数据集拆分成训练集和测试集
    # 这里使用80%的数据做训练，20%的数据做测试
    # 测试集和训练集必须是没有交集的
    ratio = 0.8
    offset = int(data_matrix.shape[0] * ratio)
    training_data = data_matrix[:offset]
    test_data = data_matrix[offset:]

    # 计算train数据集的最大值，最小值
    maximums, minimums = training_data.max(axis=0), training_data.min(axis=0)

    # 记录数据的归一化参数，在预测时对数据做归一化
    global max_values
    global min_values

    max_values = maximums
    min_values = minimums

    # 对数据进行归一化处理
    training_data = (training_data - min_values) / (maximums - minimums)
    test_data = (test_data - min_values) / (maximums - minimums)
    return training_data, test_data


# # 验证数据集读取程序的正确性
# training_data, test_data = load_data()
# print(training_data.shape)
# print(training_data)


class Regressor(paddle.nn.Layer):

    # self代表类的实例自身
    def __init__(self):
        # 初始化父类中的一些参数
        super(Regressor, self).__init__()

        # 定义一层全连接层，输入维度是1，输出维度是1
        self.fc = Linear(in_features=1, out_features=1)

    # 网络的前向计算
    def forward(self, inputs):
        x = self.fc(inputs)
        return x


# 声明定义好的线性回归模型
model = Regressor()
# 开启模型训练模式
model.train()
# 加载数据
training_data, test_data = load_data()

# 定义优化算法，使用随机梯度下降SGD
# 学习率设置为0.01
opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())

EPOCH_NUM = 10  # 设置外层循环次数
BATCH_SIZE = 100  # 设置batch大小

# 定义外层循环
for epoch_id in range(EPOCH_NUM):
    # 在每轮迭代开始之前，将训练数据的顺序随机的打乱
    np.random.shuffle(training_data)

    # 将训练数据进行拆分，每个batch包含10条数据
    mini_batches = [training_data[k:k + BATCH_SIZE] for k in range(0, len(training_data), BATCH_SIZE)]
# print(mini_batches)
    # 定义内层循环
    for iter_id, mini_batch in enumerate(mini_batches):
        x = np.array(mini_batch[:, :-1])  # 获得当前批次训练X
        y = np.array(mini_batch[:, -1:])  # 获得当前批次训练Y
# print(mini_batch, x, y)
        # 将numpy数据转为飞桨动态图tensor的格式
        X = paddle.to_tensor(x)
        Y = paddle.to_tensor(y)

        # 前向计算
        predicts = model(X)

        # 计算损失
        loss = F.square_error_cost(predicts, label=Y)
        avg_loss = paddle.mean(loss)
        if iter_id % 100 == 0:
            print("epoch: {}, iter: {}, loss is: {}".format(epoch_id, iter_id, avg_loss.numpy()))

        # 反向传播，计算每层参数的梯度值
        avg_loss.backward()
        # 更新参数，根据设置好的学习率迭代一步
        opt.step()
        # 清空梯度变量，以备下一轮计算
        opt.clear_grad()


def load_one_example():
    # 从上边已加载的测试集中，随机选择一条作为测试数据
    idx = np.random.randint(0, test_data.shape[0])
    # idx = -10
    x0, y0 = test_data[idx, 0], test_data[idx, -1]

    x0 = x0.reshape([1, -1])

    return x0, y0


# 保存模型参数，文件名为LR_model.pdparams
paddle.save(model.state_dict(), 'C:/Users/lxcqm/Desktop/model/model1.pdmodel')
print("模型保存成功，模型参数保存在C:/Users/lxcqm/Desktop/model/model1.pdmodel")

# 参数为保存模型参数的文件地址
model_dict = paddle.load('C:/Users/lxcqm/Desktop/model/model1.pdmodel')
model.load_dict(model_dict)
model.eval()

# 参数为数据集的文件地址
xn, yn = load_one_example()
# 将数据转为动态图的variable格式
xn = paddle.to_tensor(xn)
predict = model(xn)
# print("xn", xn,"predict",predict, "yn", yn)
# 对结果做反归一化处理
predict = predict * (max_values[-1] - min_values[-1]) + min_values[-1]
# 对Y数据做反归一化处理
yn = yn * (max_values[-1] - min_values[-1]) + min_values[-1]

print("Inference result is {}, the corresponding Y is {}".format(predict.numpy(), yn))

task3.2（代码实现）

题目：卷积神经网络（CNN）分类

使用PaddlePaddle框架构建一个简单的卷积神经网络（CNN），用于对MNIST手写数字数据集进行分类。

(Paddle Pytorch Tensorflow等框架都可)

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
import json
import gzip
import paddle
from paddle.vision.transforms import Normalize
from paddle.io import Dataset
import numpy as np
from PIL import Image
from paddle.vision.transforms import functional as F

# 定义图像归一化处理方法,这里的CHW指图像格式需为 [C通道数,H图像高度,W图像宽度]
# 减均值,除以标准差
# 假设像素值范围是 [0, 255]
# 当每个像素值减去 127.5 后
# 范围变为 [-127.5, 127.5]
# 再除以 127.5（或者是原始数据范围的一半）
# 就得到了 [-1, 1] 的范围
transform = Normalize(mean=[127.5], std=[127.5], data_format='CHW')


class MNISTDataset(Dataset):

    def __init__(self, datafile, mode='train', transform=None):

        super().__init__()

        self.mode = mode
        self.transform = transform

        print('loading mnist dataset from {} ......'.format(datafile))

        data = json.load(gzip.open(datafile))
        print('mnist dataset load done')

        # 读取到的数据区分训练集,验证集,测试集
        train_set, val_set, eval_set = data

        if mode == 'train':
            # 获得训练数据集
            self.imgs, self.labels = train_set[0], train_set[1]
        elif mode == 'valid':
            # 获得验证数据集
            self.imgs, self.labels = val_set[0], val_set[1]
        elif mode == 'test':
            # 获得测试数据集
            self.imgs, self.labels = eval_set[0], eval_set[1]
        else:
            raise Exception("mode can only be one of ['train', 'valid', 'test']")

    def __getitem__(self, index):
        """
        实现__getitem__方法，定义指定index时如何获取数据
        """
        data = self.imgs[index]
        label = self.labels[index]

        return self.transform(data), label

    def __len__(self):
        """
        实现__len__方法，返回数据集总数目
        """
        return len(self.imgs)


datafile = 'D:/paddlepaddle/paddlepaddle手写数字/mnist.json.gz'

# 下载数据集并初始化 DataSet
train_dataset = MNISTDataset(datafile, mode='train', transform=transform)
test_dataset = MNISTDataset(datafile, mode='test', transform=transform)

# print('train images: ', train_dataset.__len__(), ', test images: ', test_dataset.__len__())

# from matplotlib import pyplot as plt
#
# for data in train_dataset:
#     image, label = data
#     print('shape of image: ', image.shape)
#     plt.title(str(label))
#     plt.imshow(image[0])
#     break

# 定义并初始化数据读取器
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=0)
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=0)
# print('step num:', len(train_loader))


# class MNIST_CNN(paddle.nn.Layer):
#     def __init__(self):
#         super(MNIST_CNN, self).__init__()
#
#         # 定义一层全连接层，输出维度为一
#         self.fc = paddle.nn.Linear(in_features=784, out_features=1)
#         # 图片像素28*28=784个像素点
#
#     def forward(self, inputs):
#         outputs = self.fc(inputs)
#         return outputs


class MNIST_CNN(paddle.nn.Layer):
    def __init__(self):
        super(MNIST_CNN, self).__init__()

        # 定义卷积层
        self.conv1 = paddle.nn.Conv2D(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)
        self.pool1 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

        self.conv2 = paddle.nn.Conv2D(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.pool2 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

        # 计算全连接层的输入维度
        self.fc_input_dim = 32 * 7 * 7  # 根据卷积层和池化层输出的维度计算

        # 定义全连接层
        self.fc1 = paddle.nn.Linear(in_features=self.fc_input_dim, out_features=128)
        self.fc2 = paddle.nn.Linear(in_features=128, out_features=10)  # 输出类别数量为10，适用于MNIST数据集

    def forward(self, inputs):
        x = paddle.to_tensor(inputs)
        x = paddle.reshape(x, [-1, 1, 28, 28])
        # x = paddle.unsqueeze(x, axis=1)  # Add channel dimension
        x = self.conv1(x)
        x = paddle.nn.functional.relu(x)
        x = self.pool1(x)

        x = self.conv2(x)
        x = paddle.nn.functional.relu(x)
        x = self.pool2(x)

        x = paddle.flatten(x, start_axis=1)

        x = self.fc1(x)
        x = paddle.nn.functional.relu(x)
        x = self.fc2(x)

        return x


model = MNIST_CNN()


def train(model):
    print('train:')
    model.train()
    # 定义优化器，使用随机梯度下降SGD优化器，学习率设置为0.001
    # SGD的基本原理是在每一次迭代中，使用随机选择的小批量训练数据来计算梯度，并更新模型参数
    opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
    EPOCH_NUM = 5
    for epoch_id in range(EPOCH_NUM):
        print('epoch:', epoch_id)
        for batch_id, data in enumerate(train_loader()):
            images, labels = data
            images = paddle.to_tensor(images).astype('float32')
            labels = paddle.to_tensor(labels).astype('float32')

            images = paddle.reshape(images, [images.shape[0], images.shape[2] * images.shape[3]])

            # 前向计算的过程
            predicts = model(images)
            # Convert labels data type to integer
            labels_int = paddle.cast(labels, dtype='int64')

            # Convert labels to one-hot encoding
            labels_onehot = paddle.nn.functional.one_hot(labels_int, num_classes=10)
            # 计算损失，取一个批次样本损失的平均值

            loss = paddle.nn.functional.square_error_cost(predicts, labels_onehot)
            avg_loss = paddle.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()
            opt.step()
            opt.clear_grad()


# 创建模型
print("create model:")

# 启动训练过程
train(model)
# # 保存模型参数，文件名为LR_model.pdparams
# paddle.save(model.state_dict(), 'C:/Users/lxcqm/Desktop/model/modelhn.pdmodel')
# print("模型保存成功，模型参数保存在C:/Users/lxcqm/Desktop/model/modelhn.pdmodel")
#
# # 参数为保存模型参数的文件地址
# model_dict = paddle.load('C:/Users/lxcqm/Desktop/model/modelhn.pdmodel')
# model.load_dict(model_dict)
# model.eval()

task3.2（代码实现）

题目：卷积神经网络（CNN）分类

使用PaddlePaddle框架构建一个简单的卷积神经网络（CNN），用于对MNIST手写数字数据集进行分类。

(Paddle Pytorch Tensorflow等框架都可)

提示

构建一个包含卷积层、池化层和全连接层的CNN模型。
加载MNIST数据集，可以使用paddle.vision.datasets.MNIST。
定义损失函数和优化器。
训练模型以对手写数字进行分类。
评估模型性能并进行预测。

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
import json
import gzip
import paddle
from paddle.vision.transforms import Normalize
from paddle.io import Dataset
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import numpy as np
from PIL import Image
from paddle.vision.transforms import functional as F



# 定义图像归一化处理方法,这里的CHW指图像格式需为 [C通道数,H图像高度,W图像宽度]

transform = Normalize(mean=[127.5], std=[127.5], data_format='CHW')


class MNISTDataset(Dataset):

    def __init__(self, datafile, mode='train', transform=None):

        super().__init__()

        self.mode = mode
        self.transform = transform

        print('loading mnist dataset from {} ......'.format(datafile))

        data = json.load(gzip.open(datafile))
        print('mnist dataset load done')

        # 读取到的数据区分训练集,验证集,测试集
        train_set, val_set, eval_set = data

        if mode == 'train':
            # 获得训练数据集
            self.imgs, self.labels = train_set[0], train_set[1]
        elif mode == 'valid':
            # 获得验证数据集
            self.imgs, self.labels = val_set[0], val_set[1]
        elif mode == 'test':
            # 获得测试数据集
            self.imgs, self.labels = eval_set[0], eval_set[1]
        else:
            raise Exception("mode can only be one of ['train', 'valid', 'test']")

    def __getitem__(self, index):
        """
        实现__getitem__方法，定义指定index时如何获取数据
        """
        data = self.imgs[index]
        label = self.labels[index]

        return self.transform(data), label

    def __len__(self):
        """
        实现__len__方法，返回数据集总数目
        """
        return len(self.imgs)


datafile = 'D:/paddlepaddle/paddlepaddle手写数字/mnist.json.gz'

# 下载数据集并初始化 DataSet
train_dataset = MNISTDataset(datafile, mode='train', transform=transform)
test_dataset = MNISTDataset(datafile, mode='test', transform=transform)

# 定义并初始化数据读取器
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=0)
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=0)
# train_loader = paddle.io.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=0)
# test_loader = paddle.io.DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=0)

class MNIST_CNN(paddle.nn.Layer):
    def __init__(self):
        super(MNIST_CNN, self).__init__()

        # 定义卷积层
        self.conv1 = paddle.nn.Conv2D(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)
        self.pool1 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

        self.conv2 = paddle.nn.Conv2D(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.pool2 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

        # 计算全连接层的输入维度
        self.fc_input_dim = 32 * 7 * 7  # 根据卷积层和池化层输出的维度计算

        # 定义全连接层
        self.fc1 = paddle.nn.Linear(in_features=self.fc_input_dim, out_features=128)
        self.fc2 = paddle.nn.Linear(in_features=128, out_features=10)  # 输出类别数量为10，适用于MNIST数据集

    def forward(self, inputs):
        x = paddle.to_tensor(inputs)
        x = paddle.reshape(x, [-1, 1, 28, 28])
        # x = paddle.unsqueeze(x, axis=1)  # Add channel dimension
        x = self.conv1(x)
        x = paddle.nn.functional.relu(x)
        x = self.pool1(x)

        x = self.conv2(x)
        x = paddle.nn.functional.relu(x)
        x = self.pool2(x)

        x = paddle.flatten(x, start_axis=1)

        x = self.fc1(x)
        x = paddle.nn.functional.relu(x)
        x = self.fc2(x)

        return x


model = MNIST_CNN()


def train(model):
    print('train:')
    model.train()
    # 定义优化器
    # opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
    # opt = paddle.optimizer.Momentum(learning_rate=0.001, momentum=0.9, parameters=model.parameters())
    # opt = paddle.optimizer.Adagrad(learning_rate=0.001, parameters=model.parameters())
    opt = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
    EPOCH_NUM = 40
    total_losses = []  # 存储每个batch的损失值
    for epoch_id in range(EPOCH_NUM):
        print('epoch:', epoch_id)
        for batch_id, data in enumerate(train_loader()):
            images, labels = data
            images = paddle.to_tensor(images).astype('float32')
            labels = paddle.to_tensor(labels).astype('float32')

            images = paddle.reshape(images, [images.shape[0], images.shape[2] * images.shape[3]])

            # 前向计算的过程
            predicts = model(images)
            # Convert labels data type to integer
            labels_int = paddle.cast(labels, dtype='int64')

            # Convert labels to one-hot encoding
            labels_onehot = paddle.nn.functional.one_hot(labels_int, num_classes=10)
            # 计算损失，取一个批次样本损失的平均值

            loss = paddle.nn.functional.square_error_cost(predicts, labels_onehot)
            avg_loss = paddle.mean(loss)

            # 计算预测结果
            probs = paddle.nn.functional.softmax(predicts, axis=1)
            predictions = paddle.argmax(probs, axis=1)
            # 计算准确率
            correct = paddle.sum(paddle.cast(paddle.equal(predictions, labels_int), dtype='float32'))
            accuracy = correct / images.shape[0] * 100

            if batch_id % 200 == 0:
                print("epoch: {}, batch: {}, loss is: {}, accuracy is: {}".format(epoch_id, batch_id,
                                                                                  avg_loss.numpy(),
                                                                                  accuracy.numpy()))


            # 后向传播，更新参数的过程
            avg_loss.backward()
            opt.step()
            opt.clear_grad()
            # 保存每个batch的损失值
            total_losses.append(avg_loss.numpy())


    # 绘制总的损失曲线图
    plt.plot(total_losses)
    plt.xlabel('Batch')
    plt.ylabel('Loss')
    plt.title('Training Loss Curve')
    plt.ylim(0, 0.1)  # 设置y轴范围为0到0.1
    plt.show()


# 创建模型
print("create model:")

# 启动训练过程
train(model)

# 保存模型参数，文件名为modelhn.pdmodel
paddle.save(model.state_dict(), 'C:/Users/lxcqm/Desktop/model/modelhn.pdmodel')
print("模型保存成功，模型参数保存在C:/Users/lxcqm/Desktop/model/modelhn.pdmodel")

# 参数为保存模型参数的文件地址

model_dict = paddle.load('C:/Users/lxcqm/Desktop/model/modelhn.pdmodel')
model.load_dict(model_dict)
model.eval()

test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=0)

for batch_id, data in enumerate(test_loader):
    images, labels = data
    images = paddle.to_tensor(images).astype('float32')
    labels = paddle.to_tensor(labels).astype('float32')

    images = paddle.reshape(images, [images.shape[0], images.shape[2] * images.shape[3]])

    # 前向计算的过程
    predicts = model(images)
    #########################
    # 设置数据读取器，API自动读取MNIST数据测试集
    test_dataset = paddle.vision.datasets.MNIST(mode='test')
    test_data0 = np.array(test_dataset[batch_id][0])
    test_label_0 = np.array(test_dataset[batch_id][1])

    # plt.figure("Image")  # 图像窗口名称
    plt.figure(figsize=(2, 2))
    plt.imshow(test_data0, cmap=plt.cm.binary)
    plt.axis('on')  # 关掉坐标轴为 off
    plt.title('image')  # 图像题目
    plt.show()

    break

# test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=0)

# 打印测试结果
# print("Inference result is {}, the corresponding label is {}".format(predicts, labels))

predicts_np = predicts.numpy()
labels_np = labels.numpy()

print("预测各标签概率:")
print(predicts_np[0])
print("实际标签:", labels_np[0])

# 推理结果向量
predictions = np.array(predicts_np[0])

# 找到概率最高的标签
predicted_label = np.argmax(predictions)
# print(predictions)
print("模型认为概率最高的标签是:", predicted_label)


# for batch_id, data in enumerate(test_loader):
#     images, labels = data
#     images = paddle.to_tensor(images).astype('float32')
#     labels = paddle.to_tensor(labels).astype('float32')
#
#     images = paddle.reshape(images, [images.shape[0], images.shape[2] * images.shape[3]])

total_accuracy = 0.0
total_samples = 0
for batch_id, data in enumerate(test_loader()):
    images, labels = data
    images = paddle.to_tensor(images).astype('float32')
    labels = paddle.to_tensor(labels).astype('float32')

    images = paddle.reshape(images, [images.shape[0], images.shape[2] * images.shape[3]])

    # 前向计算
    predicts = model(images)
    # Convert labels data type to integer
    labels_int = paddle.cast(labels, dtype='int64')

    # Convert labels to one-hot encoding
    labels_onehot = paddle.nn.functional.one_hot(labels_int, num_classes=10)
    # 计算损失，取一个批次样本损失的平均值

    loss = paddle.nn.functional.square_error_cost(predicts, labels_onehot)
    avg_loss = paddle.mean(loss)

    # 计算预测结果
    probs = paddle.nn.functional.softmax(predicts, axis=1)
    predictions = paddle.argmax(probs, axis=1)
    # 计算准确率
    correct = paddle.sum(paddle.cast(paddle.equal(predictions, labels_int), dtype='float32'))
    accuracy = correct / images.shape[0] * 100

    if batch_id % 10 == 0:
        print(" batch: {}, loss is: {}, accuracy is: {}".format( batch_id,
                                                                          avg_loss.numpy(),
                                                                          accuracy.numpy()))
    # 累加准确率值和样本数量
    total_accuracy += accuracy.numpy() * images.shape[0]
    total_samples += images.shape[0]

# 计算平均准确率
accuracy_total = total_accuracy / total_samples

print("- Total Accuracy: {:.5f}%".format(accuracy_total))
Python 深度学习 智能车 考核
Prev:
一.《动手学深度学习》Paddle版笔记-使用Tensor来处理数据
Next:
Python程序控制结构

    • Copyright © 2023 - 2024 tumytime | Powered by Hexo | Theme Bamboo

    Total visits： times |