rock数据集ResNet34实现「建议收藏」

rock数据集ResNet34实现「建议收藏」1.搭建ResNet网络Resnet_model.py#-*-coding:utf-8-*-importtorch.nnasnnimporttorchclassBasicBlock(nn.Module):expansion=1def__init__(self,in_channel,out_channel,stride=1,downsample=None,**kwargs):super(BasicBlock,self).

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

1.搭建ResNet网络

Resnet_model.py

# -*-coding:utf-8-*-

import torch.nn as nn
import torch


class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        out += identity
        out = self.relu(out)

        return out


class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, in_channel, out_channel, stride=1, downsample=None,
                 groups=1, width_per_group=64):
        super(Bottleneck, self).__init__()

        width = int(out_channel * (width_per_group / 64.)) * groups

        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,
                               kernel_size=1, stride=1, bias=False)  # squeeze channels
        self.bn1 = nn.BatchNorm2d(width)
        # -----------------------------------------
        self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,
                               kernel_size=3, stride=stride, bias=False, padding=1)
        self.bn2 = nn.BatchNorm2d(width)
        # -----------------------------------------
        self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel*self.expansion,
                               kernel_size=1, stride=1, bias=False)  # unsqueeze channels
        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        out += identity
        out = self.relu(out)

        return out


class ResNet(nn.Module):

    def __init__(self,
                 block,
                 blocks_num,
                 num_classes=1000,
                 include_top=True,
                 groups=1,
                 width_per_group=64):
        super(ResNet, self).__init__()
        self.include_top = include_top
        self.in_channel = 64

        self.groups = groups
        self.width_per_group = width_per_group

        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
                               padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channel)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, blocks_num[0])
        self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
        self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
        self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
        if self.include_top:
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)
            self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')

    def _make_layer(self, block, channel, block_num, stride=1):
        downsample = None
        if stride != 1 or self.in_channel != channel * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(channel * block.expansion))

        layers = []
        layers.append(block(self.in_channel,
                            channel,
                            downsample=downsample,
                            stride=stride,
                            groups=self.groups,
                            width_per_group=self.width_per_group))
        self.in_channel = channel * block.expansion

        for _ in range(1, block_num):
            layers.append(block(self.in_channel,
                                channel,
                                groups=self.groups,
                                width_per_group=self.width_per_group))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        if self.include_top:
            x = self.avgpool(x)
            x = torch.flatten(x, 1)
            x = self.fc(x)

        return x


def resnet34(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnet34-333f7ec4.pth
    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)


def resnet50(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnet50-19c8e357.pth
    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)


def resnet101(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnet101-5d3b4d8f.pth
    return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes, include_top=include_top)


def resnext50_32x4d(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth
    groups = 32
    width_per_group = 4
    return ResNet(Bottleneck, [3, 4, 6, 3],
                  num_classes=num_classes,
                  include_top=include_top,
                  groups=groups,
                  width_per_group=width_per_group)


def resnext101_32x8d(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth
    groups = 32
    width_per_group = 8
    return ResNet(Bottleneck, [3, 4, 23, 3],
                  num_classes=num_classes,
                  include_top=include_top,
                  groups=groups,
                  width_per_group=width_per_group)

2.导入ResNet34参数

官网下载后,放在同一文件夹中。

3.训练网络

Resnet_train.py

# -*-coding:utf-8-*-
import os
import json

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets
from tqdm import tqdm

from Resnet_model import resnet34
import torchvision.models.resnet

def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("using {} device.".format(device))

    data_transform = { 
   
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
        "val": transforms.Compose([transforms.Resize(256),
                                   transforms.CenterCrop(224),
                                   transforms.ToTensor(),
                                   transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}

    data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
    image_path = os.path.join(data_root,"data_mining","data_set")  # flower data set path
    assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
                                         transform=data_transform["train"])
    train_num = len(train_dataset)


    rock_list = train_dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in rock_list.items())
    # write dict into json file
    json_str = json.dumps(cla_dict, indent=4)
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)

    batch_size = 5
    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    print('Using {} dataloader workers every process'.format(nw))

    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=batch_size, shuffle=True,
                                               num_workers=nw)

    validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
                                            transform=data_transform["val"])
    val_num = len(validate_dataset)
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=batch_size, shuffle=False,
                                                  num_workers=nw)

    print("using {} images for training, {} images for validation.".format(train_num,
                                                                           val_num))

    net = resnet34()
    # load pretrain weights
    # download url: https://download.pytorch.org/models/resnet34-333f7ec4.pth
    model_weight_path = "./resnet34-pre.pth"
    assert os.path.exists(model_weight_path), "file {} does not exist.".format(model_weight_path)
    net.load_state_dict(torch.load(model_weight_path, map_location=device))
    # for param in net.parameters():
    # param.requires_grad = False

    # change fc layer structure
    in_channel = net.fc.in_features
    net.fc = nn.Linear(in_channel, 7)
    net.to(device)

    # define loss function
    loss_function = nn.CrossEntropyLoss()

    # construct an optimizer
    params = [p for p in net.parameters() if p.requires_grad]
    optimizer = optim.Adam(params, lr=0.0001)

    epochs = 10
    best_acc = 0.0
    save_path = './resNet34.pth'
    train_steps = len(train_loader)
    for epoch in range(epochs):
        # train
        net.train()
        running_loss = 0.0
        train_bar = tqdm(train_loader)
        for step, data in enumerate(train_bar):
            images, labels = data
            optimizer.zero_grad()
            logits = net(images.to(device))
            loss = loss_function(logits, labels.to(device))
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()

            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
                                                                     epochs,
                                                                     loss)

        # validate
        net.eval()
        acc = 0.0  # accumulate accurate number / epoch
        with torch.no_grad():
            val_bar = tqdm(validate_loader)
            for val_data in val_bar:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                # loss = loss_function(outputs, test_labels)
                predict_y = torch.max(outputs, dim=1)[1]
                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()

                val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1,
                                                           epochs)

        val_accurate = acc / val_num
        print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' %
              (epoch + 1, running_loss / train_steps, val_accurate))

        if val_accurate > best_acc:
            best_acc = val_accurate
            torch.save(net.state_dict(), save_path)

    print('Finished Training')


if __name__ == '__main__':
    main()

4.训练结果

C:\ProgramData\Anaconda3\envs\pytorch\python.exe C:/Users/pythonProject/data_mining/ResNet/Resnet_train.py
using cpu device.
Using 5 dataloader workers every process
using 12600 images for training, 1400 images for validation.
train epoch[1/10] loss:0.972100%|██████████| 2520/2520 [1:30:58<00:00,  2.14s/it]
valid epoch[1/10]100%|██████████| 280/280 [02:21<00:00,  2.03it/s]
[epoch 1] train_loss: 0.904  val_accuracy: 0.874
train epoch[2/10] loss:0.833100%|██████████| 2520/2520 [1:33:16<00:00,  2.17s/it]
valid epoch[2/10]100%|██████████| 280/280 [02:22<00:00,  2.06it/s]
  0%|          | 0/2520 [00:00<?, ?it/s][epoch 2] train_loss: 0.665  val_accuracy: 0.791
train epoch[3/10] loss:0.884100%|██████████| 2520/2520 [1:30:23<00:00,  2.12s/it]
valid epoch[3/10]100%|██████████| 280/280 [02:20<00:00,  2.07it/s]
[epoch 3] train_loss: 0.588  val_accuracy: 0.938
train epoch[4/10] loss:0.507100%|██████████| 2520/2520 [1:31:15<00:00,  2.15s/it]
valid epoch[4/10]100%|██████████| 280/280 [02:18<00:00,  2.19it/s]
[epoch 4] train_loss: 0.509  val_accuracy: 0.939
train epoch[5/10] loss:0.344100%|██████████| 2520/2520 [1:30:26<00:00,  2.15s/it]
valid epoch[5/10]100%|██████████| 280/280 [02:21<00:00,  2.03it/s]
[epoch 5] train_loss: 0.462  val_accuracy: 0.945
train epoch[6/10] loss:0.258100%|██████████| 2520/2520 [1:30:19<00:00,  2.15s/it]
valid epoch[6/10]100%|██████████| 280/280 [02:19<00:00,  2.12it/s]
[epoch 6] train_loss: 0.416  val_accuracy: 0.874
train epoch[7/10] loss:0.097100%|██████████| 2520/2520 [1:30:09<00:00,  2.11s/it]
valid epoch[7/10]100%|██████████| 280/280 [02:17<00:00,  2.14it/s]
  0%|          | 0/2520 [00:00<?, ?it/s][epoch 7] train_loss: 0.382  val_accuracy: 0.933
train epoch[8/10] loss:0.156100%|██████████| 2520/2520 [1:30:48<00:00,  2.17s/it]
valid epoch[8/10]100%|██████████| 280/280 [02:22<00:00,  2.03it/s]
  0%|          | 0/2520 [00:00<?, ?it/s][epoch 8] train_loss: 0.337  val_accuracy: 0.938
train epoch[9/10] loss:0.284100%|██████████| 2520/2520 [1:31:23<00:00,  2.27s/it]
valid epoch[9/10]100%|██████████| 280/280 [02:23<00:00,  2.09it/s]
[epoch 9] train_loss: 0.319  val_accuracy: 0.961
train epoch[10/10] loss:0.248100%|██████████| 2520/2520 [1:35:54<00:00,  2.26s/it]
valid epoch[10/10]100%|██████████| 280/280 [02:32<00:00,  1.92it/s]
[epoch 10] train_loss: 0.299  val_accuracy: 0.974
Finished Training

在这里插入图片描述
在这里插入图片描述

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/188766.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • Platform Device and Drivers

    Platform Device and DriversPlatformDeviceandDrivers从我们可以了解Platformbus上面的驱动模型接口:platform_device,platform_driver。和PCI和USB这些大结构的总线不同,虚拟总线Platformbus使用最小结构来集成SOCpro

  • deepfakes视频的网站_deepfakes视频的网站[通俗易懂]

    deepfakes视频的网站_deepfakes视频的网站[通俗易懂]{“optioninfo”:{“dynamic”:”true”,”static”:”true”},”simplifiedDisplay”:”newEdition”,”newCard”:[{“link”:”https://www.aliyun.com/product/live”,”icon”:”live”,”title”:”视频直播LIVE”,”des”:”视频直播(ApsaraVideoLive…

  • 二叉树进行中序遍历的结果_层次遍历和中序遍历构建二叉树

    二叉树进行中序遍历的结果_层次遍历和中序遍历构建二叉树目录1.二叉树1.中序遍历1.二叉树1.中序遍历不论是二叉树、二叉排序树(搜索树),遍历是基础。至于什么是中序遍历,中规中矩的理论,可以参考这篇文章,二叉树中序遍历(递归+非递归)Java.,其中详细介绍了中序遍历实现的方法和结果,包括递归和非递归两种方式。…

  • Ubuntu安装gcc4.1.2

    Ubuntu安装gcc4.1.2安装之前,系统中必须要有cc或者gcc等编译器,并且是可用的,或者用环境变量CC指定系统上的编译器。如果系统上没有编译器,不能安装源代码形式的GCC4.1.2。如果是这种情况,可以在网上找一个与你系统相适应的如RPM等二进制形式的GCC软件包来安装使用。本文介绍的是以源代码形式提供的GCC软件包的安装过程,软件包本身和其安装过程同样适用于其它Linux和Unix系统。系统上原来的GCC编译…

  • HTTP500内部服务器错误_服务器内部错误500

    HTTP500内部服务器错误_服务器内部错误500解决运行.asp出现“http500内部服务器错误”及“数据库连接出错,请检查Conn.asp文件中的数据库参数设置。”问题经过N久的尝试,终于解决了winXP不能运行.asp的问题了…..1、运行.asp出现“http500内部服务器错误”出现这个问题的主要原因是因为MSDTC启动失败,解决方法:[1]:检查你的DTC服务(全…

  • 彻底明白vue双向绑定底层原理(源码分析)

    彻底明白vue双向绑定底层原理(源码分析)vue是一个mvvm框架,双向绑定是vue的一个核心功能,所谓双向绑定就是当试图发生改变的时候传递给VM(ViewModel),让数据得到更新,当数据发生改变的时候传给VM(ViewModel),使得视图发生变化!概念都知道,但是vue怎么做到的呢?看下面的一张图(图是搬运别人的)可能你现在看不明白,observer是什么东西,watchter,Dep又是什么东西?没有关系,接下来只要你看完我这篇文章,保证给你整的明明白白!看上图,从左边开始newMVVM其实就是我newVue(),我们一

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号