1.2.1.190125

Author: LatentLinker

Generate_image/dataset.py renamed to Generate_image/data/dataset.py

@@ -1,18 +1,16 @@
-# coding:utf8
 import os
-import ipdb
 import torch as t
 import torchvision as tv
 import tqdm
-from model import NetG, NetD
+from models import NetG, NetD
 from torchnet.meter import AverageValueMeter
 from config import opt
 
 
 def train(**kwargs):
     opt._parse(kwargs)
     if opt.vis:
-        from visualize import Visualizer
+        from utils.visualize import Visualizer
         vis = Visualizer(opt.env)
 
     # 数据

Generate_image/main.py

@@ -0,0 +1 @@
+from .model import NetG, NetD

Generate_image/models/__init__.py

@@ -1,4 +1,3 @@
-# coding:utf8
 from torch import nn
 
 

Generate_image/model.py renamed to Generate_image/models/model.py

@@ -8,22 +8,22 @@ class DefaultConfig(object):
     env = 'opalus_recognltion'  # visdom 环境
     vis_port = 8097  # visdom 端口
     image_size = 224
-    model = 'ResNet152'  # 使用的模型，名字必须与models/__init__.py中的名字一致
+    model = 'AlexNet1'  # 使用的模型，名字必须与models/__init__.py中的名字一致
 
     data_root = "/home/tian/Desktop/spiders/design/design/spiders/image"  # 数据集存放路径
     # load_model_path = None  # 加载训练的模型的路径，为None代表不加载
-    load_model_path = 'checkpoint/ResNet152_0124_11-57-28.pth.tar'
+    load_model_path = 'checkpoint/AlexNet1_0125_18-08-46.pth.tar'
 
     batch_size = 16  # 每批训练数据的个数,显存不足,适当减少
     use_gpu = True  # user GPU or not
     num_workers = 4  # how many workers for loading data
     print_freq = 2  # print info every N batch
-    vis = False  # 是否使用visdom可视化
+    vis = True  # 是否使用visdom可视化
 
     cate_classes = get_classes(data_root)['class2num']  # 分类列表
     num_classes = len(cate_classes)  # 分类个数
-    pretrained = False  # 不加载预训练
-    # pretrained = True  # 加载预训练模型
+    # pretrained = False  # 不加载预训练
+    pretrained = True  # 加载预训练模型
 
     max_epoch = 10  # 学习次数
     lr = 0.001  # initial learning rate

Generate_image/visualize.py renamed to Generate_image/utils/visualize.py

@@ -1,4 +1,3 @@
-# coding:utf8
 from PIL import Image
 from torch.utils import data
 from torchvision import transforms as T
@@ -63,9 +62,9 @@ def __getitem__(self, index):
         # img = cv2.imread(img_path)
         # img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
         data = Image.open(img_path)
-        data = data.convert("RGB")
+        data = data.convert("RGB")  # 有4通道图片转化为长通道
         data = self.transforms(data)
-        return data, label
+        return data, label  # 返回数据级标签
 
     def __len__(self):
         return len(self.imgs)

Image_recognition/Authority/.gitkeep

@@ -20,7 +20,7 @@ def test(**kwargs):
         model = getattr(models, opt.model)()
         if opt.load_model_path:
             checkpoint = t.load(opt.load_model_path)
-            model.load_state_dict(checkpoint["state_dict"])
+            model.load_state_dict(checkpoint["state_dict"]) # 加载模型
         model.to(opt.device)
         model.eval()  # 把module设成测试模式，对Dropout和BatchNorm有影响
         # data
@@ -46,13 +46,13 @@ def test(**kwargs):
 
 
 def recognition(**kwargs):
-    with t.no_grad():
-        opt._parse(kwargs)  # 用来标志计算要被计算图隔离出去
+    with t.no_grad():   # 用来标志计算要被计算图隔离出去
+        opt._parse(kwargs)
         image = image_loader(opt.url)
         model = getattr(models, opt.model)()
         if opt.load_model_path:
             checkpoint = t.load(opt.load_model_path)
-            model.load_state_dict(checkpoint["state_dict"])  # 预加载模型
+            model.load_state_dict(checkpoint["state_dict"])  # 加载模型
         model.to(opt.device)
         model.eval()
         image = image.view(1, 3, opt.image_size, opt.image_size).to(opt.device)  # 转换image
@@ -68,7 +68,7 @@ def train(**kwargs):
     if opt.vis:
         vis = Visualizer(opt.env, port=opt.vis_port)  # 开启visdom 可视化
     previous_loss = 1e10  # 上次学习的loss
-    best_precision = 0
+    best_precision = 0  # 最好的精确度
     start_epoch = 0
     lr = opt.lr
     # step1: criterion and optimizer
@@ -119,14 +119,14 @@ def train(**kwargs):
             target = label.to(opt.device)
 
             score = model(input)
-            # loss = criterion(score, target)  # 计算损失
-            loss = criterion(score[0], target)  # 计算损失   Inception3网络
+            loss = criterion(score, target)  # 计算损失
+            # loss = criterion(score[0], target)  # 计算损失   Inception3网络
             optimizer.zero_grad()  # 参数梯度设成0
             loss.backward()  # 反向传播
             optimizer.step()  # 更新参数
             # meters update and visualize
-            # precision1_train, precision2_train = accuracy(score, target, topk=(1, 2))
-            precision1_train, precision2_train = accuracy(score[0], target, topk=(1, 2))  # Inception3网络
+            precision1_train, precision2_train = accuracy(score, target, topk=(1, 2))
+            # precision1_train, precision2_train = accuracy(score[0], target, topk=(1, 2))  # Inception3网络
             train_losses.update(loss.item(), input.size(0))
             train_top1.update(precision1_train[0].item(), input.size(0))
             train_progressor.current_loss = train_losses.avg
@@ -137,11 +137,11 @@ def train(**kwargs):
                 else:
                     print('loss', train_losses.val)
             train_progressor()
-            # train_progressor.done()  #
+        # train_progressor.done()  # 保存训练结果为txt
         # validate and visualize
         valid_loss = val(model, epoch, criterion, val_dataloader)  # 校验模型
         best_precision = valid_loss[1]
-        # is_best = valid_loss[1] > best_precision  # 准确率比较，如果此次比上次大　　保存模型
+        # is_best = valid_loss[1] > best_precision  # 精确度比较，如果此次比上次大　　保存模型
         # best_precision = max(valid_loss[1], best_precision)
         # if is_best:
         model.save({
@@ -189,7 +189,7 @@ def val(model, epoch, criterion, dataloader):
             val_progressor.current_top1 = top1.avg
             val_progressor()
 
-        # val_progressor.done()
+        # val_progressor.done() # 保存校验结果为txt
         return [losses.avg, top1.avg]
 
 

Image_recognition/config.py

@@ -2,12 +2,20 @@
 from config import opt
 from torchvision.models import AlexNet
 import torch
+import torch.nn as nn
 
 
-def alexnet(pretrained=False, **kwargs): # 224*224
+def alexnet(pretrained=False, **kwargs):  # 224*224
     if pretrained:
         model = AlexNet(**kwargs)
-        model.load_state_dict(torch.load('./checkpoint/inception_v3_google-1a9a5a14.pth'))
+        pretrained_state_dict = torch.load(
+            './Authority/alexnet-owt-4df8aa71.pth')
+        now_state_dict = model.state_dict()  # 返回model模块的字典
+        pretrained_state_dict.pop('classifier.6.weight')
+        pretrained_state_dict.pop('classifier.6.bias')
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(
+            now_state_dict)
         return model
     return AlexNet(**kwargs)
 
@@ -25,9 +33,10 @@ def get_optimizer(self, lr, weight_decay):
         if not opt.pretrained:
             return super(AlexNet1, self).get_optimizer(lr, weight_decay)
         else:
-            return torch.optim.Adam(self.model.fc.parameters(), lr=lr, weight_decay=weight_decay)
+            return torch.optim.Adam(self.model.classifier[6].parameters(), lr=lr, weight_decay=weight_decay)
 
 
 if __name__ == '__main__':
     a = AlexNet1()
-    print(a)
+    for i in a.model.classifier[6]:
+        print(i)

Image_recognition/data/dataset.py

@@ -11,14 +11,23 @@ def densenet201(pretrained=False, **kwargs):
                          **kwargs)
         pattern = re.compile(
             r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$')
-        state_dict = torch.load('./checkpoint/inception_v3_google-1a9a5a14.pth')
-        for key in list(state_dict.keys()):
+        pretrained_state_dict = torch.load(
+            './Authority/densenet201-c1103571.pth')  # load_url函数根据model_urls字典下载或导入相应的预训练模型
+        for key in list(pretrained_state_dict.keys()):
             res = pattern.match(key)
             if res:
                 new_key = res.group(1) + res.group(2)
-                state_dict[new_key] = state_dict[key]
-                del state_dict[key]
-        model.load_state_dict(state_dict)
+                pretrained_state_dict[new_key] = pretrained_state_dict[key]
+                del pretrained_state_dict[key]
+        now_state_dict = model.state_dict()  # 返回model模块的字典
+        pretrained_state_dict.pop('classifier.weight')
+        pretrained_state_dict.pop('classifier.bias')
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(
+            now_state_dict)
+        # 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，
+        # 这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，
+        # 该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
         return model
     return DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 48, 32),
                     **kwargs)
@@ -37,7 +46,7 @@ def get_optimizer(self, lr, weight_decay):
         if not opt.pretrained:
             return super(DenseNet201, self).get_optimizer(lr, weight_decay)
         else:
-            return torch.optim.Adam(self.model.fc.parameters(), lr=lr, weight_decay=weight_decay)
+            return torch.optim.Adam(self.model.classifier.parameters(), lr=lr, weight_decay=weight_decay)
 
 
 if __name__ == '__main__':

Image_recognition/main.py

@@ -11,14 +11,23 @@ def densenet161(pretrained=False, **kwargs):
                          **kwargs)
         pattern = re.compile(
             r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$')
-        state_dict = torch.load('./checkpoint/inception_v3_google-1a9a5a14.pth')
-        for key in list(state_dict.keys()):
+        pretrained_state_dict = torch.load(
+            './Authority/densenet161-8d451a50.pth')  # load_url函数根据model_urls字典下载或导入相应的预训练模型
+        for key in list(pretrained_state_dict.keys()):
             res = pattern.match(key)
             if res:
                 new_key = res.group(1) + res.group(2)
-                state_dict[new_key] = state_dict[key]
-                del state_dict[key]
-        model.load_state_dict(state_dict)
+                pretrained_state_dict[new_key] = pretrained_state_dict[key]
+                del pretrained_state_dict[key]
+        now_state_dict = model.state_dict()  # 返回model模块的字典
+        pretrained_state_dict.pop('classifier.weight')
+        pretrained_state_dict.pop('classifier.bias')
+        now_state_dict.update(pretrained_state_dict)
+        model.load_state_dict(
+            now_state_dict)
+        # 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，
+        # 这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，
+        # 该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
         return model
     return DenseNet(num_init_features=96, growth_rate=48, block_config=(6, 12, 36, 24),
                     **kwargs)

Image_recognition/models/alexnet.py

@@ -18,7 +18,10 @@ def inception_v3(pretrained=False, **kwargs):  # 299*299
         pretrained_state_dict.pop('fc.bias')
         now_state_dict.update(pretrained_state_dict)
         model.load_state_dict(
-            now_state_dict)  # 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
+            now_state_dict)
+        # 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，
+        # 这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，
+        # 该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
         return model
     return Inception3(**kwargs)
 

Image_recognition/models/denseNet201.py

@@ -51,11 +51,14 @@ def resnet152(pretrained=False, **kwargs):
         pretrained_state_dict = torch.load(
             './Authority/resnet152-b121ed2d.pth')  # load_url函数根据model_urls字典下载或导入相应的预训练模型
         now_state_dict = model.state_dict()  # 返回model模块的字典
-        pretrained_state_dict.pop('fc.weight')
+        pretrained_state_dict.pop('fc.weight')  # 排除全连接层的参数(全连接层返回分类个数)
         pretrained_state_dict.pop('fc.bias')
         now_state_dict.update(pretrained_state_dict)
         model.load_state_dict(
-            now_state_dict)  # 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
+            now_state_dict)
+        # 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，
+        # 这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，
+        # 该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
         return model
     return ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
 

Image_recognition/models/densenet161.py

@@ -1,5 +1,6 @@
 import os
 
+
 # 获取目录下所有分类和图片数据
 def get_classes(path):
     class2num = {}

Image_recognition/models/inceptionv3.py

@@ -6,21 +6,21 @@ class ImageFolderSplitter:
     def __init__(self, path, train_size=0.8):
         self.path = path
         self.train_size = train_size
-        self.x_train = []
-        self.x_valid = []
-        self.y_train = []
-        self.y_valid = []
+        self.x_train = []  # 训练图片
+        self.x_valid = []  # 训练标签
+        self.y_train = []  # 测试图片
+        self.y_valid = []  # 测试标签
         self.data_x_path = get_classes(path)['data_x_path']
         self.data_y_label = get_classes(path)['data_y_label']
-        # 80%的训练集，20%的测试机集
+        # 随机80%的训练集和20%的测试集
         self.x_train, self.x_valid, self.y_train, self.y_valid = train_test_split(self.data_x_path, self.data_y_label,
                                                                                   shuffle=True,
                                                                                   train_size=self.train_size)
 
-    def getTrainingDataset(self):
+    def getTrainingDataset(self):  # 返回训练级
         return self.x_train, self.y_train
 
-    def getValidationDataset(self):
+    def getValidationDataset(self):  # 返回测试集
         return self.x_valid, self.y_valid
 
 

Image_recognition/models/resnet152.py

@@ -1,6 +1,6 @@
 import sys
 
-
+# 进度条
 class ProgressBar(object):
     DEFAULT = "Progress: %(bar)s %(percent)3d%%"
 

Image_recognition/utils/get_classes.py

@@ -1,12 +1,10 @@
-import shutil
 import time
 
 import torch
 from config import opt
-import os
 
 
-# 仪表
+# 仪表盘
 class AverageMeter(object):
     """Computes and stores the average and current value"""
 
@@ -28,7 +26,6 @@ def update(self, val, n=1):
 
 # 准确率
 def accuracy(output, target, topk=(1,)):
-    """Computes the accuracy over the k top predictions for the specified values of k"""
     with torch.no_grad():
         maxk = max(topk)
         batch_size = target.size(0)

Image_recognition/utils/imagefolder_splitter.py

@@ -3,7 +3,7 @@
 import time
 import numpy as np
 
-
+# visdom 可视化工具
 class Visualizer(object):
     """
     封装了visdom的基本操作，但是你仍然可以通过`self.vis.function`