# 使用卷积神经网络进行图像分类¶

## 一、环境配置¶

[7]:

import paddle
import paddle.nn.functional as F
from paddle.vision.transforms import ToTensor
import numpy as np
import matplotlib.pyplot as plt


2.1.0


## 二、加载数据集¶

[8]:

transform = ToTensor()
transform=transform)
transform=transform)


## 三、组建网络¶

[9]:

class MyNet(paddle.nn.Layer):
def __init__(self, num_classes=1):
super(MyNet, self).__init__()

self.conv1 = paddle.nn.Conv2D(in_channels=3, out_channels=32, kernel_size=(3, 3))
self.pool1 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

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

self.conv3 = paddle.nn.Conv2D(in_channels=64, out_channels=64, kernel_size=(3,3))

self.linear1 = paddle.nn.Linear(in_features=1024, out_features=64)
self.linear2 = paddle.nn.Linear(in_features=64, out_features=num_classes)

def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.pool1(x)

x = self.conv2(x)
x = F.relu(x)
x = self.pool2(x)

x = self.conv3(x)
x = F.relu(x)

x = self.flatten(x)
x = self.linear1(x)
x = F.relu(x)
x = self.linear2(x)
return x


## 四、模型训练&预测¶

[10]:

epoch_num = 10
batch_size = 32
learning_rate = 0.001

[6]:

val_acc_history = []
val_loss_history = []

def train(model):
print('start training ... ')
# turn into training mode
model.train()

parameters=model.parameters())

shuffle=True,
batch_size=batch_size)

for epoch in range(epoch_num):
for batch_id, data in enumerate(train_loader()):
x_data = data[0]
y_data = paddle.unsqueeze(y_data, 1)

logits = model(x_data)
loss = F.cross_entropy(logits, y_data)

if batch_id % 1000 == 0:
print("epoch: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, loss.numpy()))
loss.backward()
opt.step()

# evaluate model after one epoch
model.eval()
accuracies = []
losses = []
for batch_id, data in enumerate(valid_loader()):
x_data = data[0]
y_data = paddle.unsqueeze(y_data, 1)

logits = model(x_data)
loss = F.cross_entropy(logits, y_data)
acc = paddle.metric.accuracy(logits, y_data)
accuracies.append(acc.numpy())
losses.append(loss.numpy())

avg_acc, avg_loss = np.mean(accuracies), np.mean(losses)
print("[validation] accuracy/loss: {}/{}".format(avg_acc, avg_loss))
val_acc_history.append(avg_acc)
val_loss_history.append(avg_loss)
model.train()

model = MyNet(num_classes=10)
train(model)

start training ...
epoch: 0, batch_id: 0, loss is: [2.7625809]

[ ]:

plt.plot(val_acc_history, label = 'validation accuracy')

plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0.5, 0.8])
plt.legend(loc='lower right')

<matplotlib.legend.Legend at 0x12c3686d0>