首页 > 营销学院 > AI智能

DataFountain-FashionMNIST：CNN基础准确率0.85

图像分类（image classification）是计算机视觉领域中最简单最基础的任务，学习研究图像分类是每个计算机视觉研究者的必经之路，图像分类网络也是很多更复杂任务（如目标检测、语义分割等）算法的基础。本练习赛旨在让选手们用图像分类任务来以赛代练、熟悉深度学习框架和比赛流程。

☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜

赛题介绍

赛题背景

图像分类（image classification）是计算机视觉领域中最简单最基础的任务，学习研究图像分类是每个计算机视觉研究者的必经之路，图像分类网络也是很多更复杂任务（如目标检测、语义分割等）算法的基础。本练习赛旨在让选手们用图像分类任务来以赛代练、熟悉深度学习框架和比赛流程。

在图像分类学习中，MNIST数据集常被用来作为入门教学数据集。但是，MNIST数据集存在一些问题：首先，MNIST数据集对于现在的卷积神经网络来说过于简单，SOTA模型的分类精度达到了99.84%，甚至传统机器学习方法也能达到97%的精度，因此模型的精度在此达到了饱和，几乎没有提升的空间；再者，有些专家对MNIST数据集提出了质疑，比如谷歌的深度学习专家、Keras的作者François Chollet曾表示：“MNIST存在很多问题，但最重要的是，它真的不具有计算机视觉任务的代表性。”并补充道：“很多好点子（比如batch norm）在MNIST上效果差，但相反的，一些差的方法可能在MNIST产生好效果，却不能迁移到真实计算机视觉任务中。”

数据说明

本练习赛采用和MNIST同等规模但更有难度的数据集Fashion-MNIST（github链接：https://github.com/zalandoresearch/fashion-mnist），Fashion-MNIST由60000张训练集图像、10000张测试集图像及对应的标签构成，每张图像是分辨率为28x28的灰度图像，包含10种分类：T恤、裤子、套头衫、连衣裙、大衣、凉鞋、衬衫、运动鞋、包、短靴。

本练习赛的参赛者可以使用Tensorflow、Keras、Pytorch、Paddlepaddle等开源深度学习框架来进行模型的搭建、训练和预测。

In [1]

import pandas as pdimport numpy as np# 数据读取train_df = pd.read_csv('fashion-mnist_train.csv')
test_df = pd.read_csv('fashion-mnist_test_data.csv')

In [2]

train_df.head()

   label  pixel1  pixel2  pixel3  pixel4  pixel5  pixel6  pixel7  pixel8  \
0      2       0       0       0       0       0       0       0       0   
1      9       0       0       0       0       0       0       0       0   
2      6       0       0       0       0       0       0       0       5   
3      0       0       0       0       1       2       0       0       0   
4      3       0       0       0       0       0       0       0       0   

   pixel9  ...  pixel775  pixel776  pixel777  pixel778  pixel779  pixel780  \
0       0  ...         0         0         0         0         0         0   
1       0  ...         0         0         0         0         0         0   
2       0  ...         0         0         0        30        43         0   
3       0  ...         3         0         0         0         0         1   
4       0  ...         0         0         0         0         0         0   

   pixel781  pixel782  pixel783  pixel784  
0         0         0         0         0  
1         0         0         0         0  
2         0         0         0         0  
3         0         0         0         0  
4         0         0         0         0  

[5 rows x 785 columns]

数据可视化

In [3]

%pylab inline# 绘制10*10的图片plt.figure(figsize=(10, 10))for idx in range(100):    # 图片尺寸从784 -》 28 * 28
    xy = train_df.iloc[idx].values[1:].reshape(28,28)
    plt.subplot(10, 10, idx+1)    # 展示图片
    plt.imshow(xy, cmap='gray')
    plt.xticks([]); plt.yticks([])

Populating the interactive namespace from numpy and matplotlib

In [4]

import paddle
paddle.__version__

'2.2.0'

数据读取

In [5]

from paddle.io import DataLoader, Datasetfrom PIL import Image# 自定义数据集完成数据读取class MyDataset(Dataset):
    def __init__(self, img, label):
        super(MyDataset, self).__init__()
        self.img = img
        self.label = label    
    def __getitem__(self, index):
        img = self.img[index]        # 对数据集进行归一化
        return img/255, int(self.label[index])    def __len__(self):
        return len(self.label)# 使用5.9w进行训练train_dataset = MyDataset(
    train_df.iloc[:-1000, 1:].values.reshape(59000, 28, 28).astype(np.float32), 
    paddle.to_tensor(train_df.label.iloc[:-1000].values.astype(np.float32))
)
train_loader = DataLoader(train_dataset, batch_size=300, shuffle=True)# 最后1k作为验证集val_dataset = MyDataset(
    train_df.iloc[-1000:, 1:].values.reshape(1000, 28, 28).astype(np.float32), 
    paddle.to_tensor(train_df.label.iloc[-1000:].values.astype(np.float32))
)
val_loader = DataLoader(val_dataset, batch_size=300, shuffle=False)# 最终测试集test_dataset = MyDataset(
    test_df.iloc[:, 1:].values.reshape(10000, 28, 28).astype(np.float32),
    paddle.to_tensor(np.zeros((test_df.shape[0])))
)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

全连接模型

In [6]

# 构建全连接模型，先需要从多维转变为二维model = paddle.nn.Sequential(
    paddle.nn.Flatten(),
    paddle.nn.Linear(28*28,128),
    paddle.nn.LeakyReLU(),
    paddle.nn.Linear(128, 10)
)

paddle.summary(model, (64, 28, 28))

W1207 20:53:04.353837   104 device_context.cc:447] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 10.1, Runtime API Version: 10.1
W1207 20:53:04.359086   104 device_context.cc:465] device: 0, cuDNN Version: 7.6.

---------------------------------------------------------------------------
 Layer (type)       Input Shape          Output Shape         Param #    
===========================================================================
   Flatten-1       [[64, 28, 28]]         [64, 784]              0       
   Linear-1         [[64, 784]]           [64, 128]           100,480    
  LeakyReLU-1       [[64, 128]]           [64, 128]              0       
   Linear-2         [[64, 128]]            [64, 10]            1,290     
===========================================================================
Total params: 101,770
Trainable params: 101,770
Non-trainable params: 0
---------------------------------------------------------------------------
Input size (MB): 0.19
Forward/backward pass size (MB): 0.51
Params size (MB): 0.39
Estimated Total Size (MB): 1.09
---------------------------------------------------------------------------

{'total_params': 101770, 'trainable_params': 101770}

In [7]

# 定义优化器，损失函数optimizer = paddle.optimizer.Adam(parameters=model.parameters(), learning_rate=0.0001)
criterion = paddle.nn.CrossEntropyLoss()# 每个epoch迭代训练#     每个batch -> 正向传播 -> 计算损失 -> 更新参数for epoch in range(0, 5):
    Train_Loss, Val_Loss = [], []
    Train_ACC, Val_ACC = [], []    # 训练部分
    model.train()    for i, (x, y) in enumerate(train_loader):
        pred = model(x)
        loss = criterion(pred, y)
        Train_Loss.append(loss.item())
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()
        Train_ACC.append((pred.numpy().argmax(1) == y.numpy()).mean())        
        if i % 100 == 0:            print(f'{i}/{len(train_loader)}\t Loss {np.mean(Train_Loss):3.5f} {np.mean(Train_ACC):3.5f}')    # 验证部分
    model.eval()    for i, (x, y) in enumerate(val_loader):
        pred = model(x)
        loss = criterion(pred, y)
        Val_Loss.append(loss.item())
        Val_ACC.append((pred.numpy().argmax(1) == y.numpy()).mean())    
    if epoch % 1 == 0:        print(f'\nEpoch: {epoch}')        print(f'Loss {np.mean(Train_Loss):3.5f}/{np.mean(Val_Loss):3.5f}')        print(f'ACC {np.mean(Train_ACC):3.5f}/{np.mean(Val_ACC):3.5f}')

0/197	 Loss 2.33518 0.17000
100/197	 Loss 1.50995 0.55713

Epoch: 0
Loss 1.20884/0.83340
ACC 0.63190/0.71083
0/197	 Loss 0.77190 0.74667
100/197	 Loss 0.73694 0.76122

Epoch: 1
Loss 0.69631/0.65332
ACC 0.77584/0.77250
0/197	 Loss 0.61251 0.80333
100/197	 Loss 0.60704 0.80515

Epoch: 2
Loss 0.59082/0.57583
ACC 0.80878/0.80167
0/197	 Loss 0.52229 0.84333
100/197	 Loss 0.55234 0.81921

Epoch: 3
Loss 0.53963/0.53572
ACC 0.82233/0.80417
0/197	 Loss 0.54005 0.81667
100/197	 Loss 0.51667 0.82782

Epoch: 4
Loss 0.50867/0.50455
ACC 0.83046/0.82083

卷积模型

In [11]

# 卷积模型model = paddle.nn.Sequential(
    paddle.nn.Conv2D(1, 10, (5, 5)),
    paddle.nn.ReLU(),
    paddle.nn.Conv2D(10, 20, (5, 5)),
    paddle.nn.ReLU(),
    paddle.nn.MaxPool2D((2, 2)),

    paddle.nn.Flatten(),
    paddle.nn.Linear(2000, 10),
)

paddle.summary(model, (64, 1, 28, 28))

---------------------------------------------------------------------------
 Layer (type)       Input Shape          Output Shape         Param #    
===========================================================================
   Conv2D-5      [[64, 1, 28, 28]]     [64, 10, 24, 24]         260      
    ReLU-5       [[64, 10, 24, 24]]    [64, 10, 24, 24]          0       
   Conv2D-6      [[64, 10, 24, 24]]    [64, 20, 20, 20]        5,020     
    ReLU-6       [[64, 20, 20, 20]]    [64, 20, 20, 20]          0       
  MaxPool2D-4    [[64, 20, 20, 20]]    [64, 20, 10, 10]          0       
   Flatten-4     [[64, 20, 10, 10]]       [64, 2000]             0       
   Linear-5         [[64, 2000]]           [64, 10]           20,010     
===========================================================================
Total params: 25,290
Trainable params: 25,290
Non-trainable params: 0
---------------------------------------------------------------------------
Input size (MB): 0.19
Forward/backward pass size (MB): 15.40
Params size (MB): 0.10
Estimated Total Size (MB): 15.68
---------------------------------------------------------------------------

{'total_params': 25290, 'trainable_params': 25290}

In [12]

# 优化器与损失函数optimizer = paddle.optimizer.Adam(parameters=model.parameters(), learning_rate=0.0001)
criterion = paddle.nn.CrossEntropyLoss()# 训练部分for epoch in range(0, 5):
    Train_Loss, Val_Loss = [], []
    Train_ACC, Val_ACC = [], []

    model.train()    for i, (x, y) in enumerate(train_loader):
        pred = model(x.reshape((-1, 1, 28, 28)))
        loss = criterion(pred, y)
        Train_Loss.append(loss.item())
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()
        Train_ACC.append((pred.numpy().argmax(1) == y.numpy()).mean())        
        if i % 100 == 0:            print(f'{i}/{len(train_loader)}\t Loss {np.mean(Train_Loss):3.5f} {np.mean(Train_ACC):3.5f}')

    model.eval()    for i, (x, y) in enumerate(val_loader):
        pred = model(x.reshape((-1, 1, 28, 28)))
        loss = criterion(pred, y)
        Val_Loss.append(loss.item())
        Val_ACC.append((pred.numpy().argmax(1) == y.numpy()).mean())    
    if epoch % 1 == 0:        print(f'\nEpoch: {epoch}')        print(f'Loss {np.mean(Train_Loss):3.5f}/{np.mean(Val_Loss):3.5f}')        print(f'ACC {np.mean(Train_ACC):3.5f}/{np.mean(Val_ACC):3.5f}')

0/197	 Loss 2.29863 0.15333
100/197	 Loss 1.61717 0.53125

Epoch: 0
Loss 1.23357/0.74845
ACC 0.62601/0.74167
0/197	 Loss 0.73336 0.76000
100/197	 Loss 0.66099 0.76261

Epoch: 1
Loss 0.63249/0.61879
ACC 0.77187/0.77333
0/197	 Loss 0.56483 0.80000
100/197	 Loss 0.55956 0.79855

Epoch: 2
Loss 0.54548/0.56240
ACC 0.80436/0.79167
0/197	 Loss 0.58850 0.77333
100/197	 Loss 0.51179 0.81703

Epoch: 3
Loss 0.50036/0.52460
ACC 0.82221/0.80583
0/197	 Loss 0.41658 0.86667
100/197	 Loss 0.47553 0.83274

Epoch: 4
Loss 0.47199/0.50074
ACC 0.83300/0.82333

# paddlepaddle # 能在 # 提出了 # 也能 # 在此 # 代练 # 多维 # 最简单 # 达到了 # 必经之路 # 练习赛 # https # git # pytorch # keras # tensorflow # cnn # 算法 # github # batch # igs # red # ai # 谷歌