├── README.md
├── data
    ├── dataset_k1.json
    └── dataset_test.json
├── dataset.py
├── fastai_version
    └── to_be_continue.txt
├── main.py
├── tools
    ├── cate_distribute.png
    ├── data_analysis.py
    └── re_clean_data.py
├── trainer.py
└── untils.py


/README.md:
--------------------------------------------------------------------------------
 1 | # DF分类
 2 | 模型调用基于[pretrainedmodels](https://github.com/Cadene/pretrained-models.pytorch) 和 [effcientnet](https://github.com/lukemelas/EfficientNet-PyTorch)，模型与其详细信息可在链接中看到；
 3 | 
 4 | **单模表现(A榜)：**
 5 | **effcientnet-b4**:_0.547_
 6 | **senet154**: _0.551_(这个模型比较大，量力而行)
 7 | **inceptionresnetv2**: _0.522_
 8 | 
 9 | (TTA为左右翻转输出取平均)
10 | 
11 | se154+effb4 ensemble *0.571*
12 | 
13 | ### Requirements
14 | 
15 | ```angular2html
16 | opencv-python
17 | torchsummary
18 | scikit-learn==0.21.2
19 | albumentations==0.3.3
20 | pytorch>=1.0.0
21 | pretrainedmodels==0.7.4
22 | efficientnet-pytorch==0.4.0
23 | ```
24 | ### 数据
25 | 单标签分类，数据集经过处理，对于多个类别的图片，**使用总体数量最多的作为其类别**。
26 | 
27 | 数据集索引为Json格式，位于`./data/dataset_k1.json`。其中4/5用于训练，1/5用于验证。可以根据json自己划分一下。
28 | 
29 | 测试数据集索引为`./data/dataset_test.json`
30 | 
31 | ### 训练
32 | 训练参数在`main.py`中查看，都有相关解释；
33 | 
34 | 部分重要的参数在`untils.py`中，可以检查一下，写得比较粗糙难免有一些错误：**创建优化器**`build_optimizer()`、**初始化模型**`build_cls_model()`*(支持修改relu激活函数为mish,但不建议使用，显存会炸)*、**损失函数**`build_loss_function()`(*单标签就用ce和smooth感觉就足够了*)
35 | 
36 | ### 测试
37 | 测试部分`main.py`的`test(option_path,test_image_folder, save_path,model_path,test_info_path)`
38 | **option_path**：训练过程保存了训练参数的json文件，就在模型保存的目录下。
39 | **test_image_folder**：测试图片文件夹。
40 | **save_path**：保存predictions的位置，以dict形式保存，`{'IMAGE_NAME':[OUTPUT_LIST]}`,输出的list是最后fc的输出，长度为类别数，这样保存是为了方便融模型，至于怎么融可自由发挥。
41 | **model_path**：模型位置。多gpu保存的在`resum_load()`里面改参数。
42 | 
43 | 
44 | ### 可能有用的
45 | 
46 | **初始学习率寻找**：参考fastai的[lr_finder](https://sgugger.github.io/how-do-you-find-a-good-learning-rate.html)
47 | ```
48 | import matplotlib.pyplot as plt
49 | trainer = MultiClsTrainer(opt)
50 | logs = trainer.lr_finder()
51 | plt.plot(logs['lr'][10:-5],logs['loss'][10:-5])
52 | ```
53 | 
54 | **预裁剪**：对于过长的图片，裁剪掉下方的一部分，再进行训练。
55 | 
56 | **split_weights**：权重衰减不优化再bias上，原理实验等谷歌。
57 | 
58 | **数据简单EDA**:位于tools文件夹
59 | 


--------------------------------------------------------------------------------
/dataset.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- encoding: utf-8 -*-
  3 | '''
  4 | @File           :   dataset.py
  5 | @Desciption     :   None
  6 | @Modify Time      @Author    @Version 
  7 | ------------      -------    --------  
  8 | 2019/9/26 13:36   Daic       1.0
  9 | '''
 10 | import os
 11 | import cv2
 12 | import json
 13 | import torch
 14 | import numpy as np
 15 | import albumentations as albu
 16 | from torch.utils.data import  DataLoader
 17 | from torch.utils.data import  Dataset as BaseDB
 18 | 
 19 | 
 20 | def SkyCrop(img):
 21 |     #img [h,w,3]
 22 |     if img.shape[1]*1.8<img.shape[0]:
 23 |         #too high
 24 |         fix_len = round(img.shape[1]*1.4)
 25 |         return img[:fix_len,::,::].astype(int)
 26 |     else:
 27 |         return img
 28 | 
 29 | def get_training_augmentation():
 30 |     #just for train
 31 |     train_transform = [
 32 |         albu.OneOf(
 33 |             [
 34 |                 albu.NoOp(p=1),
 35 |                 albu.RandomResizedCrop(512, 512, scale=(0.5, 1.0), ratio=(0.8, 1.2), p=1.0),
 36 |                 albu.Rotate(limit=(-20, 20), p=1.),
 37 |             ],
 38 |             p=0.8,
 39 |         ),
 40 |         albu.HorizontalFlip(p=0.5),
 41 |     ]
 42 |     return albu.Compose(train_transform)
 43 | 
 44 | def get_preprocess(size=224):
 45 |     res=[
 46 |         albu.Resize(size, size),
 47 |         albu.Normalize(
 48 |             mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)
 49 |         ),
 50 |     ]
 51 |     return albu.Compose(res)
 52 | def get_flip_preprocess(size=224):
 53 |     res=[
 54 |         albu.HorizontalFlip(p=1.),
 55 |         albu.Resize(size, size),
 56 |         albu.Normalize(
 57 |             mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)
 58 |         ),
 59 |     ]
 60 |     return albu.Compose(res)
 61 | 
 62 | class ClsSteelDataset(BaseDB):
 63 |     def __init__(self,opt, phase ,augmentation=None):
 64 |         self.phase = phase
 65 |         self.size = opt.size
 66 |         self.precrop = opt.precrop
 67 | 
 68 |         self.data_type = opt.data_type
 69 |         print("data type : %s"%self.data_type)
 70 | 
 71 |         self.image_path = opt.image_path
 72 | 
 73 |         self.infos = json.load(open(opt.input_json))
 74 | 
 75 |         if self.data_type == 'kfolder':
 76 |             self.dataset = [tmp for tmp in self.infos if tmp['split'] == self.phase]
 77 | 
 78 |         elif self.data_type == 'all':
 79 |             self.dataset = self.infos
 80 | 
 81 |         else:
 82 |             raise Exception("Unsupported data type {}".format(self.data_type))
 83 | 
 84 | 
 85 |         self.augmentation = augmentation
 86 | 
 87 |         self.preprocess = get_preprocess(size=self.size)
 88 | 
 89 |     def __getitem__(self, idx):
 90 |         name = self.dataset[idx]['img']
 91 |         img = cv2.imread(os.path.join(self.image_path, self.dataset[idx]['img']))
 92 | 
 93 |         if self.precrop:
 94 |             img = SkyCrop(img).astype(np.uint8)
 95 |         else:
 96 |             img = img.astype(np.uint8)
 97 | 
 98 | 
 99 |         if self.phase == 'test':
100 |             label = -1
101 |         else:
102 |             label = self.dataset[idx]['cate']
103 | 
104 |         if self.phase == 'train':
105 |             sample = self.augmentation(image=img)
106 |             img = sample['image']
107 | 
108 |         img = self.preprocess(image=img)['image']# size size 3
109 |         img = torch.from_numpy(img).permute(2,0,1).float()#
110 | 
111 |         return img , label , name#, mask
112 | 
113 |     def __len__(self):
114 |         return len(self.dataset)
115 | 


--------------------------------------------------------------------------------
/fastai_version/to_be_continue.txt:
--------------------------------------------------------------------------------
1 | fastai版本baseline，便于比赛快速迭代
2 | 


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- encoding: utf-8 -*-
  3 | '''
  4 | @File           :   main_cls.py
  5 | @Desciption     :   None
  6 | @Modify Time      @Author    @Version
  7 | ------------      -------    --------
  8 | 2019/10/6 1:25   Daic       1.0
  9 | '''
 10 | import os
 11 | import json
 12 | import argparse
 13 | from untils import *
 14 | from trainer import *
 15 | 
 16 | parser = argparse.ArgumentParser()
 17 | # Input paths
 18 | parser.add_argument('--input_json', type=str, default='./data/dataset_k1.json')
 19 | parser.add_argument('--image_path', type=str, default='./data/train')#'./data/train')
 20 | #output_path
 21 | parser.add_argument('--out_path', type=str,  default='./data/save')
 22 | parser.add_argument('--train_name', type=str,  default='resnet50')
 23 | #dataset
 24 | parser.add_argument('--data_type', type=str,  default='kfolder',
 25 |                     help='kfolder: using K folder split ; train_all: train all images with out validation ')
 26 | parser.add_argument('--size', type=int,  default=224)
 27 | parser.add_argument('--precrop', type=bool,  default=True,
 28 |                     help='crop image which is too high or wide')
 29 | #optimizer
 30 | ##more detail can be found in untils.build_optimizer function
 31 | parser.add_argument('--optimizer', type=str,  default='sgdmom')
 32 | parser.add_argument('--lr', type=float,  default=3e-4)
 33 | parser.add_argument('--weight_decay', type=float,  default=1e-5)
 34 | parser.add_argument('--momentum', type=float,  default=0.9)
 35 | parser.add_argument('--split_weights', type=bool,  default=True,
 36 |                     help='no weight decay for bias: from bag of tricks')
 37 | 
 38 | ##you can define your lr schedule in traner.py
 39 | ##if use epoch schedule
 40 | parser.add_argument('--decay_step', type=list,  default=[4,8,12])
 41 | parser.add_argument('--decay_rate', type=float,  default=0.6)
 42 | 
 43 | #model
 44 | parser.add_argument('--cnn', type=str,  default='resnet50')
 45 | parser.add_argument('--num_class', type=int,  default=29)
 46 | parser.add_argument('--loss', type=str,  default='lsr',
 47 |                     help='lsr:      label smooth ce with default 0.1 smooth factor'
 48 |                          'ce :      Cross Entropy Loss'
 49 |                          '!Carefully use:'
 50 |                          'bce:      nn.BCELoss()'
 51 |                          'bcel:     nn.BCEWithLogitsLoss()'
 52 |                          'focal:    Focal Loss')
 53 | 
 54 | #train and eval
 55 | parser.add_argument('--train_bch', type=int,  default=64)
 56 | parser.add_argument('--val_bch', type=int,  default=64)
 57 | parser.add_argument('--num_worker', type=int,  default=8)
 58 | parser.add_argument('--max_epoch', type=int,  default=20)
 59 | 
 60 | parser.add_argument('--seed', type=int,  default=1996)
 61 | parser.add_argument('--gpu_id', type=str,  default='2')
 62 | 
 63 | #resume
 64 | parser.add_argument('--resume_path', type=str,  default='')
 65 | 
 66 | def train():
 67 |     opt = parser.parse_args()
 68 |     dopt = vars(opt)
 69 |     #make save path and save config:
 70 |     save_path = os.path.join(opt.out_path, opt.train_name)
 71 |     if not os.path.isdir(save_path):
 72 |         os.mkdir(save_path)
 73 |     opt_save_path = os.path.join(opt.out_path,opt.train_name,'OPTIONS_'+opt.cnn+'.json')
 74 |     json.dump(dopt,open(opt_save_path,'w'))
 75 |     #fix gpu
 76 |     os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpu_id
 77 |     #fix seed
 78 |     random.seed(opt.seed)
 79 |     torch.manual_seed(opt.seed)
 80 |     torch.cuda.manual_seed(opt.seed)
 81 |     torch.cuda.manual_seed_all(opt.seed)  # if you are using multi-GPU.
 82 |     np.random.seed(opt.seed)  # Numpy module.
 83 |     os.environ["PYTHONHASHSEED"] = str(opt.seed)
 84 |     np.random.seed(opt.seed)
 85 |     torch.cuda.manual_seed(opt.seed)
 86 |     torch.backends.cudnn.deterministic = True
 87 | 
 88 | 
 89 |     trainer = MultiClsTrainer(opt)
 90 |     #trainer.lr_finder()
 91 |     trainer.train_model()
 92 | 
 93 | def load_options(options,dict):
 94 |     for k in dict:
 95 |         vars(options)[k] = dict[k]
 96 |     return options
 97 | 
 98 | def test(option_path,
 99 |          test_image_folder,
100 |          save_path,
101 |          model_path,
102 |          test_info_path = './data/dataset_test.json'):
103 | 
104 |     opt = parser.parse_args()
105 |     opt = load_options(opt,json.load(open(option_path)))
106 |     os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpu_id
107 | 
108 |     trainer = MultiClsTrainer(opt)
109 |     trainer.test_model(test_info_path,test_image_folder,save_path,model_path)
110 | 
111 | 


--------------------------------------------------------------------------------
/tools/cate_distribute.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daic115/DF_Cloud_Type_Classification/1ca6a2c6275ac859a5fd63ec4cfc9d9c2bbd55d2/tools/cate_distribute.png


--------------------------------------------------------------------------------
/tools/data_analysis.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- encoding: utf-8 -*-
  3 | '''
  4 | @File           :   data_analysis.py
  5 | @Desciption     :   None
  6 | @Modify Time      @Author    @Version 
  7 | ------------      -------    --------  
  8 | 2019/10/6 23:56   Daic       1.0        
  9 | '''
 10 | '''
 11 | ===============================size：
 12 | threathod: 1.3:
 13 | too high = 2323
 14 | too wide = 1705
 15 | 
 16 | threathod: 1.2:
 17 | too high = 2328
 18 | too wide = 1717
 19 | '''
 20 | '''
 21 | ================================k1 cate distribute
 22 |             train     val    arg_times
 23 | big mid 1
 24 | cate: 0      29        9        20
 25 | cate: 1    1458      438        1
 26 | cate: 2      11        5        40
 27 | cate: 3      68       22        10
 28 | cate: 4      73       35        10
 29 | cate: 5       4        0        0
 30 | cate: 6     115       33        10
 31 | cate: 7     238       80        6
 32 | 
 33 | big high 2
 34 | cate: 8       7        3        20
 35 | cate: 9    1057      377        10        
 36 | cate:10      93       27        10
 37 | cate:11       6        2        10
 38 | cate:12      51       13        16
 39 | cate:13      15        7        30
 40 | cate:14     155       46        6
 41 | 
 42 | big low 0
 43 | cate:15      33        7        10
 44 | cate:16     120       37        8
 45 | cate:17     747      264        1
 46 | cate:18     500      160        2
 47 | cate:19     625      215        2
 48 | cate:20     179       65        4
 49 | cate:21      68       18        10
 50 | cate:22      21        3        10
 51 | cate:23      42       12        10
 52 | cate:24    1230      382        10
 53 | cate:25      20        4        10
 54 | cate:26     408      126        2
 55 | cate:27     337      110        3
 56 | cate:28       1        0        0
 57 | '''
 58 | 
 59 | '''
 60 | ============================label_countting:
 61 | single label : 10211
 62 | mutilabel    : 454
 63 | {'1': 38,
 64 |  '10': 1434,
 65 |  '10;18': 95,
 66 |  '10;18;18': 5,
 67 |  '10;18;20': 9,
 68 |  '10;19': 3,
 69 |  '10;20': 42,
 70 |  '10;25': 8,
 71 |  '10;27': 17,
 72 |  '11': 120,
 73 |  '11;18': 18,
 74 |  '11;20': 10,
 75 |  '12': 8,
 76 |  '13': 64,
 77 |  '14': 22,
 78 |  '15': 201,
 79 |  '15;18': 5,
 80 |  '15;20': 5,
 81 |  '16': 40,
 82 |  '17': 157,
 83 |  '18': 1011,
 84 |  '18;20': 5,
 85 |  '18;25': 8,
 86 |  '18;27': 3,
 87 |  '19': 660,
 88 |  '2': 1896,
 89 |  '20': 840,
 90 |  '20;27': 7,
 91 |  '21': 244,
 92 |  '22': 86,
 93 |  '23': 24,
 94 |  '24': 54,
 95 |  '25': 1612,
 96 |  '26': 24,
 97 |  '27': 534,
 98 |  '28': 447,
 99 |  '2;10': 54,
100 |  '2;11': 8,
101 |  '2;15': 3,
102 |  '2;18': 20,
103 |  '2;19': 3,
104 |  '2;20': 11,
105 |  '2;25': 6,
106 |  '2;7': 3,
107 |  '3': 16,
108 |  '4': 90,
109 |  '4;10': 3,
110 |  '4;18': 7,
111 |  '5': 108,
112 |  '6': 4,
113 |  '7': 148,
114 |  '7;18': 15,
115 |  '7;23': 9,
116 |  '8': 318,
117 |  '8;17': 21,
118 |  '8;18': 6,
119 |  '9': 10}
120 | '''


--------------------------------------------------------------------------------
/tools/re_clean_data.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- encoding: utf-8 -*-
 3 | '''
 4 | @File           :   re_clean_data.py
 5 | @Desciption     :   None
 6 | @Modify Time      @Author    @Version 
 7 | ------------      -------    --------  
 8 | 2019/10/8 20:42   Daic       1.0        
 9 | '''
10 | import os
11 | import csv
12 | import json
13 | def get_cates(str):
14 |     cat_list = []
15 |     pre_idx = 0
16 |     for x in range(len(str)-1):
17 |         if str[x]==';':
18 |             cat_list.append(int(str[pre_idx:x])-1)
19 |             pre_idx = x+1
20 |     cat_list.append(int(str[pre_idx:])-1)
21 |     return cat_list
22 | 
23 | def get_main_cate(list,dict):
24 |     final_cate = list[0]
25 |     for li in list:
26 |         if dict[str(li)]>dict[str(final_cate)]:
27 |             final_cate = li
28 | 
29 |     return final_cate
30 | 
31 | def one_hot_list(cate):
32 |     onehot = []
33 |     for x in range(29):
34 |         if x in cate:
35 |             onehot.append(1)
36 |         else:
37 |             onehot.append(0)
38 |     return onehot
39 | 
40 | ### this  is  cheecking single label that is belong to the category with most count
41 | # r = csv.reader(open('/media/disk2/daic/Cloud/Train_label.csv'))
42 | # datas = [l for l in r]
43 | # predata = json.load(open('/media/disk2/daic/Cloud/dataset_k1.json'))
44 | # count = {}
45 | # for x in range(29):
46 | #     count[str(x)] = 0
47 | # for tmp in predata:
48 | #     count[str(tmp['cate'])]+=1
49 | #
50 | # for i in range(1,len(datas)):
51 | #     da = datas[i]
52 | #     if len(da[1])>2:
53 | #         tmp_cates = get_cates(da[1])
54 | #         tmp_cate = get_main_cate(tmp_cates,count)
55 | #         img = da[0]
56 | #         for tmp in predata:
57 | #             if tmp['img']==img and tmp['cate']!=tmp_cate:
58 | #                 print("!!!!!!!!!!!!!!!!!!")
59 | 
60 | ### this is getting the mutilabel dataset;
61 | 
62 | if __name__ == '__main__':
63 |     r = csv.reader(open('./Train_label.csv'))
64 |     datas = [l for l in r]
65 |     predata = json.load(open('./dataset_k1.json'))
66 | 
67 |     idx = {}
68 |     for x in range(1,len(datas)):
69 |         idx[datas[x][0]] = datas[x][1]
70 | 
71 |     for x in range(len(predata)):
72 |         k = predata[x]['img']
73 |         oneh = one_hot_list(get_cates(idx[k]))
74 | 
75 |         predata[x]['muticate'] = oneh
76 | 
77 |     json.dump(predata)
78 | 
79 | 
80 | 
81 | 
82 | 
83 | 
84 | 


--------------------------------------------------------------------------------
/trainer.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- encoding: utf-8 -*-
  3 | '''
  4 | @File           :   models.py
  5 | @Desciption     :   None
  6 | @Modify Time      @Author    @Version
  7 | ------------      -------    --------
  8 | 2019/9/26 13:38   Daic       1.0
  9 | '''
 10 | import time
 11 | import torch
 12 | import torch.nn as nn
 13 | import numpy as np
 14 | from untils import *
 15 | from dataset import *
 16 | from torch.optim.lr_scheduler import ReduceLROnPlateau,MultiStepLR
 17 | 
 18 | class MultiClsTrainer(object):
 19 |     def __init__(self, opt):
 20 |         self.opt = opt
 21 |         print(opt)
 22 |         self.save_path = os.path.join(self.opt.out_path,self.opt.train_name)
 23 |         if not os.path.isdir(self.save_path):
 24 |             os.mkdir(self.save_path)
 25 | 
 26 |         self.train_bch = opt.train_bch
 27 |         self.val_bch = opt.val_bch
 28 |         self.num_worker  = opt.num_worker
 29 |         self.model = build_cls_model(self.opt.cnn,active = 'relu',class_num=self.opt.num_class,chanel_num=3)#relu
 30 |         #print(self.nmodel)
 31 |         self.model.cuda()
 32 |         #self.model = torch.nn.DataParallel(self.nmodel)
 33 | 
 34 |         self.val_dataset = ClsSteelDataset(self.opt, 'val')
 35 |         self.train_arguementation = get_training_augmentation()
 36 |         self.train_dataset = ClsSteelDataset(self.opt,'train',self.train_arguementation)
 37 |         print("Initial dataset success! The train length: %d  The val length: %d"%
 38 |               (len(self.train_dataset),len(self.val_dataset)))
 39 | 
 40 |         self.train_loader = DataLoader(dataset=self.train_dataset,shuffle=True ,
 41 |                                        batch_size=self.train_bch, num_workers=self.num_worker)
 42 |         self.val_loader   = DataLoader(dataset=self.val_dataset,shuffle=False ,
 43 |                                        batch_size=self.val_bch, num_workers=self.num_worker-4)
 44 | 
 45 |         self.loss = build_loss_function(self.opt)
 46 | 
 47 |         if self.opt.split_weights == 1:
 48 |             params = split_weights(self.model)
 49 |         else:
 50 |             params = self.model.parameters()
 51 | 
 52 |         self.optimizer = build_optimizer(params, self.opt)
 53 |         self.scheduler = MultiStepLR(self.optimizer, milestones=self.opt.decay_step, gamma=self.opt.decay_rate)
 54 | 
 55 | 
 56 |         self.max_epoch = self.opt.max_epoch
 57 |         self.max_score = 0.
 58 | 
 59 |         self.best_acc = 0.5
 60 | 
 61 |     def resum_load(self,path,mutigpu=False):
 62 |         net_data = torch.load(path)
 63 | 
 64 |         if mutigpu:
 65 |             for k, v in net_data.items():
 66 |                 name = k[7:]
 67 |                 net_data[name] = net_data.pop(k)
 68 |         self.model.load_state_dict(torch.load(net_data))
 69 |         print("Loading success from %s"%path)
 70 | 
 71 |     def lr_finder(self,epoch,save_path,slr=1e-8,elr=1):
 72 |         log_lrs = []
 73 |         log_loss = []
 74 |         all_iter = self.train_dataset.__len__() * epoch // self.train_bch
 75 |         global_iter = 0.
 76 |         _lr__ = slr
 77 |         mult = (elr / slr) ** (1 / all_iter)
 78 | 
 79 |         for epoch in range(epoch):
 80 |             for i, data in enumerate(self.train_loader):
 81 |                 _lr__ *= mult
 82 |                 set_lr(self.optimizer, _lr__)
 83 |                 log_lrs.append(math.log10(_lr__))
 84 |                 img = data[0].cuda()
 85 |                 label = data[1].cuda()
 86 |                 outputs = self.model(img)
 87 |                 loss = self.loss(outputs, label)
 88 |                 log_loss.append(loss.item())
 89 | 
 90 |                 self.optimizer.zero_grad()
 91 |                 loss.backward()
 92 |                 self.optimizer.step()
 93 | 
 94 |                 global_iter+=1
 95 |                 print("%.1f / %.1f  loss:%.6f  lr%.8f"%(global_iter,all_iter,loss.item(),_lr__))
 96 |         logs = {'lr':log_lrs,'loss':log_loss}
 97 |         json.dump(logs,open(os.path.join(save_path,'find_lr.json'),'w'))
 98 |         return logs
 99 | 
100 | 
101 | 
102 |     def eval_model(self):
103 |         self.model.eval()
104 |         pre = []
105 |         gt = []
106 | 
107 |         with torch.no_grad():
108 |             for i, data in enumerate(self.val_loader):
109 |                 img = data[0].cuda()
110 |                 label = data[1]
111 |                 label = label.numpy().astype(int).tolist()
112 |                 outputs = self.model(img).data.cpu()#.squeeze().numpy()#b
113 |                 #print(outputs)
114 | 
115 |                 #predicted = (outputs>0.5).astype(int).tolist()
116 |                 _, predicted = torch.max(outputs, 1)
117 |                 predicted = predicted.squeeze().numpy().tolist()
118 |                 #print(predicted)
119 |                 #print(label)
120 |                 pre += predicted
121 |                 gt += label
122 |         print(classification_report(gt,pre))
123 |         accs = classification_report(gt,pre,output_dict=True)
124 |         return accs
125 | 
126 |     def train_model(self):
127 |         global_iter = 0
128 |         running_loss = 0.
129 |         item_num = 0
130 |         start = time.time()
131 |         for epoch in range(self.max_epoch):
132 |             print('\nEpoch: {}'.format(epoch))
133 |             for i, data in enumerate(self.train_loader):
134 |                 img = data[0].cuda()
135 |                 label = data[1].cuda()
136 |                 #print(label)
137 |                 item_num += label.size(0)
138 |                 outputs = self.model(img)
139 |                 loss = self.loss(outputs, label)
140 |                 self.optimizer.zero_grad()
141 |                 loss.backward()
142 |                 self.optimizer.step()
143 |                 running_loss += loss.item()
144 |                 if i% 10 == 0 and i>0:
145 |                     print('[%d, %d]   loss: %.5f    lr:%.5f    time:%.2f' %
146 |                           (epoch, i, running_loss / item_num,self.optimizer.param_groups[0]['lr'],
147 |                            (time.time()-start))
148 |                           )
149 |                     running_loss = 0.
150 |                     item_num = 0
151 |                     start = time.time()
152 | 
153 |                 global_iter+=1
154 | 
155 |             acc = self.eval_model()
156 |             json.dump(acc, open(os.path.join(self.save_path, 'log_epoch' + str(epoch) + '.json'), 'w'))
157 | 
158 |             # print("epoch %d:"%(epoch))
159 |             # print('macro avg',acc['macro avg'])
160 |             # print('weighted avg', acc['weighted avg'])
161 |             if self.best_acc<= acc["accuracy"]:
162 |                 torch.save(self.model.state_dict(),os.path.join(self.save_path,'model.pth'))
163 |                 print("saving model....")
164 |                 self.best_acc = acc["accuracy"]
165 |             if epoch == (self.max_epoch-1):
166 |                 torch.save(self.model.state_dict(), os.path.join(self.save_path,'model_latest.pth'))
167 | 
168 |             self.scheduler.step()
169 | 
170 |     def test_model(self,test_info_path,test_image_folder,save_path,model_path=None):
171 |         if model_path != None:
172 |             self.resum_load(model_path)
173 | 
174 |         opt_test = self.opt
175 |         opt_test.image_path = test_image_folder
176 |         opt_test.input_json = test_info_path
177 | 
178 |         prediction = {}
179 |         test_dataset = ClsSteelDataset(opt_test, 'test')
180 |         test_loader = DataLoader(test_dataset,shuffle=False,
181 |                                 batch_size=1, num_workers=4)
182 | 
183 |         for i, data in enumerate(test_loader):
184 |             img = data[0].cuda()
185 |             name = data[2][0]
186 |             outputs = self.model(img)
187 |             outputs = outputs.data.cpu().numpy().tolist()
188 |             prediction[name] = outputs
189 |             if i%100 == 0:
190 |                 print('%d / %d'%(i,len(test_dataset)))
191 | 
192 |         json.dump(prediction,open(save_path,'w'))
193 | 
194 | 
195 | 
196 | 


--------------------------------------------------------------------------------
/untils.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- encoding: utf-8 -*-
  3 | '''
  4 | @File           :   untils.py
  5 | @Desciption     :   None
  6 | @Modify Time      @Author    @Version 
  7 | ------------      -------    --------  
  8 | 2019/9/26 13:36   Daic       1.0
  9 | '''
 10 | import math
 11 | import torch
 12 | import random
 13 | import torch.nn as nn
 14 | import torch.nn.functional as F
 15 | from torch.autograd import Variable
 16 | from torchsummary import summary
 17 | import torch.optim as optim
 18 | from torch.optim import Optimizer
 19 | import pretrainedmodels
 20 | from efficientnet_pytorch import EfficientNet
 21 | from sklearn.metrics import classification_report
 22 | 
 23 | class RAdam(Optimizer):
 24 | 
 25 |     def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):
 26 |         defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
 27 |         self.buffer = [[None, None, None] for ind in range(10)]
 28 |         super(RAdam, self).__init__(params, defaults)
 29 | 
 30 |     def __setstate__(self, state):
 31 |         super(RAdam, self).__setstate__(state)
 32 | 
 33 |     def step(self, closure=None):
 34 | 
 35 |         loss = None
 36 |         if closure is not None:
 37 |             loss = closure()
 38 | 
 39 |         for group in self.param_groups:
 40 | 
 41 |             for p in group['params']:
 42 |                 if p.grad is None:
 43 |                     continue
 44 |                 grad = p.grad.data.float()
 45 |                 if grad.is_sparse:
 46 |                     raise RuntimeError('RAdam does not support sparse gradients')
 47 | 
 48 |                 p_data_fp32 = p.data.float()
 49 | 
 50 |                 state = self.state[p]
 51 | 
 52 |                 if len(state) == 0:
 53 |                     state['step'] = 0
 54 |                     state['exp_avg'] = torch.zeros_like(p_data_fp32)
 55 |                     state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)
 56 |                 else:
 57 |                     state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)
 58 |                     state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)
 59 | 
 60 |                 exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
 61 |                 beta1, beta2 = group['betas']
 62 | 
 63 |                 exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
 64 |                 exp_avg.mul_(beta1).add_(1 - beta1, grad)
 65 | 
 66 |                 state['step'] += 1
 67 |                 buffered = self.buffer[int(state['step'] % 10)]
 68 |                 if state['step'] == buffered[0]:
 69 |                     N_sma, step_size = buffered[1], buffered[2]
 70 |                 else:
 71 |                     buffered[0] = state['step']
 72 |                     beta2_t = beta2 ** state['step']
 73 |                     N_sma_max = 2 / (1 - beta2) - 1
 74 |                     N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)
 75 |                     buffered[1] = N_sma
 76 | 
 77 |                     # more conservative since it's an approximated value
 78 |                     if N_sma >= 5:
 79 |                         step_size = group['lr'] * math.sqrt((1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (N_sma_max - 2)) / (1 - beta1 ** state['step'])
 80 |                     else:
 81 |                         step_size = group['lr'] / (1 - beta1 ** state['step'])
 82 |                     buffered[2] = step_size
 83 | 
 84 |                 if group['weight_decay'] != 0:
 85 |                     p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)
 86 | 
 87 |                 # more conservative since it's an approximated value
 88 |                 if N_sma >= 5:
 89 |                     denom = exp_avg_sq.sqrt().add_(group['eps'])
 90 |                     p_data_fp32.addcdiv_(-step_size, exp_avg, denom)
 91 |                 else:
 92 |                     p_data_fp32.add_(-step_size, exp_avg)
 93 | 
 94 |                 p.data.copy_(p_data_fp32)
 95 | 
 96 |         return loss
 97 | 
 98 | class FocalLoss(nn.Module):
 99 |     def __init__(self, gamma=0, alpha=None, size_average=True):
100 |         super(FocalLoss, self).__init__()
101 |         self.gamma = gamma
102 |         self.alpha = alpha
103 |         if isinstance(alpha, (float, int)): self.alpha = torch.Tensor([alpha, 1 - alpha])
104 |         if isinstance(alpha, list): self.alpha = torch.Tensor(alpha)
105 |         self.size_average = size_average
106 |     def forward(self, input, target):
107 |         if input.dim() > 2:
108 |             input = input.view(input.size(0), input.size(1), -1)  # N,C,H,W => N,C,H*W
109 |             input = input.transpose(1, 2)  # N,C,H*W => N,H*W,C
110 |             input = input.contiguous().view(-1, input.size(2))  # N,H*W,C => N*H*W,C
111 |         target = target.view(-1, 1)
112 |         logpt = F.log_softmax(input)
113 |         logpt = logpt.gather(1, target)
114 |         logpt = logpt.view(-1)
115 |         pt = Variable(logpt.data.exp())
116 |         if self.alpha is not None:
117 |             if self.alpha.type() != input.data.type():
118 |                 self.alpha = self.alpha.type_as(input.data)
119 |             at = self.alpha.gather(0, target.data.view(-1))
120 |             logpt = logpt * Variable(at)
121 |         loss = -1 * (1 - pt) ** self.gamma * logpt
122 |         if self.size_average:
123 |             return loss.mean()
124 |         else:
125 |             return loss.sum()
126 | 
127 | def build_optimizer(params, opt):
128 |     if opt.optimizer == 'rmsprop':
129 |         return optim.RMSprop(params, opt.lr, opt.momentum, weight_decay=opt.weight_decay)
130 |     elif opt.optimizer == 'radam':
131 |         return RAdam(params, opt.lr, weight_decay=opt.weight_decay)
132 |     elif opt.optimizer == 'adagrad':
133 |         return optim.Adagrad(params, opt.lr, weight_decay=opt.weight_decay)
134 |     elif opt.optimizer == 'sgd':
135 |         return optim.SGD(params, opt.lr, weight_decay=opt.weight_decay)
136 |     elif opt.optimizer == 'sgdm':
137 |         return optim.SGD(params, opt.lr, opt.momentum, weight_decay=opt.weight_decay)
138 |     elif opt.optimizer == 'sgdmom':
139 |         return optim.SGD(params, opt.lr, opt.momentum, weight_decay=opt.weight_decay, nesterov=True)
140 |     elif opt.optimizer == 'adam':
141 |         return optim.Adam(params, opt.lr,  weight_decay=opt.weight_decay)
142 |     else:
143 |         raise Exception("bad option opt.optim: {}".format(opt.optim))
144 | 
145 | def build_cls_model(name,active = 'relu',class_num=5,chanel_num=3):
146 |     if name in ['efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3', 'efficientnet-b4',
147 |                   'efficientnet-b5','efficientnet-b6']:
148 |         if name == 'efficientnet-b3':
149 |             model = EfficientNet.from_pretrained('efficientnet-b3')
150 |             model._fc = nn.Linear(in_features=1536, out_features=class_num, bias=True)
151 |         elif name == 'efficientnet-b4':
152 |             model = EfficientNet.from_pretrained('efficientnet-b3')
153 |             model._fc = nn.Linear(in_features=1792, out_features=class_num, bias=True)
154 |         elif name == 'efficientnet-b6':
155 |             model = EfficientNet.from_pretrained('efficientnet-b6')
156 |             model._fc = nn.Linear(in_features=2304, out_features=class_num, bias=True)
157 |     if name not in ['efficientnet-b0','efficientnet-b1','efficientnet-b2','efficientnet-b3','efficientnet-b4','efficientnet-b5','efficientnet-b6']:
158 |         model = pretrainedmodels.__dict__[name](num_classes=1000, pretrained='imagenet')
159 |         if name in ['resnet18','resnet32']:
160 |             if chanel_num==1:
161 |                 model.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
162 |             model.last_linear = nn.Linear(in_features=512, out_features=class_num, bias=True)
163 |         elif name in ['resnet50','resnet101','resnet152']:
164 |             if chanel_num == 1:
165 |                 model.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
166 |             model.last_linear = nn.Linear(in_features=2048, out_features=class_num, bias=True)
167 |         elif name in ['senet154',  'se_resnet50', 'se_resnet101', 'se_resnet152', 'se_resnext50_32x4d', 'se_resnext101_32x4d']:
168 |             #if chanel_num == 1:
169 |                 #model.layer0.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
170 |             model.avg_pool = nn.AdaptiveAvgPool2d(1)
171 |             model.last_linear = nn.Linear(in_features=2048, out_features=class_num, bias=True)
172 |         elif name in ['inceptionv4']:
173 |             model.last_linear = nn.Linear(in_features=1536, out_features=class_num, bias=True)
174 |         elif name in ['inceptionresnetv2']:
175 |             model.last_linear = nn.Linear(in_features=1536, out_features=class_num, bias=True)
176 |         else:
177 |             raise Exception("unsupported model! {}".format(name))
178 | 
179 |     if active == 'relu':
180 |         return model
181 |     elif active == 'mish':
182 |         convert_relu_to_Mish(model)
183 |         return model
184 | 
185 | def set_lr(optimizer, lr):
186 |     for group in optimizer.param_groups:
187 |         group['lr'] = lr
188 | def get_lr(optimizer):
189 |     return optimizer.param_groups[0]['lr']
190 | 
191 | 
192 | class LSR(nn.Module):
193 |     def __init__(self, e=0.1, reduction='mean'):
194 |         super(LSR,self).__init__()
195 |         self.log_softmax = nn.LogSoftmax(dim=1)
196 |         self.e = e
197 |         self.reduction = reduction
198 | 
199 |     def _one_hot(self, labels, classes, value=1):
200 |         """
201 |             Convert labels to one hot vectors
202 | 
203 |         Args:
204 |             labels: torch tensor in format [label1, label2, label3, ...]
205 |             classes: int, number of classes
206 |             value: label value in one hot vector, default to 1
207 | 
208 |         Returns:
209 |             return one hot format labels in shape [batchsize, classes]
210 |         """
211 | 
212 |         one_hot = torch.zeros(labels.size(0), classes)
213 | 
214 |         # labels and value_added  size must match
215 |         labels = labels.view(labels.size(0), -1)
216 |         value_added = torch.Tensor(labels.size(0), 1).fill_(value)
217 | 
218 |         value_added = value_added.to(labels.device)
219 |         one_hot = one_hot.to(labels.device)
220 | 
221 |         one_hot.scatter_add_(1, labels, value_added)
222 | 
223 |         return one_hot
224 | 
225 |     def _smooth_label(self, target, length, smooth_factor):
226 |         """convert targets to one-hot format, and smooth
227 |         them.
228 |         Args:
229 |             target: target in form with [label1, label2, label_batchsize]
230 |             length: length of one-hot format(number of classes)
231 |             smooth_factor: smooth factor for label smooth
232 | 
233 |         Returns:
234 |             smoothed labels in one hot format
235 |         """
236 |         one_hot = self._one_hot(target, length, value=1 - smooth_factor)
237 |         one_hot += smooth_factor / length
238 | 
239 |         return one_hot.to(target.device)
240 | 
241 |     def forward(self, x, target):
242 | 
243 |         if x.size(0) != target.size(0):
244 |             raise ValueError('Expected input batchsize ({}) to match target batch_size({})'
245 |                              .format(x.size(0), target.size(0)))
246 | 
247 |         if x.dim() < 2:
248 |             raise ValueError('Expected input tensor to have least 2 dimensions(got {})'
249 |                              .format(x.size(0)))
250 | 
251 |         if x.dim() != 2:
252 |             raise ValueError('Only 2 dimension tensor are implemented, (got {})'
253 |                              .format(x.size()))
254 | 
255 |         smoothed_target = self._smooth_label(target, x.size(1), self.e)
256 |         x = self.log_softmax(x)
257 |         loss = torch.sum(- x * smoothed_target, dim=1)
258 | 
259 |         if self.reduction == 'none':
260 |             return loss
261 | 
262 |         elif self.reduction == 'sum':
263 |             return torch.sum(loss)
264 | 
265 |         elif self.reduction == 'mean':
266 |             return torch.mean(loss)
267 | 
268 |         else:
269 |             raise ValueError('unrecognized option, expect reduction to be one of none, mean, sum')
270 | 
271 | def build_loss_function(opt):
272 |     if opt.loss =='lsr':
273 |         return LSR()
274 |     elif opt.loss =='ce':
275 |         return nn.CrossEntropyLoss()
276 |     elif opt.loss == 'bce':
277 |         return nn.BCELoss()
278 |     elif opt.loss == 'focal':
279 |         return FocalLoss()
280 |     elif opt.loss == 'bcel':
281 |         return nn.BCEWithLogitsLoss()
282 |     else:
283 |         raise Exception("bad option opt.loss: {}".format(opt.loss))
284 | 
285 | 
286 | 
287 | def split_weights(net):
288 |     """split network weights into to categlories,
289 |     one are weights in conv layer and linear layer,
290 |     others are other learnable paramters(conv bias,
291 |     bn weights, bn bias, linear bias)
292 |     Args:
293 |         net: network architecture
294 | 
295 |     Returns:
296 |         a dictionary of params splite into to categlories
297 |     """
298 | 
299 |     decay = []
300 |     no_decay = []
301 | 
302 |     for m in net.modules():
303 |         if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
304 |             decay.append(m.weight)
305 | 
306 |             if m.bias is not None:
307 |                 no_decay.append(m.bias)
308 | 
309 |         else:
310 |             if hasattr(m, 'weight'):
311 |                 no_decay.append(m.weight)
312 |             if hasattr(m, 'bias'):
313 |                 no_decay.append(m.bias)
314 | 
315 |     assert len(list(net.parameters())) == len(decay) + len(no_decay)
316 | 
317 |     return [dict(params=decay), dict(params=no_decay, weight_decay=0)]
318 | 
319 | #####################################
320 | #Pairwise Confusion for Fine-Grained Visual Classification
321 | #https://github.com/abhimanyudubey/confusion
322 | def PairwiseConfusion(features):
323 |     batch_size = features.size(0)
324 |     if float(batch_size) % 2 != 0:
325 |         raise Exception('Incorrect batch size provided')
326 |     batch_left = features[:int(0.5*batch_size)]
327 |     batch_right = features[int(0.5*batch_size):]
328 |     loss  = torch.norm((batch_left - batch_right).abs(),2, 1).sum() / float(batch_size)
329 | 
330 |     return loss
331 | 
332 | def EntropicConfusion(features):
333 |     batch_size = features.size(0)
334 |     return torch.mul(features, torch.log(features)).sum() * (1.0 / batch_size)


--------------------------------------------------------------------------------