項目簡介

目的： 實現(xiàn)昆蟲的圖像分類，同時該模型也可以用于其他圖像的分類識別，只需傳入相應(yīng)的訓(xùn)練集進行訓(xùn)練，保存為另一個模型即可，進行調(diào)用使用。
配置環(huán)境： pycharm（python3.7），導(dǎo)入pytotch庫
知識預(yù)備： 需要了解卷積神經(jīng)網(wǎng)絡(luò)的基本原理與結(jié)構(gòu)，熟悉pytorch的使用，csdn有很多介紹卷積神經(jīng)網(wǎng)絡(luò)的文章，可查閱。
例如：

https://blog.csdn.net/yunpiao123456/article/details/52437794
https://blog.csdn.net/weipf8/article/details/103917202

算法設(shè)計思路：
（1） 收集數(shù)據(jù)集，利用 python 的 requests 庫和 bs4 進行網(wǎng)絡(luò)爬蟲，下載數(shù)據(jù)集
（2） 搭建卷積神經(jīng)網(wǎng)絡(luò)
（3）對卷積神經(jīng)網(wǎng)絡(luò)進行訓(xùn)練
（4） 改進訓(xùn)練集與測試集，并擴大數(shù)據(jù)集
（5） 保存模型
（6） 調(diào)用模型進行測試

項目效果展示

注，模型我達到的最高正確率在85%，最后穩(wěn)定在79%，中間出現(xiàn)了過擬合，可減少訓(xùn)練次數(shù)進行優(yōu)化，數(shù)據(jù)集較少的情況下，建議訓(xùn)練10次就可。

程序運行流程圖

代碼使用說明

先訓(xùn)練模型，進行模型保存之后可對模型進行調(diào)用，不用每使用一次模型就要進行訓(xùn)練。文末有項目的完整代碼：修改自己的數(shù)據(jù)集src位置，一般情況下能正常運行，如果不能，請檢查自己的第三方庫是否成功安裝，以及是否成功導(dǎo)入。若有問題可以私信交流學(xué)習(xí)。

數(shù)據(jù)集準(zhǔn)備

注：由于爬蟲，會有一些干擾數(shù)據(jù)，所以我這里展示的是進行數(shù)據(jù)清洗之后的數(shù)據(jù)。
注：訓(xùn)練集：測試集=7：3（可自己修改）
注：若正確率不理想，可擴大數(shù)據(jù)集，數(shù)據(jù)清洗，圖片處理等方面進行改進

訓(xùn)練集

部分?jǐn)?shù)據(jù)展示

測試集

文件格式與訓(xùn)練集一樣。

搭建神經(jīng)網(wǎng)絡(luò)

框架：

結(jié)構(gòu)：

代碼實現(xiàn)：

# 定義網(wǎng)絡(luò)
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.max_pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.max_pool2 = nn.MaxPool2d(2)
        self.conv3 = nn.Conv2d(64, 64, 3)
        self.conv4 = nn.Conv2d(64, 64, 3)
        self.max_pool3 = nn.MaxPool2d(2)
        self.conv5 = nn.Conv2d(64, 128, 3)
        self.conv6 = nn.Conv2d(128, 128, 3)
        self.max_pool4 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(4608, 512)
        self.fc2 = nn.Linear(512, 1)

    def forward(self, x):
        in_size = x.size(0)
        x = self.conv1(x)
        x = F.relu(x)
        x = self.max_pool1(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.max_pool2(x)
        x = self.conv3(x)
        x = F.relu(x)
        x = self.conv4(x)
        x = F.relu(x)
        x = self.max_pool3(x)
        x = self.conv5(x)
        x = F.relu(x)
        x = self.conv6(x)
        x = F.relu(x)
        x = self.max_pool4(x)
        # 展開
        x = x.view(in_size, -1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = torch.sigmoid(x)
        return x

訓(xùn)練函數(shù)

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):

        data, target = data.to(device), target.to(device).float().unsqueeze(1)

        optimizer.zero_grad()

        output = model(data)

        # print(output)

        loss = F.binary_cross_entropy(output, target)

        loss.backward()

        optimizer.step()

        if (batch_idx + 1) % 1 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(

                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),

                       100. * (batch_idx + 1) / len(train_loader), loss.item()))

測試函數(shù)

def test(model, device, test_loader):
    model.eval()

    test_loss = 0

    correct = 0

    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device).float().unsqueeze(1)
            # print(target)
            output = model(data)
            # print(output)
            test_loss += F.binary_cross_entropy(output, target, reduction='mean').item()
            pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in output]).to(device)
            correct += pred.eq(target.long()).sum().item()

        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))

模型-訓(xùn)練過程完整代碼

模型保存使用的是torch.save(model，src),model即須保存的模型，src即模型保存的位置，后綴為pth

import torch.nn.functional as F
import torch.optim as optim
import torch
import torch.nn as nn
import torch.nn.parallel
from PIL import Image
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
import torchvision.datasets as datasets


# 設(shè)置超參數(shù)
#每次的個數(shù)
BATCH_SIZE = 20
#迭代次數(shù)
EPOCHS = 10
#采用cpu還是gpu進行計算
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 數(shù)據(jù)預(yù)處理

transform = transforms.Compose([
    transforms.Resize(100),
    transforms.RandomVerticalFlip(),
    transforms.RandomCrop(50),
    transforms.RandomResizedCrop(150),
    transforms.ColorJitter(brightness=0.5, contrast=0.5, hue=0.5),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
#導(dǎo)入訓(xùn)練數(shù)據(jù)
dataset_train = datasets.ImageFolder('D:\\cnn_net\\train\\insects', transform)

#導(dǎo)入測試數(shù)據(jù)
dataset_test = datasets.ImageFolder('D:\\cnn_net\\train\\test', transform)

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

# print(dataset_train.imgs)
# print(dataset_train[0])
# print(dataset_train.classes)
classess=dataset_train.classes #標(biāo)簽
class_to_idxes=dataset_train.class_to_idx #對應(yīng)關(guān)系
print(class_to_idxes)
# print(dataset_train.class_to_idx)

train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)
# for batch_idx, (data, target) in enumerate(train_loader):
#     # print(data)
#     print(target)
#     data, target = data.to(device), target.to(device).float().unsqueeze(1)
#     # print(data)
#     print(target)

# 定義網(wǎng)絡(luò)
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.max_pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.max_pool2 = nn.MaxPool2d(2)
        self.conv3 = nn.Conv2d(64, 64, 3)
        self.conv4 = nn.Conv2d(64, 64, 3)
        self.max_pool3 = nn.MaxPool2d(2)
        self.conv5 = nn.Conv2d(64, 128, 3)
        self.conv6 = nn.Conv2d(128, 128, 3)
        self.max_pool4 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(4608, 512)
        self.fc2 = nn.Linear(512, 1)

    def forward(self, x):
        in_size = x.size(0)
        x = self.conv1(x)
        x = F.relu(x)
        x = self.max_pool1(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.max_pool2(x)
        x = self.conv3(x)
        x = F.relu(x)
        x = self.conv4(x)
        x = F.relu(x)
        x = self.max_pool3(x)
        x = self.conv5(x)
        x = F.relu(x)
        x = self.conv6(x)
        x = F.relu(x)
        x = self.max_pool4(x)
        # 展開
        x = x.view(in_size, -1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = torch.sigmoid(x)
        return x

modellr = 1e-4

# 實例化模型并且移動到GPU

model = ConvNet().to(device)
print(model)
# 選擇簡單暴力的Adam優(yōu)化器，學(xué)習(xí)率調(diào)低

optimizer = optim.Adam(model.parameters(), lr=modellr)
#調(diào)整學(xué)習(xí)率
def adjust_learning_rate(optimizer, epoch):
    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
    modellrnew = modellr * (0.1 ** (epoch // 5))
    print("lr:", modellrnew)
    for param_group in optimizer.param_groups:
        param_group['lr'] = modellrnew

# 定義訓(xùn)練過程
def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):

        data, target = data.to(device), target.to(device).float().unsqueeze(1)

        optimizer.zero_grad()

        output = model(data)

        # print(output)

        loss = F.binary_cross_entropy(output, target)

        loss.backward()

        optimizer.step()

        if (batch_idx + 1) % 1 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(

                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),

                       100. * (batch_idx + 1) / len(train_loader), loss.item()))

def test(model, device, test_loader):
    model.eval()

    test_loss = 0

    correct = 0

    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device).float().unsqueeze(1)
            # print(target)
            output = model(data)
            # print(output)
            test_loss += F.binary_cross_entropy(output, target, reduction='mean').item()
            pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in output]).to(device)
            correct += pred.eq(target.long()).sum().item()

        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))




# 訓(xùn)練
for epoch in range(1, EPOCHS + 1):
    adjust_learning_rate(optimizer, epoch)
    train(model, device, train_loader, optimizer, epoch)
    test(model, device, test_loader)

torch.save(model, 'D:\\cnn_net\\datas\\model_insects.pth')

模型-調(diào)用完整代碼

模型調(diào)用使用，torch.load(src)

from PIL import Image

from torchvision import transforms
import torch.nn.functional as F

import torch
import torch.nn as nn
import torch.nn.parallel


# 定義網(wǎng)絡(luò)
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.max_pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.max_pool2 = nn.MaxPool2d(2)
        self.conv3 = nn.Conv2d(64, 64, 3)
        self.conv4 = nn.Conv2d(64, 64, 3)
        self.max_pool3 = nn.MaxPool2d(2)
        self.conv5 = nn.Conv2d(64, 128, 3)
        self.conv6 = nn.Conv2d(128, 128, 3)
        self.max_pool4 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(4608, 512)
        self.fc2 = nn.Linear(512, 1)

    def forward(self, x):
        in_size = x.size(0)
        x = self.conv1(x)
        x = F.relu(x)
        x = self.max_pool1(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.max_pool2(x)
        x = self.conv3(x)
        x = F.relu(x)
        x = self.conv4(x)
        x = F.relu(x)
        x = self.max_pool3(x)
        x = self.conv5(x)
        x = F.relu(x)
        x = self.conv6(x)
        x = F.relu(x)
        x = self.max_pool4(x)
        # 展開
        x = x.view(in_size, -1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = torch.sigmoid(x)
        return x


# 模型存儲路徑
# model_save_path = 'E:\\Cat_And_Dog\\kaggle\\model_insects.pth'

# ------------------------ 加載數(shù)據(jù) --------------------------- #
# Data augmentation and normalization for training
# Just normalization for validation
# 定義預(yù)訓(xùn)練變換
# 數(shù)據(jù)預(yù)處理


class_names = ['瓢蟲','螳螂',]  # 這個順序很重要，要和訓(xùn)練時候的類名順序一致

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# ------------------------ 載入模型并且訓(xùn)練 --------------------------- #
model = torch.load('D:\\cnn_net\\datas\\model_insects.pth')
model.eval()
# print(model)38，49

# image_PIL = Image.open('D:\\cnn_net\\train\\insects\\螳螂\\t28.jpg')
image_PIL = Image.open('D:\\cnn_net\\train\\insects\\瓢蟲\\p49.jpg')
# image_PIL = Image.open('D:\\cnn_net\\train\\test\\01.jpg')
transform_test = transforms.Compose([
    transforms.Resize(100),
    transforms.RandomVerticalFlip(),
    transforms.RandomCrop(50),
    transforms.RandomResizedCrop(150),
    transforms.ColorJitter(brightness=0.5, contrast=0.5, hue=0.5),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
    ])

image_tensor = transform_test(image_PIL)
    # 以下語句等效于 image_tensor = torch.unsqueeze(image_tensor, 0)
image_tensor.unsqueeze_(0)
    # 沒有這句話會報錯
image_tensor = image_tensor.to(device)

out = model(image_tensor)
# print(out)
pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in out]).to(device)
print(class_names[pred])

注

有錯誤的地方歡迎大家交流學(xué)習(xí)，進行指正，一起學(xué)習(xí)進步。文章來源地址http://www.zghlxwxcb.cn/news/detail-405625.html

到了這里，關(guān)于卷積神經(jīng)網(wǎng)絡(luò)實現(xiàn)圖像識別的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！