bobodareng

VGG网络在CIFAR_10和GID数据集上的Pytorch实现

文章目录

- 一、VGG简介
- 二、VGG-16在CIFAR_10数据集上的实现
- - 2.1 CIFAR_10数据集简介
  - 2.2 加载数据集（Dataset)
  - 2.3 模型搭建(Model)
  - 2.4 训练(Train)
  - 2.5 预测（Predict）
- 三、VGG-16在GID数据集上的实现
- - 3.1 Gaofen Image Dataset(GID)数据集简介
  - 3.1 模型搭建(Model)
  - 3.2 训练(Train)
  - 3.3 预测（Predict）

一、VGG简介

$\quad$ $\quad$ VGGNet由牛津大学的视觉几何组（Visual Geometry Group）提出，它的主要贡献是使用非常小的**（ $3 \times 3$ ）卷积滤波器架构对网络深度的增加进行了全面评估，这表明通过将深度推到16-19加权层可以实现对现有技术配置的显著改进**。这些发现让VGG团队在ILSVRC-2014的**定位任务（localisation）**取得第一、**分类任务（classification）**取得第二（第一名是GoogLeNet）。并且作者还表明其提出的ConvNet对于其他数据集泛化的很好，在其它数据集上也取得了最好的结果。

$\quad$ $\quad$ 关于VGG网络详解见我另一篇博文：https://blog.csdn.net/Bobodareng/article/details/117599525

二、VGG-16在CIFAR_10数据集上的实现

2.1 CIFAR_10数据集简介

$\quad$ $\quad$ CIFAR-10 是由 Hinton 的学生 Alex Krizhevsky 和 Ilya Sutskever 整理的一个用于识别普适物体的小型数据集。该数据集共有60000张32*32彩色图像，一共包含 10 个类别的 RGB 彩色图片，每类6000张：

飞机（ airplane ）、汽车（ automobile ）、鸟类（ bird ）、猫（ cat ）、鹿（ deer ）、狗（ dog ）、蛙类（ frog ）、马（ horse ）、船（ ship ）

卡车（ truck ）

$\quad$ $\quad$ 图片的尺寸为 32×32 ，数据集中一共有 50000 张训练图片和 10000 张测试图片。 CIFAR-10 的图片样例如下图所示：

$\quad$ $\quad$ 上图列举了CIFAR_10中的10种类别，每一类随机展示了10张图片。

数据集下载
官方下载地址：（很慢）
（共有三个版本：python,matlab,binary version 适用于C语言），我在训练时直接利用代码从Pytorch.datasets()中下载。
http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz

http://www.cs.toronto.edu/~kriz/cifar-10-matlab.tar.gz

http://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz

2.2 加载数据集（Dataset)

$\quad$ $\quad$ 我们可以手动下载CIFAR_10数据集，也可以用Pytorch的torchvision.datasets模块加载一些经典的数据集，比如：Imagenet, CIFAR10, MNIST都可以通过torchvision来获取，并且torchvision还提供了transforms类可以用来预处理数据。

   import torchvision
    ...
    #利用 torchvision.datasets来下载CIFAR_10数据集到根目录的data文件夹中
    # 50000张训练图片
    # 第一次使用时要将download设置为True才会自动去下载数据集
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                             download=True, transform=transform)
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=128,
                                               shuffle=True, num_workers=0)
     # 10000张验证图片
    第一次使用时要将download设置为True才会自动去下载数据集
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=True, transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=128,
                                             shuffle=True, num_workers=0)
    ...

下载后结果如下图：

（1）数据集划分
$\quad$ $\quad$ 一般来讲数据集可分为训练集（train）、验证集(val)和测试集（test），训练集用于训练，验证集用于验证训练期间的模型精度，测试集用于测试最终模型的表现。通常利用验证集可用来设计一些交叉验证方法，在数据量较少的情况下能够提高模型的鲁棒性，在我的这次任务中只将数据集分为train和val，只是为了观察模型的训练过程，训练完成后测试单张图片。

（2）数据预处理。
$\quad$ $\quad$ 常用数据预处理方法可概述为2类，数据标准化（Normalize）处理和数据增广（Augmentation）。最常用的数据标准化处理就是数据的归一化，原数据可能数据量很大，维数很多，计算机处理起来时间复杂度很高，预处理可以降低数据维度。同时，把数据都规范到（0-1），这样使得它们对模型的影响具有同样的尺度。
$\quad$ $\quad$ 我通过torchvision.transforms中的各类数据处理函数对图像数据进行预处理：
$\quad$ $\quad$ 关于torchvision.transforms的各种算法实现，见我的另一篇博文：
$\quad$ $\quad$ https://blog.csdn.net/Bobodareng/article/details/117597673

import torchvision.transforms as transforms
#数据预处理
transform=transforms.Compose([
        transforms.RandomCrop(32, padding=4), #上下左右填充4个像素后随机裁剪，由于CIFAR_10数据图片均为32×32，故将随机裁剪后的尺度也设为32
        transforms.RandomHorizontalFlip(),#随机水平翻转处理
        transforms.ToTensor(),  #转换为张量Tensor
        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])#归一化处理
        ...

（3）随机可视化数据集

我们通过imshow()函数对加载的验证集（val）数据进行随机可视化，输出随机的8张图片和对应标签。

 import matplotlib.pyplot as plt
 import numpy as np
 from torchvision import datasets, transforms,utils
 
    def main():
    ...
    classes = ('airplane', 'automobile', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    # 随机显示val图片
    def imshow(img):
        img = img / 2 + 0.5  # unnormalize，逆标准化还原原始图像
        npimg = img.numpy()  #将图像转化为numpy.andgrry格式
        plt.imshow(np.transpose(npimg, (1, 2, 0)))   
        plt.show()
    #输出图像对应的标签
    print(' '.join('%5s' % classes[val_label[j].item()] for j in range(8)))
    imshow(utils.make_grid(val_image))
    #...
    
    if __name__ == '__main__':
       main()

输出结果如下图所示：

2.3 模型搭建(Model)

$\quad$ $\quad$ VGG16包含了16个隐藏层（13个卷积层和3个全连接层），在VGG-16的基础上搭建模型，特征提取层沿用原网络结构（13个卷积层），由于我使用的CIFAR_10数据集的图片是3x32x32的图片，所以这里面有一些通道是和3x224x224图片是不一样，尺寸小了7x7倍，需要进行调整，比如在后面全连接层，我的是256的输出通道，最后是10个类，因为VGG网络参数量在全连接层最多，这样可以减少参数，而且参考过的几篇文章说即便去掉几个全连接层性能也不会受太大影像。

$\quad$ $\quad$ 模型完整代码（model.py）：

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
import torch.nn as nn
import torch

class VGG(nn.Module):
    def __init__(self, features, num_classes=10, init_weights=False):
        super(VGG, self).__init__()
        self.features = features
        self.classifier = nn.Sequential(
            nn.Linear(512*1*1, 256),           #针对CIFAR_10 的input 32*32进行了修改
            nn.ReLU(True),                     #激活函数ReLU
            nn.Dropout(p=0.5),                 #随机失活，神经元失活率为50%
            nn.Linear(256, 256),               #为了减少参数，输出通道设为256
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(256, num_classes)        #num_classes=10
        )
        if init_weights:
            self._initialize_weights()
        
    def forward(self, x):
        # N x 3 x 32 x 32
        x = self.features(x)
        # N x 512 x 1 x 1
        x = torch.flatten(x, start_dim=1)      #将卷积层输出结果展开为一维向量
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                # nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


    def make_features(cfg: list): #自定义特征提取块，通过for循环搭建vgg16的13个卷积层（原始结构不做改动）
       layers = []
       in_channels = 3            # 原始图片输入channels=3
       for v in cfg:              # 利用传入参数列表cfg搭建
           if v == "M":           # M代表最大池化层，卷积核2*2，步长为2
               layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
           else:                  #卷积层，卷积核3*3，上下左右均填充一个为单位像素
               conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
               layers += [conv2d, nn.ReLU(inplace=True)]
               in_channels = v
      return nn.Sequential(*layers)


    cfgs = {                              #设置参数字典方便变换模型，可以实验vgg19和其他vgg结构网络
        'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
        'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
   }


    def vgg(model_name="vgg16", **kwargs):# 断言输入的模型名称在设置好的字典cfgs中，否则弹出警告
        assert model_name in cfgs, "Warning: model number {} not in cfgs dict!".format(model_name)
        cfg = cfgs[model_name]            # 取模型对应的参数列表，作为自定义特侦提取块make_feature的参数

        model = VGG(make_features(cfg), **kwargs)
        return model
        
    if __name__ == '__main__':
        net = vgg("vgg16")   #打印出修改后的vgg16网络结构
        print(net)

$\quad$ $\quad$ 模型搭建完成后保存为model.py文件，点击运行打印出网络结构：

VGG(
(features): Sequential(
(0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU(inplace=True)
(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU(inplace=True)
(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(6): ReLU(inplace=True)
(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(8): ReLU(inplace=True)
(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(11): ReLU(inplace=True)
(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(13): ReLU(inplace=True)
(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(15): ReLU(inplace=True)
(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(18): ReLU(inplace=True)
(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(20): ReLU(inplace=True)
(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(22): ReLU(inplace=True)
(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(25): ReLU(inplace=True)
(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(27): ReLU(inplace=True)
(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(29): ReLU(inplace=True)
(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(classifier): Sequential(
(0): Linear(in_features=512, out_features=256, bias=True)
(1): ReLU(inplace=True)
(2): Dropout(p=0.5, inplace=False)
(3): Linear(in_features=256, out_features=256, bias=True)
(4): ReLU(inplace=True)
(5): Dropout(p=0.5, inplace=False)
(6): Linear(in_features=256, out_features=10, bias=True)
)
)

Process finished with exit code 0

$\quad$ $\quad$ 说明模型是正确的，接下来准备进行训练。

2.4 训练(Train)

$\quad$ $\quad$ 训练设置 train_loader 的batch_size=200，val_loader的batch_size=50,每个epoch有50000/200=250个train_iteration，10000/50=200个val_iteration，总共训练50个epoch。对数据进行预处理，选择GPU进行运算，实例化之前搭建的vgg模型，选用交叉熵损失函数（CrossEntropyLoss），优化器选用Adam，lr=0.0002。

$\quad$ $\quad$ Adam优化器主要包含以下几个显著的优点：：

$\quad$ $\quad$ 1. 实现简单，计算高效，对内存需求少

$\quad$ $\quad$ 2. 参数的更新不受梯度的伸缩变换影响

$\quad$ $\quad$ 3. 超参数具有很好的解释性，且通常无需调整或仅需很少的微调

$\quad$ $\quad$ 4. 更新的步长能够被限制在大致的范围内（初始学习率）

$\quad$ $\quad$ 5. 能自然地实现步长退火过程（自动调整学习率）

$\quad$ $\quad$ 6. 很适合应用于大规模的数据及参数的场景

$\quad$ $\quad$ 7. 适用于不稳定目标函数

$\quad$ $\quad$ 8. 适用于梯度稀疏或梯度存在很大噪声的问题

$\quad$ $\quad$ 综合Adam在很多情况下算作默认工作性能比较优秀的优化器。详解见：简单认识Adam优化器 - 简书 (jianshu.com)

$\quad$ $\quad$ 完整的训练代码 (cifar_train.py):

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
import torch
import torch.nn as nn
from model import vgg                       
import torch.optim as optim
import torchvision
from torchvision import datasets, transforms,utils
import matplotlib.pyplot as plt
import numpy as np
import hiddenlayer as hl                                                   
import json

def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")# 设置运行设备，如果GPU可用使用GPU，否则使用CPU
    print("using {} device.".format(device))                               # 输出训练的设备名称

    # 数据预处理
    transform=transforms.Compose([
        transforms.RandomCrop(32, padding=4),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
                                                                              
    # 加载数据集,50000张训练图片                                                                          
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,   # 第一次使用时要将download设置为True才会自动去下载数据集
                                             download=False, transform=transform)
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=200,
                                               shuffle=True, num_workers=0)

    cifar10_list = train_set.class_to_idx
    cla_dict = dict((val, key) for key, val in cifar10_list.items())
    json_str = json.dumps(cla_dict, indent=9)                            # 将字典写入 json file
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)
    '''   
     {"0": "airplane","1": "automobile", "2": "bird", "3": "cat","4": "deer",
     "5": "dog","6": "frog","7": "horse","8": "ship","9": "truck"}
    '''

    # 10000张验证图片
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=False, transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=50,
                                             shuffle=True, num_workers=0)
    val_num = len(val_set)
                                             
    # 注释段用来随机可视化数据集                                         
    # val_data_iter = iter(val_loader)
    # val_image, val_label = val_data_iter.next()

    # classes = ('airplane', 'automobile', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')

    # 用来随机可视化数据集的函数
    # def imshow(img):
    #     img = img / 2 + 0.5  # unnormalize
    #     npimg = img.numpy()
    #     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    #     plt.show()
    #
    # print(' '.join('%5s' % classes[val_label[j].item()] for j in range(8)))
    # imshow(utils.make_grid(val_image))
    
    model_name = "vgg16"                                                # Net实例化
    net = vgg(model_name=model_name, num_classes=10, init_weights=True) #没有使用预训练模型参数，初始化权重从头开始训练
    net.to(device)
    loss_function = nn.CrossEntropyLoss()                               # 选用交叉熵损失函数
    optimizer = optim.Adam(net.parameters(), lr=0.0002)                 # 选用Adam优化器
    history1 = hl.History()                                             # 用history记录训练过程指标
    canvas1 = hl.Canvas()                                               # 用Canvas绘制曲线图
    
    epochs=50                                                           # 由于第一次训练较深的神经网络，epoch采用50次
    train_steps=len(train_loader)
    save_path = './vgg16.pth' 
    best_acc = 0.0
    #train   
    for epoch in range(epochs):
        net.train()
        running_loss = 0.0                                              # 每个epoch的loss归零，重新累加
        train_bar = tqdm(train_loader)                                  # Tqdm 是一个快速可扩展的Python进度条，显示每个epoch训练进度
        for step, data in enumerate(train_bar):
            images, labels = data                                       # 获得输入信息[inputs,lables]
            optimizer.zero_grad()                                       # 梯度清零，避免梯度累加
            outputs = net(images.to(device))
            loss = loss_function(outputs, labels.to(device))            # 计算每个iteration的loss
            loss.backward()                                             # loss后向传播
            optimizer.step()                                            # 优化参数

            running_loss += loss.item()                                 # 每个epoch的loss累加，用于输出本次epoch平均loss
            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,  # 进度条信息epoch[n/50]
                                                                     epochs,
                                                                     loss )
                                                                        
        net.eval()
        acc = 0.0                                                      
        with torch.no_grad():                                           # 计算精度过程不求梯度
            val_bar = tqdm(val_loader)
            for val_data in val_bar:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1                 # 计算验证精度 correct_number
                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()

        val_accurate = acc / val_num                                    # 预测正确率(correct_number/val_num(验证集样本数))
        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
              (epoch + 1, running_loss / train_steps, val_accurate))    # 打印该次epoch的train_loss和val_acc
                                                                        # train_loss=running_loss / train_steps（itreation数）
        if val_accurate > best_acc:
            best_acc = val_accurate
            torch.save(net.state_dict(), save_path)                     # 保存训练好的模型到根目录
        history1.log((epoch, step), train_loss=running_loss / train_steps, val_acc=best_acc)

    print('Finished Training')
    with canvas1:
        canvas1.draw_plot(history1['train_loss'])                       # canvas绘图
        canvas1.draw_plot(history1['val_acc'])
                                              

if __name__ == '__main__':
    main()

'''
            if step % 50 == 49:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image.to(device))  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label.to(device)).sum().item() / val_label.size(0)
              
                    print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 50, accuracy))
                    running_loss = 0.0
 '''

$\quad$ $\quad$ 开始训练，50个epoch大概持续了不到 1h,电脑也是跑的发烫，输出训练过程如下：

C:\Users\wxyz1\anaconda3\envs\pytorch\python.exe “F:/Deep learning (compute vision)/Code master/deep-learning-for-image-processing-master/pytorch_classification/vggnet/cifar_train.py”
using cuda:0 device.
train epoch[1/50] loss:1.857: 100%|██████████| 250/250 [00:56<00:00, 4.44it/s]
100%|██████████| 200/200 [00:06<00:00, 30.05it/s]
[epoch 1] train_loss: 2.058 val_accuracy: 0.319
train epoch[2/50] loss:1.555: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.22it/s]
[epoch 2] train_loss: 1.684 val_accuracy: 0.414
train epoch[3/50] loss:1.456: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.30it/s]
[epoch 3] train_loss: 1.489 val_accuracy: 0.494
train epoch[4/50] loss:1.106: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.08it/s]
[epoch 4] train_loss: 1.296 val_accuracy: 0.599
train epoch[5/50] loss:1.179: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.22it/s]
[epoch 5] train_loss: 1.133 val_accuracy: 0.626
train epoch[6/50] loss:0.854: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 30.09it/s]
[epoch 6] train_loss: 0.985 val_accuracy: 0.662
train epoch[7/50] loss:0.843: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 30.11it/s]
[epoch 7] train_loss: 0.888 val_accuracy: 0.711
train epoch[8/50] loss:0.841: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.07it/s]
[epoch 8] train_loss: 0.802 val_accuracy: 0.740
train epoch[9/50] loss:0.776: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.05it/s]
[epoch 9] train_loss: 0.739 val_accuracy: 0.748
train epoch[10/50] loss:0.805: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.22it/s]
[epoch 10] train_loss: 0.689 val_accuracy: 0.738
train epoch[11/50] loss:0.521: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.17it/s]
[epoch 11] train_loss: 0.639 val_accuracy: 0.778
train epoch[12/50] loss:0.687: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.18it/s]
[epoch 12] train_loss: 0.601 val_accuracy: 0.790
train epoch[13/50] loss:0.521: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 29.89it/s]
[epoch 13] train_loss: 0.561 val_accuracy: 0.787
train epoch[14/50] loss:0.620: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.15it/s]
[epoch 14] train_loss: 0.533 val_accuracy: 0.788
train epoch[15/50] loss:0.590: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.14it/s]
[epoch 15] train_loss: 0.495 val_accuracy: 0.812
train epoch[16/50] loss:0.431: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.15it/s]
[epoch 16] train_loss: 0.467 val_accuracy: 0.813
train epoch[17/50] loss:0.463: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.23it/s]
[epoch 17] train_loss: 0.450 val_accuracy: 0.819
train epoch[18/50] loss:0.349: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.23it/s]
[epoch 18] train_loss: 0.421 val_accuracy: 0.827
train epoch[19/50] loss:0.346: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.20it/s]
[epoch 19] train_loss: 0.402 val_accuracy: 0.827
train epoch[20/50] loss:0.492: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.25it/s]
[epoch 20] train_loss: 0.383 val_accuracy: 0.825
train epoch[21/50] loss:0.536: 100%|██████████| 250/250 [00:55<00:00, 4.49it/s]
100%|██████████| 200/200 [00:06<00:00, 30.03it/s]
[epoch 21] train_loss: 0.355 val_accuracy: 0.833
train epoch[22/50] loss:0.439: 100%|██████████| 250/250 [00:55<00:00, 4.50it/s]
100%|██████████| 200/200 [00:06<00:00, 30.17it/s]
[epoch 22] train_loss: 0.350 val_accuracy: 0.835
train epoch[23/50] loss:0.301: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 30.07it/s]
[epoch 23] train_loss: 0.332 val_accuracy: 0.840
train epoch[24/50] loss:0.407: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 29.96it/s]
[epoch 24] train_loss: 0.320 val_accuracy: 0.836
train epoch[25/50] loss:0.344: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 29.81it/s]
[epoch 25] train_loss: 0.314 val_accuracy: 0.834
train epoch[26/50] loss:0.264: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 29.92it/s]
[epoch 26] train_loss: 0.284 val_accuracy: 0.836
train epoch[27/50] loss:0.346: 100%|██████████| 250/250 [00:55<00:00, 4.49it/s]
100%|██████████| 200/200 [00:06<00:00, 30.00it/s]
[epoch 27] train_loss: 0.270 val_accuracy: 0.843
train epoch[28/50] loss:0.320: 100%|██████████| 250/250 [00:55<00:00, 4.51it/s]
100%|██████████| 200/200 [00:06<00:00, 30.14it/s]
[epoch 28] train_loss: 0.263 val_accuracy: 0.852
train epoch[29/50] loss:0.272: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.20it/s]
[epoch 29] train_loss: 0.245 val_accuracy: 0.852
train epoch[30/50] loss:0.201: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.19it/s]
[epoch 30] train_loss: 0.238 val_accuracy: 0.853
train epoch[31/50] loss:0.191: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.19it/s]
[epoch 31] train_loss: 0.232 val_accuracy: 0.854
train epoch[32/50] loss:0.212: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.25it/s]
[epoch 32] train_loss: 0.225 val_accuracy: 0.843
train epoch[33/50] loss:0.324: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.16it/s]
[epoch 33] train_loss: 0.214 val_accuracy: 0.848
train epoch[34/50] loss:0.224: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.16it/s]
[epoch 34] train_loss: 0.204 val_accuracy: 0.846
train epoch[35/50] loss:0.251: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.18it/s]
[epoch 35] train_loss: 0.193 val_accuracy: 0.845
train epoch[36/50] loss:0.258: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.18it/s]
[epoch 36] train_loss: 0.195 val_accuracy: 0.852
train epoch[37/50] loss:0.120: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.21it/s]
[epoch 37] train_loss: 0.176 val_accuracy: 0.851
train epoch[38/50] loss:0.103: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.25it/s]
[epoch 38] train_loss: 0.181 val_accuracy: 0.854
train epoch[39/50] loss:0.237: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.14it/s]
[epoch 39] train_loss: 0.172 val_accuracy: 0.849
train epoch[40/50] loss:0.249: 100%|██████████| 250/250 [00:55<00:00, 4.53it/s]
100%|██████████| 200/200 [00:06<00:00, 30.09it/s]
[epoch 40] train_loss: 0.163 val_accuracy: 0.852
train epoch[41/50] loss:0.167: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.09it/s]
[epoch 41] train_loss: 0.159 val_accuracy: 0.857
train epoch[42/50] loss:0.237: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.25it/s]
[epoch 42] train_loss: 0.149 val_accuracy: 0.852
train epoch[43/50] loss:0.137: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.17it/s]
[epoch 43] train_loss: 0.152 val_accuracy: 0.856
train epoch[44/50] loss:0.157: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 29.91it/s]
[epoch 44] train_loss: 0.145 val_accuracy: 0.860
train epoch[45/50] loss:0.209: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.16it/s]
[epoch 45] train_loss: 0.135 val_accuracy: 0.854
train epoch[46/50] loss:0.080: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.19it/s]
[epoch 46] train_loss: 0.138 val_accuracy: 0.859
train epoch[47/50] loss:0.153: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.13it/s]
[epoch 47] train_loss: 0.129 val_accuracy: 0.855
train epoch[48/50] loss:0.143: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.15it/s]
[epoch 48] train_loss: 0.127 val_accuracy: 0.861
train epoch[49/50] loss:0.139: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.20it/s]
[epoch 49] train_loss: 0.120 val_accuracy: 0.860
train epoch[50/50] loss:0.065: 100%|██████████| 250/250 [00:55<00:00, 4.52it/s]
100%|██████████| 200/200 [00:06<00:00, 30.25it/s]
[epoch 50] train_loss: 0.125 val_accuracy: 0.856
Finished Training

Process finished with exit code 0

$\quad$ $\quad$ 得出train_loss和val_acc曲线图如下：

$\quad$ $\quad$ 可见train_loss逐渐收敛到0.1左右（估计再有20个epoch可以收敛到0.0x）,验证精度达到86%左右，图中 $x$ 轴单位为 epoch：iteration。
$\quad$ $\quad$ 事实上上图是我多次尝试最终的训练结果，刚开始由于尝试对每个epoch的每隔50个iteration 的train_loss 都进行可视化输出，由于单位换算不准确得到下面的错误train_loss图（batch_size均为128，50个epoch, 390个iteration/epoch，每50个iteration打印输出信息），可以看出由于换算错误一开始的loss值就很小（异常），但是val_acc公式不受影响，显示了50个epoch下每50个iteration的val_acc波动情况，最高达到89%，train_loss的曲线形态也依然说明了网络学习的趋势。

$\quad$ $\quad$ 之后又尝试调整，将batch_size改为300，150 iteration/epoch，train_loss曲线值依然没有反映真实值（换算仍不正确），于是想到以epoch为单位对tran_loss进行输出（最终实验表明是正确的，train_loss显示为正常值）省去很多麻烦，由于iteration间隔扩大，val_acc曲线变得平滑，基本趋势没有改变。

$\quad$ $\quad$ 之后想验证batch_size=500，epoch=90对于val_cc收敛精度的影响，跑了2个小时，得出的曲线如下，精度提升不明显，抖动比较明显，大概收敛在87%左右，说明调大batch_size和epoch对val_cc精读提升不大。

$\quad$ $\quad$ 最终选择 train_loader 的batch_size=200，val_acc的batch_size=50，以epoch为单位输出train_loss，总共训练50个epoch，得到顶图曲线作为最终结果。

2.5 预测（Predict）

$\quad$ $\quad$ 在根目录新建文件夹sample存放测试图片，任何尺度均可。将预测的结果图片保存在predict文件夹中。预测程序保存为predict.py:

import os
import json

import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt

from model import vgg


def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    # 对输入的测试图片进行一个预处理，裁剪为32×32
    data_transform = transforms.Compose(
        [transforms.Resize((32, 32)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    # 加载测试图片
    img_path = "./sample/01.jpg"
    assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    img = Image.open(img_path)
    plt.imshow(img)
    # [N, C, H, W]
    img = data_transform(img)
    # expand batch dimension
    img = torch.unsqueeze(img, dim=0)

    # 读取lable字典文件
    json_path = './class_indices.json'
    assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)

    json_file = open(json_path, "r")
    class_indict = json.load(json_file)
    
    # 实例化模型
    model = vgg(model_name="vgg16", num_classes=10).to(device)
    # 加载训练好的模型文件
    weights_path = "./vgg16.pth"
    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    model.load_state_dict(torch.load(weights_path, map_location=device))

    model.eval()
    with torch.no_grad():
        # 预测图片所属类别
        output = torch.squeeze(model(img.to(device))).cpu()
        predict = torch.softmax(output, dim=0)
        predict_cla = torch.argmax(predict).numpy()

    print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
                                                 predict[predict_cla].numpy())
    # 显示并保存预测结果                                             
    plt.title(print_res)
    print(print_res)
    plt.savefig('./predict/01.jpg', bbox_inches=None)
    plt.show()


if __name__ == '__main__':
    main()

$\quad$ $\quad$ 预测结果如下：

$\quad$ $\quad$ 通过预测可以看出，模型学习的效果还是不错的，识别正确类的prob都很高，尤其是ship、frog、deer和bird类，但是也有错分，比如horse，说明模型在识别对象和背景对比差异不明显的object时还有待改进。

$\quad$ $\quad$ 在CIFAR_10验证集上预测结果的混淆矩阵如上图所示，the model accuracy is 0.8546，下表为各类别的预测准确度（Precision ）、召回率（Recall）和特异度（Specificity）。

Classes\Merics	Precision	Recall	Specificity
airplane	0.889	0.869	0.988
automobile	0.96	0.903	0.996
bird	0.88	0.74	0.989
cat	0.751	0.653	0.976
deer	0.807	0.865	0.977
dog	0.78	0.821	0.974
frog	0.859	0.914	0.983
horse	0.842	0.93	0.981
ship	0.924	0.918	0.992
truck	0.86	0.933	0.983

三、VGG-16在GID数据集上的实现

3.1 Gaofen Image Dataset(GID)数据集简介

$\quad$ $\quad$ Gaofen Image Dataset(GID)是一个用于土地利用和土地覆盖（LULC）分类的大型数据集。它包含来自中国60多个不同城市的150幅高质量高分二号（GF-2）图像，这些图像覆盖的地理区域超过了5万km²。GID图像具有较高的类内多样性和较低的类间可分离性。GF-2是高清晰度地球观测系统（HDEOS）的第二颗卫星。GF-2卫星包括了空间分辨率为1 m的全色图像和4 m的多光谱图像，图像大小为6908×7300像素。多光谱提供了蓝色、绿色、红色和近红外波段的图像。自2014年启动以来，GF-2已被用于土地调查、环境监测、作物估算、建设规划等重要应用。

$\quad$ $\quad$ 本次任务选用的是GID中遥感场景分类训练数据集—SecenClass Training Set，其中包含了15个场景类别，每个类别有2000张56×56的影像，总共30K遥感场景影像，训练完全够用。

类别包括：

industrial land（工业用地）

shrub land（灌木地）

natural grassland（自然草地）

artificial grassland（人工草地）

river（河流）

lake（湖泊）

pond（池塘）

urban residential（城市住宅）

rural residential（农村住宅）

traffic land（交通用地）

paddy field（稻田）

irrigated land（灌溉用地）

dry cropland（旱地）

garden plot（园地）

arbor woodland（林地）

数据集下载地址：http://captain.whu.edu.cn/GID/

相关参考文献：
【Tong X Y, Xia G S, Lu Q, et al. Learning Transferable Deep Models for Land-Use Classification with High-Resolution Remote Sensing Images[J]. arXiv preprint arXiv:1807.05713, 2018.】

（1）数据集划分
$\quad$ $\quad$ 利用数据集分割程序split_data.py将SecenClass Training Set划分为train（27000张）和val（3000张），观察模型的训练过程，训练完成后测试单张图片。划分好的data文件如下图：

完整的split_data.py:

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
import os
from shutil import copy, rmtree
import random

def mk_file(file_path: str):
    if os.path.exists(file_path):
        # 如果文件夹存在，则先删除原文件夹在重新创建
        rmtree(file_path)
    os.makedirs(file_path)

def main():
    # 保证随机可复现
    random.seed(0)

    # 将数据集中10%的数据划分到验证集中
    split_rate = 0.1

    # 指向data_set文件夹，data文件夹是其子文件夹
    cwd = os.getcwd()
    data_root = os.path.join(cwd, "data")
    origin_flower_path = os.path.join(data_root, "data_set")
    assert os.path.exists(origin_flower_path), "path '{}' does not exist.".format(origin_flower_path)

    flower_class = [cla for cla in os.listdir(origin_flower_path)
                    if os.path.isdir(os.path.join(origin_flower_path, cla))]

    # 建立保存训练集的文件夹
    train_root = os.path.join(data_root, "train")
    mk_file(train_root)
    for cla in flower_class:
        # 建立每个类别对应的文件夹
        mk_file(os.path.join(train_root, cla))

    # 建立保存验证集的文件夹
    val_root = os.path.join(data_root, "val")
    mk_file(val_root)
    for cla in flower_class:
        # 建立每个类别对应的文件夹
        mk_file(os.path.join(val_root, cla))

    for cla in flower_class:
        cla_path = os.path.join(origin_flower_path, cla)
        images = os.listdir(cla_path)
        num = len(images)
        # 随机采样验证集的索引
        eval_index = random.sample(images, k=int(num*split_rate))
        for index, image in enumerate(images):
            if image in eval_index:
                # 将分配至验证集中的文件复制到相应目录
                image_path = os.path.join(cla_path, image)
                new_path = os.path.join(val_root, cla)
                copy(image_path, new_path)
            else:
                # 将分配至训练集中的文件复制到相应目录
                image_path = os.path.join(cla_path, image)
                new_path = os.path.join(train_root, cla)
                copy(image_path, new_path)
            print("\r[{}] processing [{}/{}]".format(cla, index+1, num), end="")  # processing bar
        print()

    print("processing done!")


if __name__ == '__main__':
    main()

（2）数据预处理。
$\quad$ $\quad$ 和前面一样，通过torchvision.transforms中的各类数据处理函数对图像数据进行预处理：

 ...
 data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(56),   #随机裁剪的尺寸依然为56
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
        "val": transforms.Compose([transforms.Resize((56, 56)),
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    }
 ...

（3）随机可视化数据集

$\quad$ $\quad$ 我们通过imshow()函数对加载的验证集（val）数据进行随机可视化，输出随机的8张图片和对应标签如下:

3.1 模型搭建(Model)

$\quad$ $\quad$ 和之前在CIFAR_10数据集上应用的模型相同，不做改变，只是稍作调整，将num_classes变为15。搭建完保存为model.py：

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
import torch.nn as nn
import torch

class VGG(nn.Module):
    def __init__(self, features, num_classes=15, init_weights=False):
        super(VGG, self).__init__()
        self.features = features
        self.classifier = nn.Sequential(
            nn.Linear(512*1*1, 256),           #针对GID 的input 56*56进行了修改
            nn.ReLU(True),                     #激活函数ReLU
            nn.Dropout(p=0.5),                 #随机失活，神经元失活率为50%
            nn.Linear(256, 256),               #为了减少参数，输出通道设为256
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(256, num_classes)        #num_classes=15
        )
        if init_weights:
            self._initialize_weights()
        
    def forward(self, x):
        # N x 3 x 56 x 56
        x = self.features(x)
        # N x 512 x 1 x 1
        x = torch.flatten(x, start_dim=1)      #将卷积层输出结果展开为一维向量
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                # nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


    def make_features(cfg: list): #自定义特征提取块，通过for循环搭建vgg16的13个卷积层（原始结构不做改动）
       layers = []
       in_channels = 3            # 原始图片输入channels=3
       for v in cfg:              # 利用传入参数列表cfg搭建
           if v == "M":           # M代表最大池化层，卷积核2*2，步长为2
               layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
           else:                  #卷积层，卷积核3*3，上下左右均填充一个为单位像素
               conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
               layers += [conv2d, nn.ReLU(inplace=True)]
               in_channels = v
      return nn.Sequential(*layers)


    cfgs = {                      #设置参数字典方便变换模型，可以实验vgg19和其他vgg结构网络
        'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
        'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
   }


    def vgg(model_name="vgg16", **kwargs):# 断言输入的模型名称在设置好的字典cfgs中，否则弹出警告
        assert model_name in cfgs, "Warning: model number {} not in cfgs dict!".format(model_name)
        cfg = cfgs[model_name]            # 取模型对应的参数列表，作为自定义特侦提取块make_feature的参数

        model = VGG(make_features(cfg), **kwargs)
        return model
    if __name__ == '__main__':
        net = vgg("vgg16")   #打印出修改后的vgg16网络结构
        print(net)

$\quad$ $\quad$ 打印出网络结构：

VGG(
(features): Sequential(
(0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU(inplace=True)
(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU(inplace=True)
(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(6): ReLU(inplace=True)
(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(8): ReLU(inplace=True)
(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(11): ReLU(inplace=True)
(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(13): ReLU(inplace=True)
(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(15): ReLU(inplace=True)
(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(18): ReLU(inplace=True)
(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(20): ReLU(inplace=True)
(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(22): ReLU(inplace=True)
(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(25): ReLU(inplace=True)
(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(27): ReLU(inplace=True)
(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(29): ReLU(inplace=True)
(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(classifier): Sequential(
(0): Linear(in_features=512, out_features=256, bias=True)
(1): ReLU(inplace=True)
(2): Dropout(p=0.5, inplace=False)
(3): Linear(in_features=256, out_features=256, bias=True)
(4): ReLU(inplace=True)
(5): Dropout(p=0.5, inplace=False)
(6): Linear(in_features=256, out_features=15, bias=True)
)
)

Process finished with exit code 0

3.2 训练(Train)

$\quad$ $\quad$ 由于刚开始尝试在遥感数据集上训练VGG（较深的网络），之前训练LeNet和AlexNet(均在CIFAR_10数据集上)收敛速度还可以，鉴于自己电脑的算力（GTX 1050Ti 4G），分三个阶段进行训练，每个阶段训练30个epoch，总共训练90个epoch，batch_size设为200，每个阶段训练完毕分别保存模型为： vgg16Net.pth、 vgg16Net2.pth和vgg16Net3pth，后一个阶段加载上一个阶段的预训练模型继续训练直到Train_loss趋近于收敛。

$\quad$ $\quad$ 完整训练代码train.py:

import os
import json
import torch
import torch.nn as nn
from torchvision import datasets, transforms, utils
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optim
from tqdm import tqdm
import hiddenlayer as hl
from model import vgg


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(56),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
        "val": transforms.Compose([transforms.Resize((56, 56)),
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    }
    #加载数据
    data_root = os.path.abspath(os.path.join(os.getcwd(), "./.."))  # get data root path
    image_path = os.path.join(data_root, "data_set", "data")  # 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)

    scene_list = train_dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in scene_list.items())
    # 将标签分类写入字典文件 json file
    json_str = json.dumps(cla_dict, indent=14)
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)
    '''
    {              
              "0": "arbor woodland",
              "1": "artificial grassland",
              "2": "dry cropland",
              "3": "garden plot",
              "4": "industrial land",
              "5": "irrigated land",
              "6": "lake",
              "7": "natural grassland",
              "8": "paddy field",
              "9": "pond",
              "10": "river",
              "11": "rural residential",
              "12": "shrub land",
              "13": "traffic land",
              "14": "urban residential"
     }
   '''
    batch_size =200
    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers，单处理器一般设置为0
    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=True, #shufle=Ture,打乱数据集，防止模型训练在某一类
                                                  num_workers=nw)                      #上过度训练
    print("using {} images for training, {} images for validation.".format(train_num,
                                                                           val_num))

    # classes = ('arbor woodland', 'artificial grassland','dry cropland', 'garden plot','industrial land', 'irrigated land',
    #            'lake','natural grassland','paddy field','pond','river', 'rural residential','shrub land','traffic land',
    #            'urban residential')
    # val_data_iter = iter(validate_loader)
    # val_image, val_label = val_data_iter.next()
    #
    # 随机显示val图片
    # def imshow(img):
    #     img = img / 2 + 0.5  # unnormalize，逆标准化还原原始图像
    #     npimg = img.numpy()  # 将图像转化为numpy.andgrry格式
    #     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    #     plt.show()
    #
    # # 输出图像对应的标签
    # print(' '.join('%5s' % classes[val_label[j].item()] for j in range(8)))
    # imshow(utils.make_grid(val_image))

    model_name = "vgg16"
    net = vgg(model_name=model_name, num_classes=15, init_weights=True)
    net.load_state_dict(torch.load("./vgg16Net2.pth"))                               #加载第二阶段训练模型
    net.to(device)
    history1 = hl.History()
    canvas1 = hl.Canvas()
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.0002)                              #学习率初始为0.0002

    epochs = 30                                                                      #每次epoch=30，训练3次
    best_acc = 0.0
    save_path = './{}Net3.pth'.format(model_name)
    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()
            outputs = net(images.to(device))
            loss = loss_function(outputs, 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                                                                 # 计算 val_acc/ 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))
                predict_y = torch.max(outputs, dim=1)[1]
                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()

        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)
        history1.log((epoch, step), train_loss=running_loss / train_steps, val_acc=best_acc)

    print('Finished Training')
    with canvas1:
        canvas1.draw_plot(history1['train_loss'])
        canvas1.draw_plot(history1['val_acc'])

if __name__ == '__main__':
    main()

$\quad$ $\quad$ 训练过程如下所示，刚开始每个epoch大约花费5—9 min，随着训练加快，每个epoch 花费的时间稳定在1.25 min左右。由最后30个epoch的训练过程可以看出train_loss的收敛速度逐渐放缓，但并没有完全收敛，验证精度val_acc也一直在保持上升状态，说明网络依然在学习，目测还需要至少40个epoch才能完全收敛。训练全程LR都为0.0002没有变动，网上看过的几篇调参博文说后期LR增大或许可以加速收敛速度，有待尝试。

$\quad$ $\quad$ 参考博文连接：train loss相关问题 - 吱吱了了 - 博客园 (cnblogs.com)

C:\Users\wxyz1\anaconda3\envs\pytorch\python.exe “F:/Deep learning (compute vision)/Code master/deep-learning-for-image-processing-master/Remote sensing scene classification/train.py”
using cuda:0 device.
Using 8 dataloader workers every process
using 27000 images for training, 3000 images for validation.
train epoch[1/30] loss:0.428: 100%|██████████| 135/135 [03:48<00:00, 1.69s/it]
100%|██████████| 15/15 [00:46<00:00, 3.07s/it]
[epoch 1] train_loss: 0.424 val_accuracy: 0.845
train epoch[2/30] loss:0.365: 100%|██████████| 135/135 [04:48<00:00, 2.13s/it]
100%|██████████| 15/15 [00:45<00:00, 3.05s/it]
[epoch 2] train_loss: 0.413 val_accuracy: 0.858
train epoch[3/30] loss:0.386: 100%|██████████| 135/135 [03:27<00:00, 1.54s/it]
100%|██████████| 15/15 [00:59<00:00, 3.98s/it]
[epoch 3] train_loss: 0.411 val_accuracy: 0.867
train epoch[4/30] loss:0.297: 100%|██████████| 135/135 [04:41<00:00, 2.08s/it]
100%|██████████| 15/15 [00:44<00:00, 2.98s/it]
[epoch 4] train_loss: 0.392 val_accuracy: 0.863
train epoch[5/30] loss:0.358: 100%|██████████| 135/135 [02:15<00:00, 1.00s/it]
100%|██████████| 15/15 [00:17<00:00, 1.14s/it]
[epoch 5] train_loss: 0.396 val_accuracy: 0.858
train epoch[6/30] loss:0.462: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 6] train_loss: 0.379 val_accuracy: 0.861
train epoch[7/30] loss:0.299: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 7] train_loss: 0.394 val_accuracy: 0.872
train epoch[8/30] loss:0.414: 100%|██████████| 135/135 [01:17<00:00, 1.75it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 8] train_loss: 0.375 val_accuracy: 0.860
train epoch[9/30] loss:0.305: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 9]train_loss: 0.365 val_accuracy: 0.866
train epoch[10/30] loss:0.416: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 10] train_loss: 0.367 val_accuracy: 0.862
train epoch[11/30] loss:0.306: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 11] train_loss: 0.346 val_accuracy: 0.867
train epoch[12/30] loss:0.301: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 12] train_loss: 0.348 val_accuracy: 0.868
train epoch[13/30] loss:0.270: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 13] train_loss: 0.351 val_accuracy: 0.870
train epoch[14/30] loss:0.269: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 14] train_loss: 0.339 val_accuracy: 0.878
train epoch[15/30] loss:0.295: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 15] train_loss: 0.352 val_accuracy: 0.866
train epoch[16/30] loss:0.232: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 16] train_loss: 0.347 val_accuracy: 0.876
train epoch[17/30] loss:0.322: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 17] train_loss: 0.330 val_accuracy: 0.870
train epoch[18/30] loss:0.426: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 18] train_loss: 0.338 val_accuracy: 0.870
train epoch[19/30] loss:0.292: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 19] train_loss: 0.325 val_accuracy: 0.872
train epoch[20/30] loss:0.272: 100%|██████████| 135/135 [01:16<00:00, 1.77it/s]
100%|██████████| 15/15 [00:16<00:00, 1.09s/it]
[epoch 20] train_loss: 0.326 val_accuracy: 0.860
train epoch[21/30] loss:0.277: 100%|██████████| 135/135 [01:16<00:00, 1.76it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 21] train_loss: 0.328 val_accuracy: 0.875
train epoch[22/30] loss:0.232: 100%|██████████| 135/135 [01:17<00:00, 1.75it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 22] train_loss: 0.319 val_accuracy: 0.880
train epoch[23/30] loss:0.338: 100%|██████████| 135/135 [01:16<00:00, 1.76it/s]
100%|██████████| 15/15 [00:16<00:00, 1.12s/it]
[epoch 23] train_loss: 0.313 val_accuracy: 0.876
train epoch[24/30] loss:0.306: 100%|██████████| 135/135 [01:17<00:00, 1.75it/s]
100%|██████████| 15/15 [00:18<00:00, 1.24s/it]
[epoch 24] train_loss: 0.322 val_accuracy: 0.875
train epoch[25/30] loss:0.315: 100%|██████████| 135/135 [01:16<00:00, 1.77it/s]
100%|██████████| 15/15 [00:16<00:00, 1.11s/it]
[epoch 25] train_loss: 0.313 val_accuracy: 0.872
train epoch[26/30] loss:0.291: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 26] train_loss: 0.301 val_accuracy: 0.886
train epoch[27/30] loss:0.356: 100%|██████████| 135/135 [01:16<00:00, 1.77it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 27] train_loss: 0.312 val_accuracy: 0.869
train epoch[28/30] loss:0.295: 100%|██████████| 135/135 [01:16<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 28] train_loss: 0.300 val_accuracy: 0.886
train epoch[29/30] loss:0.224: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 29] train_loss: 0.299 val_accuracy: 0.884
train epoch[30/30] loss:0.348: 100%|██████████| 135/135 [01:15<00:00, 1.78it/s]
100%|██████████| 15/15 [00:16<00:00, 1.08s/it]
[epoch 30] train_loss: 0.293 val_accuracy: 0.884
Finished Training

Process finished with exit code 0

$\quad$ $\quad$ HiddenLayer是一个小型库。它覆盖基础元素，但你可能需要为自己的用例进行扩展。如果要跟踪您的训练过程，您需要使用两个类：History 存储指标，Canvas 进行绘制。利用HiddenLayer模块绘制train_loss和val_acc曲线图如下：

$\quad$ $\quad$ 关于 HiddenLayer的详细用法参见：hiddenlayer/pytorch_train.ipynb at master · waleedka/hiddenlayer · GitHub

3.3 预测（Predict）

$\quad$ $\quad$ 虽然90个epoch后train_loss仍然没有完全收敛，但是val_acc已经可以达到89%，效果还不错。在根目录新建文件夹sample存放测试图片，任何尺度均可。将预测的结果图片保存在predict文件夹中。预测程序保存为predict.py:

import os
import json

import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt

from model import vgg


def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    # 对输入的测试图片进行一个预处理，裁剪为56×56
    data_transform = transforms.Compose(
        [transforms.Resize((56, 56)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    # 加载图片
    img_path = "./sample/01.tif"
    assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    img = Image.open(img_path)
    plt.imshow(img)
    # [N, C, H, W]
    img = data_transform(img)
    # 增加batch维
    img = torch.unsqueeze(img, dim=0)

    # 读取之前写的json标签文件
    json_path = './class_indices.json'
    assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)

    json_file = open(json_path, "r")
    class_indict = json.load(json_file)
    
    # 实例化模型
    model = vgg(model_name="vgg16", num_classes=15).to(device)
    # 加载训练好的模型文件
    weights_path = "./vgg16Net3.pth"
    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    model.load_state_dict(torch.load(weights_path, map_location=device))

    model.eval()
    with torch.no_grad():
        # 预测图片分类
        output = torch.squeeze(model(img.to(device))).cpu()
        predict = torch.softmax(output, dim=0)
        predict_cla = torch.argmax(predict).numpy()

    print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
                                                 predict[predict_cla].numpy())
    plt.title(print_res)
    print(print_res)
    plt.savefig('./predict/01.jpg', bbox_inches=None)  #保存预测图片结果
    plt.show()


if __name__ == '__main__':
    main()

$\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 错误（urban residential） $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 错误（lake）

$\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 正确 $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 错误（urban residential）

思考：

$\quad$ $\quad$ 可以看出，模型对于差异比较大的异质场景分类效果还可以，如：交通用地（traffic land），但是对于类间差异不明显的场景分类效果还有待提高，例如：城市住宅（urban residential）和农村住宅（rural residential）。究其原因：

（1）是数据集划分太过细致，许多类间差异不明显的对象容易混淆，例如将水体分为：河流（river）、湖泊(lake)、池塘(pond)；将草地划分为人工草地（artificial grassland）和自然草地（nature grassland）。由于图片尺寸为56×56，场景分割不太宏观，部分图片缺失有效的上下文信息从而引起模型的错分。一般来说，对于遥感影像的宏观分类效果比较好。

（2）模型有待改进，可以添加一些对于光谱信息识别较好的tricks来提升模型的效果。通过扩展其他的遥感数据进行训练来提高模型的泛化性。

$\quad$ $\quad$ 之后将train_loader 的batch_size改为300，val_loader的batch_size改为30，训练100个epoch，观察模型的train_loss和val_acc都最终收敛，训练过程如下：

using cuda:0 device.
Using 8 dataloader workers every process
using 27000 images for training, 3000 images for validation.
train epoch[1/100] loss:2.436: 100%|██████████| 90/90 [07:41<00:00, 5.12s/it]
100%|██████████| 100/100 [01:11<00:00, 1.40it/s]
[epoch 1] train_loss: 2.542 val_accuracy: 0.188
train epoch[2/100] loss:2.149: 100%|██████████| 90/90 [04:56<00:00, 3.30s/it]
100%|██████████| 100/100 [00:44<00:00, 2.27it/s]
[epoch 2] train_loss: 2.233 val_accuracy: 0.186
train epoch[3/100] loss:2.039: 100%|██████████| 90/90 [01:26<00:00, 1.04it/s]
100%|██████████| 100/100 [00:17<00:00, 5.84it/s]
[epoch 3] train_loss: 2.112 val_accuracy: 0.260
train epoch[4/100] loss:1.914: 100%|██████████| 90/90 [01:14<00:00, 1.22it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 4] train_loss: 1.985 val_accuracy: 0.327
train epoch[5/100] loss:1.698: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.95it/s]
[epoch 5] train_loss: 1.808 val_accuracy: 0.382
train epoch[6/100] loss:1.754: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.93it/s]
[epoch 6] train_loss: 1.710 val_accuracy: 0.442
train epoch[7/100] loss:1.584: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.94it/s]
[epoch 7] train_loss: 1.626 val_accuracy: 0.458
train epoch[8/100] loss:1.435: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 8] train_loss: 1.498 val_accuracy: 0.494
train epoch[9/100] loss:1.417: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 9] train_loss: 1.451 val_accuracy: 0.500
train epoch[10/100] loss:1.282: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.00it/s]
[epoch 10] train_loss: 1.361 val_accuracy: 0.541
train epoch[11/100] loss:1.268: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.99it/s]
[epoch 11] train_loss: 1.319 val_accuracy: 0.533
train epoch[12/100] loss:1.179: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.96it/s]
[epoch 12] train_loss: 1.252 val_accuracy: 0.579
train epoch[13/100] loss:1.116: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.99it/s]
[epoch 13] train_loss: 1.194 val_accuracy: 0.600
train epoch[14/100] loss:1.234: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.97it/s]
[epoch 14] train_loss: 1.158 val_accuracy: 0.598
train epoch[15/100] loss:0.975: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.01it/s]
[epoch 15] train_loss: 1.109 val_accuracy: 0.629
train epoch[16/100] loss:0.972: 100%|██████████| 90/90 [01:13<00:00, 1.22it/s]
100%|██████████| 100/100 [00:16<00:00, 6.00it/s]
[epoch 16] train_loss: 1.063 val_accuracy: 0.645
train epoch[17/100] loss:1.038: 100%|██████████| 90/90 [01:14<00:00, 1.22it/s]
100%|██████████| 100/100 [00:16<00:00, 5.99it/s]
[epoch 17] train_loss: 1.025 val_accuracy: 0.679
train epoch[18/100] loss:0.939: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.01it/s]
[epoch 18] train_loss: 0.986 val_accuracy: 0.681
train epoch[19/100] loss:0.939: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.98it/s]
[epoch 19] train_loss: 0.953 val_accuracy: 0.676
train epoch[20/100] loss:0.798: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 20] train_loss: 0.914 val_accuracy: 0.688
train epoch[21/100] loss:0.876: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 21] train_loss: 0.899 val_accuracy: 0.709
train epoch[22/100] loss:0.916: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.02it/s]
[epoch 22] train_loss: 0.872 val_accuracy: 0.717
train epoch[23/100] loss:0.826: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.02it/s]
[epoch 23] train_loss: 0.861 val_accuracy: 0.712
train epoch[24/100] loss:0.841: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.99it/s]
[epoch 24] train_loss: 0.823 val_accuracy: 0.744
train epoch[25/100] loss:0.860: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 25] train_loss: 0.795 val_accuracy: 0.743
train epoch[26/100] loss:0.820: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.02it/s]
[epoch 26] train_loss: 0.781 val_accuracy: 0.751
train epoch[27/100] loss:0.828: 100%|██████████| 90/90 [01:15<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.02it/s]
[epoch 27] train_loss: 0.753 val_accuracy: 0.761
train epoch[28/100] loss:0.667: 100%|██████████| 90/90 [01:15<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.89it/s]
[epoch 28] train_loss: 0.738 val_accuracy: 0.759
train epoch[29/100] loss:0.685: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.00it/s]
[epoch 29] train_loss: 0.732 val_accuracy: 0.757
train epoch[30/100] loss:0.709: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.99it/s]
[epoch 30] train_loss: 0.717 val_accuracy: 0.759
train epoch[31/100] loss:0.844: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.01it/s]
[epoch 31] train_loss: 0.704 val_accuracy: 0.771
train epoch[32/100] loss:0.746: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.98it/s]
[epoch 32] train_loss: 0.677 val_accuracy: 0.795
train epoch[33/100] loss:0.607: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.97it/s]
[epoch 33] train_loss: 0.675 val_accuracy: 0.804
train epoch[34/100] loss:0.700: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.97it/s]
[epoch 34] train_loss: 0.670 val_accuracy: 0.797
train epoch[35/100] loss:0.567: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 5.99it/s]
[epoch 35] train_loss: 0.632 val_accuracy: 0.801
train epoch[36/100] loss:0.683: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 36] train_loss: 0.608 val_accuracy: 0.807
train epoch[37/100] loss:0.502: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.02it/s]
[epoch 37] train_loss: 0.615 val_accuracy: 0.819
train epoch[38/100] loss:0.579: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.00it/s]
[epoch 38] train_loss: 0.598 val_accuracy: 0.812
train epoch[39/100] loss:0.598: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 39] train_loss: 0.581 val_accuracy: 0.823
train epoch[40/100] loss:0.517: 100%|██████████| 90/90 [01:16<00:00, 1.18it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 40] train_loss: 0.574 val_accuracy: 0.808
train epoch[41/100] loss:0.514: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 41] train_loss: 0.578 val_accuracy: 0.821
train epoch[42/100] loss:0.514: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.91it/s]
[epoch 42] train_loss: 0.567 val_accuracy: 0.832
train epoch[43/100] loss:0.506: 100%|██████████| 90/90 [01:19<00:00, 1.13it/s]
100%|██████████| 100/100 [00:18<00:00, 5.50it/s]
[epoch 43] train_loss: 0.544 val_accuracy: 0.831
train epoch[44/100] loss:0.516: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.09it/s]
[epoch 44] train_loss: 0.535 val_accuracy: 0.820
train epoch[45/100] loss:0.521: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.00it/s]
[epoch 45] train_loss: 0.533 val_accuracy: 0.823
train epoch[46/100] loss:0.492: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 46] train_loss: 0.516 val_accuracy: 0.848
train epoch[47/100] loss:0.520: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 47] train_loss: 0.501 val_accuracy: 0.839
train epoch[48/100] loss:0.438: 100%|██████████| 90/90 [01:13<00:00, 1.22it/s]
100%|██████████| 100/100 [00:16<00:00, 6.07it/s]
[epoch 48] train_loss: 0.503 val_accuracy: 0.841
train epoch[49/100] loss:0.521: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.07it/s]
[epoch 49] train_loss: 0.487 val_accuracy: 0.836
train epoch[50/100] loss:0.483: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 50] train_loss: 0.501 val_accuracy: 0.850
train epoch[51/100] loss:0.548: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 51] train_loss: 0.474 val_accuracy: 0.841
train epoch[52/100] loss:0.403: 100%|██████████| 90/90 [01:13<00:00, 1.22it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 52] train_loss: 0.470 val_accuracy: 0.847
train epoch[53/100] loss:0.337: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.96it/s]
[epoch 53] train_loss: 0.452 val_accuracy: 0.850
train epoch[54/100] loss:0.463: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.09it/s]
[epoch 54] train_loss: 0.454 val_accuracy: 0.838
train epoch[55/100] loss:0.461: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 55] train_loss: 0.435 val_accuracy: 0.859
train epoch[56/100] loss:0.416: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 56] train_loss: 0.443 val_accuracy: 0.858
train epoch[57/100] loss:0.497: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 57] train_loss: 0.433 val_accuracy: 0.858
train epoch[58/100] loss:0.480: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 58] train_loss: 0.424 val_accuracy: 0.853
train epoch[59/100] loss:0.420: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 59] train_loss: 0.436 val_accuracy: 0.861
train epoch[60/100] loss:0.392: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 60] train_loss: 0.416 val_accuracy: 0.861
train epoch[61/100] loss:0.379: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 61] train_loss: 0.411 val_accuracy: 0.840
train epoch[62/100] loss:0.400: 100%|██████████| 90/90 [01:13<00:00, 1.22it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 62] train_loss: 0.396 val_accuracy: 0.856
train epoch[63/100] loss:0.390: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 63] train_loss: 0.406 val_accuracy: 0.864
train epoch[64/100] loss:0.347: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 64] train_loss: 0.393 val_accuracy: 0.866
train epoch[65/100] loss:0.275: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 65] train_loss: 0.376 val_accuracy: 0.870
train epoch[66/100] loss:0.411: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 66] train_loss: 0.381 val_accuracy: 0.852
train epoch[67/100] loss:0.287: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.07it/s]
[epoch 67] train_loss: 0.385 val_accuracy: 0.868
train epoch[68/100] loss:0.350: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 68] train_loss: 0.381 val_accuracy: 0.861
train epoch[69/100] loss:0.254: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.02it/s]
[epoch 69] train_loss: 0.370 val_accuracy: 0.877
train epoch[70/100] loss:0.319: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 70] train_loss: 0.361 val_accuracy: 0.871
train epoch[71/100] loss:0.406: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 71] train_loss: 0.373 val_accuracy: 0.870
train epoch[72/100] loss:0.280: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.01it/s]
[epoch 72] train_loss: 0.335 val_accuracy: 0.869
train epoch[73/100] loss:0.360: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 73] train_loss: 0.349 val_accuracy: 0.877
train epoch[74/100] loss:0.289: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.01it/s]
[epoch 74] train_loss: 0.361 val_accuracy: 0.876
train epoch[75/100] loss:0.365: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.07it/s]
[epoch 75] train_loss: 0.343 val_accuracy: 0.869
train epoch[76/100] loss:0.246: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 76] train_loss: 0.349 val_accuracy: 0.869
train epoch[77/100] loss:0.255: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 77] train_loss: 0.328 val_accuracy: 0.881
train epoch[78/100] loss:0.339: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.09it/s]
[epoch 78] train_loss: 0.346 val_accuracy: 0.871
train epoch[79/100] loss:0.331: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 79] train_loss: 0.329 val_accuracy: 0.875
train epoch[80/100] loss:0.344: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 80] train_loss: 0.319 val_accuracy: 0.877
train epoch[81/100] loss:0.327: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 81] train_loss: 0.324 val_accuracy: 0.874
train epoch[82/100] loss:0.326: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 82] train_loss: 0.314 val_accuracy: 0.882
train epoch[83/100] loss:0.320: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 83] train_loss: 0.324 val_accuracy: 0.863
train epoch[84/100] loss:0.251: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 84] train_loss: 0.320 val_accuracy: 0.882
train epoch[85/100] loss:0.266: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 85] train_loss: 0.302 val_accuracy: 0.869
train epoch[86/100] loss:0.249: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 86] train_loss: 0.297 val_accuracy: 0.874
train epoch[87/100] loss:0.304: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.07it/s]
[epoch 87] train_loss: 0.300 val_accuracy: 0.893
train epoch[88/100] loss:0.187: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 89] train_loss: 0.305 val_accuracy: 0.875
train epoch[89/100] loss:0.336: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.05it/s]
[epoch 89] train_loss: 0.297 val_accuracy: 0.881
train epoch[90/100] loss:0.295: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 90] train_loss: 0.293 val_accuracy: 0.881
train epoch[91/100] loss:0.307: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.07it/s]
[epoch 91] train_loss: 0.305 val_accuracy: 0.884
train epoch[92/100] loss:0.210: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.04it/s]
[epoch 92] train_loss: 0.292 val_accuracy: 0.882
train epoch[93/100] loss:0.207: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 5.95it/s]
[epoch 93] train_loss: 0.287 val_accuracy: 0.889
train epoch[94/100] loss:0.190: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.10it/s]
[epoch 94] train_loss: 0.271 val_accuracy: 0.893
train epoch[95/100] loss:0.304: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.08it/s]
[epoch 95] train_loss: 0.281 val_accuracy: 0.893
train epoch[96/100] loss:0.308: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 96] train_loss: 0.260 val_accuracy: 0.890
train epoch[97/100] loss:0.297: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 97] train_loss: 0.272 val_accuracy: 0.875
train epoch[98/100] loss:0.333: 100%|██████████| 90/90 [01:14<00:00, 1.20it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 98] train_loss: 0.282 val_accuracy: 0.879
train epoch[99/100] loss:0.298: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.03it/s]
[epoch 99] train_loss: 0.272 val_accuracy: 0.886
train epoch[100/100] loss:0.278: 100%|██████████| 90/90 [01:14<00:00, 1.21it/s]
100%|██████████| 100/100 [00:16<00:00, 6.06it/s]
[epoch 100] train_loss: 0.268 val_accuracy: 0.879
Finished Training

Process finished with exit code 0

$\quad$ $\quad$ 得到loss曲线图如下：

$\quad$ $\quad$ train_loss并没有像预想的一样降到0.0x，val_acc也没有得到提高，只是更加收敛。下面对scene image进行类别预测：

$\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 错误（urban residential） $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 正确

$\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 正确 $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ $\quad$ 正确

$\quad$ $\quad$ 通过预测发现准确率提升了，之前错分的image也正确分类，如：lake、urban residential，并且正确分类的prob都挺高，说明epoch提升可以提高test accurancy。

$\quad$ $\quad$ 在GID验证集上预测结果的混淆矩阵如上图所示，the model accuracy is 0.8933，下表为各类别的预测准确度（Precision ）、召回率（Recall）和特异度（Specificity）。

Classes\Merics	Precision	Recall	Specificity
arbor woodland	0.905	0.955	0.993
artificial grassland	0.95	0.96	0.996
dry cropland	0.922	0.89	0.995
garden plot	0.907	0.93	0.993
industrial land	0.822	0.875	0.986
irrigated land	0.859	0.73	0.991
lake	0.86	0.89	0.99
natural grassland	0.957	0.99	0.997
paddy field	0.925	0.98	0.994
pond	0.902	0.87	0.993
river	0.905	0.86	0.994
rural residential	0.881	0.775	0.992
shrub land	0.92	0.925	0.994
traffic land	0.936	0.945	0.995
urban residential	0.757	0.825	0.981

你可能感兴趣的:(Pytorch框架,深度学习,pytorch)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！小猪包333 写论文人工智能 AI写作深度学习计算机视觉
在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
损失函数与反向传播 Star_. PyTorch pytorch 深度学习 python
损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
【安装环境】配置MMTracking环境 xuanyu22 安装环境机器学习神经网络深度学习 python
版本v0.14.0安装torchnumpy的版本不能太高，否则后面安装时会发生冲突。先安装numpy，因为pytorch的安装会自动配置高版本numpy。condainstallnumpy=1.21.5mmtracking支持的torch版本有限，需要找到合适的condainstallpytorch==1.11.0torchvision==0.12.0cudatoolkit=10.2-cpytor
Python(PyTorch)和MATLAB及Rust和C++结构相似度指数测量导图亚图跨际 Python 交叉知识算法量化检查图像压缩质量低分辨率多光谱峰值信噪比端到端优化图像压缩手术机器人三维实景实时可微分渲染重建三维可视化
要点量化检查图像压缩质量低分辨率多光谱和高分辨率图像实现超分辨率分析图像质量图像索引/多尺度结构相似度指数和光谱角映射器及视觉信息保真度多种指标峰值信噪比和结构相似度指数测量结构相似性图像分类PNG和JPEG图像相似性近似算法图像压缩，视频压缩、端到端优化图像压缩、神经图像压缩、GPU变速图像压缩手术机器人深度估计算法重建三维可视化推理图像超分辨率算法模型三维实景实时可微分渲染算法MATLAB结构
【深度学习】训练过程中一个OOM的问题，太难查了 weixin_40293999 深度学习深度学习人工智能
现象：各位大佬又遇到过ubuntu的这个问题么？现象是在训练过程中，ssh上不去了，能ping通，没死机，但是ubunutu的pc侧的显示器，鼠标啥都不好用了。只能重启。问题原因：OOM了95G，尼玛！！！！pytorch爆内存了，然后journald假死了，在journald被watchdog干掉之后，系统就崩溃了。这种规模的爆内存一般，即使被oomkill了，也要卡半天的，确实会这样，能不能配
Pyorch中 nn.Conv1d 与 nn.Linear 的区别迪三 #NN_Layer 神经网络
即一维卷积层和全联接层的区别nn.Conv1d和nn.Linear都是PyTorch中的层，它们用于不同的目的，主要区别在于它们处理输入数据的方式和执行的操作类型。nn.Conv1d通过应用滑动过滤器来捕捉序列数据中的局部模式，适用于处理具有时间或序列结构的数据。nn.Linear通过将每个输入与每个输出相连接，捕捉全局关系，适用于将输入数据作为整体处理的任务。1.维度与输入nn.Conv1d（一
图片中的上采样，下采样和通道融合(up-sample, down-sample, channel confusion) 迪三 #图像处理_PyTorch 计算机视觉深度学习人工智能
前言以conv2d为例（即图片），Pytorch中输入的数据格式为tensor，格式为:[N,C,W,H,W]第一维N.代表图片个数，类似一个batch里面有N张图片第二维C.代表通道数，在模型中输入如果为彩色，常用RGB三色图，那么就是3维，即C=3。如果是黑白的，即灰度图，那么只有一个通道，即C=1第三维H.代表图片的高度，H的数量是图片像素的列数第四维W.代表图片的宽度，W的数量是图片像素的
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏租房推荐系统 58同城租房爬虫房源推荐系统房价预测系统计算机毕业设计机器学习深度学习人工智能 2401_84572577 程序员大数据 hadoop 人工智能
做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
深度学习-13-小语言模型之SmolLM的使用皮皮冰燃深度学习深度学习
文章附录1SmolLM概述1.1SmolLM简介1.2下载模型2运行2.1在CPU/GPU/多GPU上运行模型2.2使用torch.bfloat162.3通过位和字节的量化版本3应用示例4问题及解决4.1attention_mask和pad_token_id报错4.2max_new_tokens=205参考附录1SmolLM概述1.1SmolLM简介SmolLM是一系列尖端小型语言模型，提供三种规
基于深度学习的农作物病害检测 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的农作物病害检测利用卷积神经网络（CNN）、生成对抗网络（GAN）、Transformer等深度学习技术，自动识别和分类农作物的病害，帮助农业工作者提高作物管理效率、减少损失。1.农作物病害检测的挑战病害种类繁多：农作物病害的类型多样，不同病害在同一作物上的表现差异很大，同时同一种病害在不同生长阶段的症状也可能不同。环境影响：天气、光照、湿度等外部环境因素会影响农作物的表现，使得病害检
基于深度学习的文本引导的图像编辑 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的文本引导的图像编辑（Text-GuidedImageEditing）是一种通过自然语言文本指令对图像进行编辑或修改的技术。它结合了图像生成和自然语言处理（NLP）的最新进展，使用户能够通过描述性文本对图像内容进行精确的调整和操控。1.文本引导的图像编辑的挑战文本和图像之间的对齐：如何将文本中的语义信息准确地映射到图像中的特定区域或元素是一个关键挑战。这涉及到多模态数据的对齐和理解。编
深度学习--对抗生成网络（GAN, Generative Adversarial Network） Ambition_LAO 深度学习生成对抗网络
对抗生成网络（GAN,GenerativeAdversarialNetwork）是一种深度学习模型，由IanGoodfellow等人在2014年提出。GAN主要用于生成数据，通过两个神经网络相互对抗，来生成以假乱真的新数据。以下是对GAN的详细阐述，包括其概念、作用、核心要点、实现过程、代码实现和适用场景。1.概念GAN由两个神经网络组成：生成器（Generator）和判别器（Discrimina
深度学习：怎么看pth文件的参数奥利给少年深度学习人工智能
.pth文件是PyTorch模型的权重文件，它通常包含了训练好的模型的参数。要查看或使用这个文件，你可以按照以下步骤操作：1.确保你有模型的定义你需要有创建这个.pth文件时所用的模型的代码。这意味着你需要有模型的类定义和架构。2.加载模型权重使用PyTorch的load_state_dict方法来加载权重。这里是如何操作的：importtorchimporttorch.nnasnn#定义模型结构
chatgpt赋能python：如何在Python中安装Keras库？ turensu ChatGpt python chatgpt keras 计算机
如何在Python中安装Keras库？Keras是一个简单易用的神经网络库，由FrançoisChollet编写。它在Python编程语言中实现了深度学习的功能，可以使您更轻松地构建和试验不同类型的神经网络。如果您是一名Python开发人员，肯定会想知道如何在您的Python项目中安装Keras库。在本文中，我们将向您展示如何安装和配置Keras库。步骤1：安装Python要使用Keras库，您需
如何理解深度学习的训练过程奋斗的草莓熊深度学习人工智能 python scikit-learn virtualenv numpy pandas
文章目录1.训练是干什么？2.预训练模型进行训练，主要更改的是预训练模型的什么东西？1.训练是干什么？以yolov5为例子，训练的目的是把一组输入猫狗图像放到神经网络中，得到一个输出模型，这个模型下次可以直接用来识别哪个是猫，哪个是狗2.预训练模型进行训练，主要更改的是预训练模型的什么东西？超参数（Hyperparameters）：这是模型结构中定义的参数，比如：卷积核大小（kernel_size
Keras深度学习框架入门及实战指南司莹嫣Maude
Keras深度学习框架入门及实战指南keraskeras-team/keras:是一个基于Python的深度学习库，它没有使用数据库。适合用于深度学习任务的开发和实现，特别是对于需要使用Python深度学习库的场景。特点是深度学习库、Python、无数据库。项目地址:https://gitcode.com/gh_mirrors/ke/keras一、项目介绍Keras简介Keras是一款高级神经网络
深度学习驱动的车牌识别：技术演进与未来挑战逼子歌深度学习车牌识别神经网络字符识别 YOLO 卷积神经网络
一、引言1.1研究背景在当今社会，智能交通系统的发展日益重要，而车牌识别作为其关键组成部分，发挥着至关重要的作用。车牌识别技术广泛应用于交通管理、停车场管理、安防监控等领域。在交通管理中，它可以用于车辆识别、交通违法监控和车流统计等，提高交通管理的效率和准确性。在停车场管理中，实现车辆的自动识别和收费，提升管理和服务水平。在安防监控领域，可用于追踪嫌疑人及犯罪行为。深度学习的出现为车牌识别带来了重
每天五分钟玩转深度学习PyTorch：模型参数优化器torch.optim 幻风_huanfeng 深度学习框架pytorch 深度学习 pytorch 人工智能神经网络机器学习优化算法
本文重点在机器学习或者深度学习中，我们需要通过修改参数使得损失函数最小化(或最大化)，优化算法就是一种调整模型参数更新的策略。在pytorch中定义了优化器optim，我们可以使用它调用封装好的优化算法，然后传递给它神经网络模型参数，就可以对模型进行优化。本文是学习第6步(优化器)，参考链接pytorch的学习路线随机梯度下降算法在深度学习和机器学习中，梯度下降算法是最常用的参数更新方法，它的公式
什么是AIGC？有哪些免费工具？ chent_某位 AIGC
AIGC（AIGeneratedContent），即“人工智能生成内容”，是指通过人工智能技术自动生成各种类型的数字内容。AIGC让机器能够根据输入的信息或数据生成符合人类需求的文本、图像、音频、视频等内容，极大提高了内容创作的效率。AIGC的背景与起源随着深度学习和自然语言处理技术的快速发展，人工智能已经不再局限于简单的任务，如分类、预测和数据分析，而是具备了生成内容的能力。生成式AI模型，如O
戴尔笔记本win8系统改装win7系统 sophia天雪 win7 戴尔改装系统 win8
戴尔win8 系统改装win7 系统详述第一步：使用U盘制作虚拟光驱： 1）下载安装UltraISO：注册码可以在网上搜索。 2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文
BeanUtils.copyProperties使用笔记 bylijinnan java
BeanUtils.copyProperties VS PropertyUtils.copyProperties 两者最大的区别是： BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
MyEclipse中文乱码问题 0624chenhong MyEclipse
一、设置新建常见文件的默认编码格式，也就是文件保存的格式。在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 Window-->Preferences-->General -
发送邮件不懂事的小屁孩 send email
import org.apache.commons.mail.EmailAttachment; import org.apache.commons.mail.EmailException; import org.apache.commons.mail.HtmlEmail; import org.apache.commons.mail.MultiPartEmail;
动画合集换个号韩国红果果 html css
动画指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 1 transition 制作鼠标滑过图片时的放大效果 css .wrap{ width: 340px;height: 340px; position: absolute; top: 30%; left: 20%; overflow: hidden; bor
网络最常见的攻击方式竟然是SQL注入蓝儿唯美 sql注入
NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
java笔记2 a-john java
类的封装： 1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 4，封装的特性： 4.1设置
[Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx” aijuans 学习Android遇到的错误
最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。我就看了一下，和她要了psd的文件，还好我有一点
自己写的一个繁体到简体的转换程序 asialee java 转换繁体 filter 简体
今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。实现的思路是重载request的调取参数的几个方法，然后做下转换。
android意图和意图监听器技术百合不是茶 android 显示意图隐式意图意图监听器
Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。隐式意图;不指明调用的名称,根据设
spring3中新增的@value注解 bijian1013 java spring @Value
在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 1.首先在applicationContext.xml中加入： <beans xmlns="http://www.springframework.
Jboss启用CXF日志 sunjing log jboss CXF
1. 在standalone.xml配置文件中添加system-properties： <system-properties> <property name="org.apache.cxf.logging.enabled" value=&
【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码 bit1129 centos
编译必需的软件 Firebugs3.0.0 Maven3.2.3 Ant JDK1.7.0_67 protobuf-2.5.0 Hadoop 2.5.2源码包 Firebugs3.0.0 http://sourceforge.jp/projects/sfnet_findbug
struts2验证框架的使用和扩展白糖_ 框架 xml bean struts 正则表达式
struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。本文介绍一下struts2通过xml文件进行校验的方法并说
记录-感悟 braveCS 感悟
再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。 2015-1-11 1. 能在工作之余学习感兴趣的东西已经很幸福了； 2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 4. 一天内集中一个定长时间段看最新资讯和偏流式博
编程之美-数组中最长递增子序列 bylijinnan 编程之美
import java.util.Arrays; import java.util.Random; public class LongestAccendingSubSequence { /** * 编程之美数组中最长递增子序列 * 书上的解法容易理解 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组， * 然后求排序后的数组与原数
读书笔记5 chengxuyuancsdn 重复提交 struts2的token验证
1、重复提交 2、struts2的token验证 3、用response返回xml时的注意 1、重复提交 (1)应用场景 (1-1)点击提交按钮两次。 (1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 (1-3)刷新页面 (1-4)使用浏览器历史记录重复提交表单。 (1-5)浏览器重复的 HTTP 请求。 (2)解决方法 (2-1)禁掉提交按钮 (2-2)
[时空与探索]全球联合进行第二次费城实验的可能性 comsci
二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验至今给我们大家留下很多迷团..... 关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了在这里,我的意思是,现在
easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符 daizj oracle ORA-12154
用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 Copyright (c) 198
简单排序:归并排序 dieslrae 归并排序
public void mergeSort(int[] array){ int temp = array.length/2; if(temp == 0){ return; } int[] a = new int[temp]; int
C语言中字符串的\0和空格 dcj3sjt126com c
\0 为字符串结束符，比如说： abcd (空格)cdefg；存入数组时，空格作为一个字符占有一个字节的空间，我们
解决Composer国内速度慢的办法 dcj3sjt126com Composer
用法：有两种方式启用本镜像服务： 1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下 1 2 3 4 5
高效可伸缩的结果缓存 shuizhaosi888 高效可伸缩的结果缓存
/** * 要执行的算法，返回结果v */ public interface Computable<A, V> { public V comput(final A arg); } /** * 用于缓存数据 */ public class Memoizer<A, V> implements Computable<A,
三点定位的算法 haoningabc c 算法
三点定位，已知a,b,c三个顶点的x,y坐标和三个点都z坐标的距离，la，lb,lc 求z点的坐标原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求但是，由于三个点的距离可能不准，不一定会有结果，所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 运行 gcc -lm test.c test.c代码如下 #include "stdi
epoll使用详解 jimmee c linux 服务端编程 epoll
epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
Hibernate对Enum的映射的基本使用方法 linzx0212 enum Hibernate
枚举 /** * 性别枚举 */ public enum Gender { MALE(0), FEMALE(1), OTHER(2); private Gender(int i) { this.i = i; } private int i; public int getI
第10章高级事件（下） onestopweb 事件
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
孙子兵法 roadrunners 孙子兵法
始计第一孙子曰：兵者，国之大事，死生之地，存亡之道，不可不察也。故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校之以计，而索其情，曰
MySQL双向复制 tomcat_oracle mysql
本文包括: 主机配置从机配置建立主-从复制建立双向复制背景按照以下简单的步骤: 参考一下：在机器A配置主机(192.168.1.30) 在机器B配置从机(192.168.1.29) 我们可以使用下面的步骤来实现这一点步骤1：机器A设置主机在主机中打开配置文件 ,
zoj 3822 Domination(dp) 阿尔萨斯 Mina
题目链接：zoj 3822 Domination 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理