增加卷积神经网络进行图像分类的层数

经过学习发现，下一层的in_channels只需要和上一层的out_channels保持一致即可，并不是规定或计算得到的数值。

 

 

代码如下：

import paddle

import paddle.nn.functional as F

from paddle.vision.transforms import ToTensor

import numpy as np

import matplotlib.pyplot as plt

transform = ToTensor()

cifar10_train = paddle.vision.datasets.Cifar10(mode='train',

                                               transform=transform)

cifar10_test = paddle.vision.datasets.Cifar10(mode='test',

                                              transform=transform)

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=(2,2))

        self.pool1 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

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

        self.pool2 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

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

        self.pool3 = paddle.nn.MaxPool2D(kernel_size=2, stride=2)

        self.conv4 = paddle.nn.Conv2D(in_channels=64, out_channels=128, kernel_size=(2,2))

        self.flatten = paddle.nn.Flatten()

        self.linear1 = paddle.nn.Linear(in_features=512, 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.pool3(x)

        x = self.conv4(x)

        x = F.relu(x)

        x = self.flatten(x)

        x = self.linear1(x)

        x = F.relu(x)

        x = self.linear2(x)

        return x

epoch_num = 10

batch_size = 32

learning_rate = 0.001

val_acc_history = []

val_loss_history = []

def train(model):

    print('start training ... ')

    model.train()

    opt = paddle.optimizer.Adam(learning_rate=learning_rate,

                                parameters=model.parameters())

    train_loader = paddle.io.DataLoader(cifar10_train,

                                        shuffle=True,

                                        batch_size=batch_size)

    valid_loader = paddle.io.DataLoader(cifar10_test, 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.to_tensor(data[1])

            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()

            opt.clear_grad()

        model.eval()

        accuracies = []

        losses = []

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

            x_data = data[0]

            y_data = paddle.to_tensor(data[1])

            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)

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')