ConvNeXt实战：使用ConvNeXt实现植物幼苗分类（自创，非官方）(1)

• 使用LayerNorm而不是BatchNorm。

• 倒置瓶颈。图 3 (a) 至 (b) 说明了这些配置。尽管深度卷积层的 FLOPs 增加了，但由于下采样残差块的快捷 1×1 卷积层的 FLOPs 显着减少，这种变化将整个网络的 FLOPs 减少到 4.6G。成绩从 80.5% 提高到 80.6%。在 ResNet-200/Swin-B 方案中，这一步带来了更多的收益（81.9% 到 82.6%），同时也减少了 FLOP。

ConvNeXt残差模块

=======================================================================

残差模块是整个模型的核心。如下图：

代码实现：

class Block(nn.Module):

r"“” ConvNeXt Block. There are two equivalent implementations:

(1) DwConv -> LayerNorm (channels_first) -> 1x1 Conv -> GELU -> 1x1 Conv; all in (N, C, H, W)

(2) DwConv -> Permute to (N, H, W, C); LayerNorm (channels_last) -> Linear -> GELU -> Linear; Permute back

We use (2) as we find it slightly faster in PyTorch

Args:

dim (int): Number of input channels.

drop_path (float): Stochastic depth rate. Default: 0.0

layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6.

“”"

def init(self, dim, drop_path=0., layer_scale_init_value=1e-6):

super().init()

self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim) # depthwise conv

self.norm = LayerNorm(dim, eps=1e-6)

self.pwconv1 = nn.Linear(dim, 4 * dim) # pointwise/1x1 convs, implemented with linear layers

self.act = nn.GELU()

self.pwconv2 = nn.Linear(4 * dim, dim)

self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)),

requires_grad=True) if layer_scale_init_value > 0 else None

self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()

def forward(self, x):

input = x

x = self.dwconv(x)

x = x.permute(0, 2, 3, 1) # (N, C, H, W) -> (N, H, W, C)

x = self.norm(x)

x = self.pwconv1(x)

x = self.act(x)

x = self.pwconv2(x)

if self.gamma is not None:

x = self.gamma * x

x = x.permute(0, 3, 1, 2) # (N, H, W, C) -> (N, C, H, W)

x = input + self.drop_path(x)

return x

数据增强Cutout和Mixup

===========================================================================

ConvNext使用了Cutout和Mixup，为了提高成绩我在我的代码中也加入这两种增强方式。官方使用timm，我没有采用官方的，而选择用torchtoolbox。安装命令：

pip install torchtoolbox

Cutout实现，在transforms中。

from torchtoolbox.transform import Cutout

数据预处理

transform = transforms.Compose([

transforms.Resize((224, 224)),

Cutout(),

transforms.ToTensor(),

transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])

Mixup实现，在train方法中。需要导入包：from torchtoolbox.tools import mixup_data, mixup_criterion

for batch_idx, (data, target) in enumerate(train_loader):

data, target = data.to(device, non_blocking=True), target.to(device, non_blocking=True)

data, labels_a, labels_b, lam = mixup_data(data, target, alpha)

optimizer.zero_grad()

output = model(data)

loss = mixup_criterion(criterion, output, labels_a, labels_b, lam)

loss.backward()

optimizer.step()

print_loss = loss.data.item()

项目结构

===============================================================

使用tree命令，打印项目结构

ConvNext_demo

├─data

│ ├─test

│ └─train

│ ├─Black-grass

│ ├─Charlock

│ ├─Cleavers

│ ├─Common Chickweed

│ ├─Common wheat

│ ├─Fat Hen

│ ├─Loose Silky-bent

│ ├─Maize

│ ├─Scentless Mayweed

│ ├─Shepherds Purse

│ ├─Small-flowered Cranesbill

│ └─Sugar beet

├─dataset

│ ├─ init.py

│ └─ dataset.py

├─Model

│ └─convnext.py

├─ test1.py

├─ test2.py

└─ train_connext.py

数据集

==============================================================

数据集选用植物幼苗分类，总共12类。数据集连接如下：

链接：https://pan.baidu.com/s/1TOLSNj9JE4-MFhU0Yv8TNQ

提取码：syng

在工程的根目录新建data文件夹，获取数据集后，将trian和test解压放到data文件夹下面，如下图：

导入模型文件

=================================================================

从官方的链接中找到convnext.py文件，将其放入Model文件夹中。如图：

安装库，并导入需要的库

======================================================================

模型用到了timm库，如果没有需要安装，执行命令：

pip install timm

新建train_connext.py文件，导入所需要的包：

import torch.optim as optim

import torch

import torch.nn as nn

import torch.nn.parallel

import torch.utils.data

import torch.utils.data.distributed

import torchvision.transforms as transforms

from dataset.dataset import SeedlingData

from torch.autograd import Variable

from Model.convnext import convnext_tiny

from torchtoolbox.tools import mixup_data, mixup_criterion

from torchtoolbox.transform import Cutout

设置全局参数

=================================================================

设置使用GPU，设置学习率、BatchSize、epoch等参数。

设置全局参数

modellr = 1e-4

BATCH_SIZE = 8

EPOCHS = 300

DEVICE = torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’)

数据预处理

================================================================

数据处理比较简单，没有做复杂的尝试，有兴趣的可以加入一些处理。

数据预处理

transform = transforms.Compose([

transforms.Resize((224, 224)),

Cutout(),

transforms.ToTensor(),

transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])

transform_test = transforms.Compose([

transforms.Resize((224, 224)),

transforms.ToTensor(),

transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])

数据读取

然后我们在dataset文件夹下面新建 init.py和dataset.py，在mydatasets.py文件夹写入下面的代码：

说一下代码的核心逻辑。

第一步 建立字典，定义类别对应的ID,用数字代替类别。

第二步 在__init__里面编写获取图片路径的方法。测试集只有一层路径直接读取，训练集在train文件夹下面是类别文件夹，先获取到类别，再获取到具体的图片路径。然后使用sklearn中切分数据集的方法，按照7：3的比例切分训练集和验证集。

第三步 在__getitem__方法中定义读取单个图片和类别的方法，由于图像中有位深度32位的，所以我在读取图像的时候做了转换。

代码如下：

coding:utf8

import os

from PIL import Image

from torch.utils import data

from torchvision import transforms as T

from sklearn.model_selection import train_test_split

Labels = {‘Black-grass’: 0, ‘Charlock’: 1, ‘Cleavers’: 2, ‘Common Chickweed’: 3,

‘Common wheat’: 4, ‘Fat Hen’: 5, ‘Loose Silky-bent’: 6, ‘Maize’: 7, ‘Scentless Mayweed’: 8,

‘Shepherds Purse’: 9, ‘Small-flowered Cranesbill’: 10, ‘Sugar beet’: 11}

class SeedlingData(data.Dataset):

def init(self, root, transforms=None, train=True, test=False):

“”"

主要目标： 获取所有图片的地址，并根据训练，验证，测试划分数据

“”"

self.test = test

self.transforms = transforms

if self.test:

imgs = [os.path.join(root, img) for img in os.listdir(root)]

self.imgs = imgs

else:

imgs_labels = [os.path.join(root, img) for img in os.listdir(root)]

imgs = []

for imglable in imgs_labels:

for imgname in os.listdir(imglable):

imgpath = os.path.join(imglable, imgname)

imgs.append(imgpath)

trainval_files, val_files = train_test_split(imgs, test_size=0.3, random_state=42)

if train:

self.imgs = trainval_files

else:

self.imgs = val_files

def getitem(self, index):

“”"

一次返回一张图片的数据

“”"

img_path = self.imgs[index]

img_path = img_path.replace(“\”, ‘/’)

if self.test:

label = -1

else:

labelname = img_path.split(‘/’)[-2]

label = Labels[labelname]

data = Image.open(img_path).convert(‘RGB’)

data = self.transforms(data)

return data, label

def len(self):

return len(self.imgs)

然后我们在train.py调用SeedlingData读取数据 ，记着导入刚才写的dataset.py(from mydatasets import SeedlingData)

读取数据

dataset_train = SeedlingData(‘data/train’, transforms=transform, train=True)

dataset_test = SeedlingData(“data/train”, transforms=transform_test, train=False)

导入数据

train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=False)

设置模型

===============================================================

设置loss函数为nn.CrossEntropyLoss()。

• 设置模型为coatnet_0，修改最后一层全连接输出改为12（数据集的类别）。

• 优化器设置为adam。

• 学习率调整策略改为余弦退火

实例化模型并且移动到GPU

criterion = nn.CrossEntropyLoss()

#criterion = SoftTargetCrossEntropy()

model_ft = convnext_tiny(pretrained=True)

num_ftrs = model_ft.head.in_features

model_ft.head = nn.Linear(num_ftrs, 12)

model_ft.to(DEVICE)

print(model_ft)

选择简单暴力的Adam优化器，学习率调低

optimizer = optim.Adam(model_ft.parameters(), lr=modellr)

cosine_schedule = optim.lr_scheduler.CosineAnnealingLR(optimizer=optimizer,T_max=20,eta_min=1e-9)

定义训练和验证函数

最后

不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~

给大家准备的学习资料包括但不限于：

Python 环境、pycharm编辑器/永久激活/翻译插件

python 零基础视频教程

Python 界面开发实战教程

Python 爬虫实战教程

Python 数据分析实战教程

python 游戏开发实战教程

Python 电子书100本

Python 学习路线规划

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！