classifier

+import os
+import fire
+import json
+from pprint import pprint
+
+import torch
+import torch.nn as nn
+from torch.utils.tensorboard import SummaryWriter
+
+from utils import *
+
+# command
+# python eval.py --model_path='logs/April_16_00:26:10__resnet50__None/'
+
+def eval(model_path):
+    print('\n[+] Parse arguments')
+    kwargs_path = os.path.join(model_path, 'kwargs.json')
+    kwargs = json.loads(open(kwargs_path).read())
+    args, kwargs = parse_args(kwargs)
+    pprint(args)
+    device = torch.device('cuda' if args.use_cuda else 'cpu')
+
+    print('\n[+] Create network')
+    model = select_model(args)
+    optimizer = select_optimizer(args, model)
+    criterion = nn.CrossEntropyLoss()
+    if args.use_cuda:
+        model = model.cuda()
+        criterion = criterion.cuda()
+
+    print('\n[+] Load model')
+    weight_path = os.path.join(model_path, 'model', 'model.pt')
+    model.load_state_dict(torch.load(weight_path))
+
+    print('\n[+] Load dataset')
+    test_transform = get_valid_transform(args, model)
+    #print('\nTEST Transform\n', test_transform)
+    test_dataset = get_dataset(args, 'test') 
+
+
+   
+    test_loader = iter(get_dataloader(args, test_dataset)) ###
+
+    print('\n[+] Start testing')
+    writer = SummaryWriter(log_dir=model_path)
+    _test_res = validate(args, model, criterion, test_loader, step=0, writer=writer)
+
+    print('\n[+] Valid results')
+    print('  Acc@1 : {:.3f}%'.format(_test_res[0].data.cpu().numpy()[0]*100))
+    print('  Acc@5 : {:.3f}%'.format(_test_res[1].data.cpu().numpy()[0]*100))
+    print('  Loss : {:.3f}'.format(_test_res[2].data))
+    print('  Infer Time(per image) : {:.3f}ms'.format(_test_res[3]*1000 / len(test_dataset)))
+
+    writer.close()
+
+if __name__ == '__main__':
+    fire.Fire(eval)

+import torch.nn as nn
+
+class BaseNet(nn.Module):
+    def __init__(self, backbone, args):
+        super(BaseNet, self).__init__()
+
+        # Separate layers
+        self.first = nn.Sequential(*list(backbone.children())[:1])
+        self.after = nn.Sequential(*list(backbone.children())[1:-1])
+        self.fc = list(backbone.children())[-1]
+
+        self.img_size = (240, 240)
+
+    def forward(self, x):
+        f = self.first(x)
+        x = self.after(f)
+        x = x.reshape(x.size(0), -1)
+        x = self.fc(x)
+        return x, f
+
+"""
+        print("before reshape:\n", x.size()) 
+        #[128, 2048, 4, 4] 
+        # #cifar [128, 2048, 1, 1]
+        x = x.reshape(x.size(0), -1)
+        print("after reshape:\n",  x.size()) 
+        #[128, 32768] 
+        #cifar [128, 2048]
+        #RuntimeError: size mismatch, m1: [128 x 32768], m2: [2048 x 10] 
+        print("fc :\n", self.fc) 
+        #Linear(in_features=2048, out_features=10, bias=True)
+        #cifar Linear(in_features=2048, out_features=1000, bias=True)
+"""

+future
+tb-nightly
+hyperopt
+pillow==6.2.1
+natsort
+fire
+torchvision==0.2.2
+torch==1.1.0
+pandas
+sklearn
\ No newline at end of file

+import os
+import fire
+import time
+import json
+import random
+from pprint import pprint
+
+import torch.nn as nn
+import torch.backends.cudnn as cudnn
+from torch.utils.tensorboard import SummaryWriter
+
+from networks import *
+from utils import *
+
+# python train.py --use_cuda=True --network=resnet50 --dataset=BraTS --optimizer=adam 
+# nohup python train.py --use_cuda=True --network=resnet50 --dataset=BraTS --optimizer=adam &
+
+
+def train(**kwargs):
+    print('\n[+] Parse arguments')
+    args, kwargs = parse_args(kwargs)
+    pprint(args)
+    device = torch.device('cuda' if args.use_cuda else 'cpu')
+
+    print('\n[+] Create log dir')
+    model_name = get_model_name(args)
+    log_dir = os.path.join('/content/drive/My Drive/CD2 Project/classify/', model_name)
+    os.makedirs(os.path.join(log_dir, 'model'))
+    json.dump(kwargs, open(os.path.join(log_dir, 'kwargs.json'), 'w'))
+    writer = SummaryWriter(log_dir=log_dir)
+
+    if args.seed is not None:
+        random.seed(args.seed)
+        torch.manual_seed(args.seed)
+        cudnn.deterministic = True
+
+    print('\n[+] Create network')
+    model = select_model(args)
+    optimizer = select_optimizer(args, model)
+    scheduler = select_scheduler(args, optimizer)
+    criterion = nn.CrossEntropyLoss()
+    if args.use_cuda:
+        model = model.cuda()
+        criterion = criterion.cuda()
+    writer.add_graph(model)
+
+    print('\n[+] Load dataset')
+    transform = get_train_transform(args, model, log_dir)
+    val_transform = get_valid_transform(args, model)
+    train_dataset = get_dataset(args, transform, 'train')
+    valid_dataset = get_dataset(args, val_transform, 'val')
+    train_loader = iter(get_inf_dataloader(args, train_dataset))
+    max_epoch = len(train_dataset) // args.batch_size
+    best_acc = -1
+
+    print('\n[+] Start training')
+    if torch.cuda.device_count() > 1:
+        print('\n[+] Use {} GPUs'.format(torch.cuda.device_count()))
+        model = nn.DataParallel(model)
+    
+    print('\n[+] Use {} GPUs'.format(torch.cuda.device_count()))
+    print('\n[+] Using GPU: {} '.format(torch.cuda.get_device_name(0)))
+
+    start_t = time.time()
+    for step in range(args.start_step, args.max_step):
+        batch = next(train_loader)
+        _train_res = train_step(args, model, optimizer, scheduler, criterion, batch, step, writer)
+
+        if step % args.print_step == 0:
+            print('\n[+] Training step: {}/{}\tTraining epoch: {}/{}\tElapsed time: {:.2f}min\tLearning rate: {}'.format(
+                step, args.max_step, current_epoch, max_epoch, (time.time()-start_t)/60, optimizer.param_groups[0]['lr']))
+            writer.add_scalar('train/learning_rate', optimizer.param_groups[0]['lr'], global_step=step)
+            writer.add_scalar('train/acc1', _train_res[0], global_step=step)
+            writer.add_scalar('train/acc5', _train_res[1], global_step=step)
+            writer.add_scalar('train/loss', _train_res[2], global_step=step)
+            writer.add_scalar('train/forward_time', _train_res[3], global_step=step)
+            writer.add_scalar('train/backward_time', _train_res[4], global_step=step)
+            print('  Acc@1 : {:.3f}%'.format(_train_res[0].data.cpu().numpy()[0]*100))
+            print('  Acc@5 : {:.3f}%'.format(_train_res[1].data.cpu().numpy()[0]*100))
+            print('  Loss : {}'.format(_train_res[2].data))
+            print('  FW Time : {:.3f}ms'.format(_train_res[3]*1000))
+            print('  BW Time : {:.3f}ms'.format(_train_res[4]*1000))
+
+        if step % args.val_step == args.val_step-1:
+            valid_loader = iter(get_dataloader(args, valid_dataset))
+            _valid_res = validate(args, model, criterion, valid_loader, step, writer)
+            print('\n[+] Valid results')
+            writer.add_scalar('valid/acc1', _valid_res[0], global_step=step)
+            writer.add_scalar('valid/acc5', _valid_res[1], global_step=step)
+            writer.add_scalar('valid/loss', _valid_res[2], global_step=step)
+            print('  Acc@1 : {:.3f}%'.format(_valid_res[0].data.cpu().numpy()[0]*100))
+            print('  Acc@5 : {:.3f}%'.format(_valid_res[1].data.cpu().numpy()[0]*100))
+            print('  Loss : {}'.format(_valid_res[2].data))
+
+            if _valid_res[0] >= best_acc:
+                best_acc = _valid_res[0]
+                torch.save(model.state_dict(), os.path.join(log_dir, "model","model.pt"))
+                print('\n[+] Model saved')
+
+    writer.close()
+
+
+if __name__ == '__main__':
+    fire.Fire(train)

+import os
+import time
+import importlib
+import collections
+import pickle as cp
+import glob
+import numpy as np
+import pandas as pd
+
+from natsort import natsorted
+from PIL import Image
+import torch
+import torchvision
+import torch.nn.functional as F
+import torchvision.models as models
+import torchvision.transforms as transforms
+from torch.utils.data import Subset
+from torch.utils.data import Dataset, DataLoader
+
+from sklearn.model_selection import StratifiedShuffleSplit
+from sklearn.model_selection import train_test_split
+from sklearn.model_selection import KFold
+
+from networks import *
+
+
+TRAIN_DATASET_PATH = '/content/drive/My Drive/CD2 Project/data/nonaug+Normal_train/'
+TRAIN_TARGET_PATH = '/content/drive/My Drive/CD2 Project/data/train_nonaug_classify_target.csv'
+# VAL_DATASET_PATH = '../../data/MICCAI_BraTS_2019_Data_Training/ce_valid/'
+# VAL_TARGET_PATH = '../../data/MICCAI_BraTS_2019_Data_Training/ce_valid_targets.csv'
+
+current_epoch = 0
+
+
+def split_dataset(args, dataset, k):
+    # load dataset
+    X = list(range(len(dataset)))
+    Y = dataset.targets
+
+    # split to k-fold
+    assert len(X) == len(Y)
+
+    def _it_to_list(_it):
+        return list(zip(*list(_it)))
+
+    sss = StratifiedShuffleSplit(n_splits=k, random_state=args.seed, test_size=0.1)
+    Dm_indexes, Da_indexes = _it_to_list(sss.split(X, Y))
+
+    return Dm_indexes, Da_indexes
+
+
+
+def get_model_name(args):
+    from datetime import datetime, timedelta, timezone
+    now = datetime.now(timezone.utc)
+    tz = timezone(timedelta(hours=9))
+    now = now.astimezone(tz)
+    date_time = now.strftime("%B_%d_%H:%M:%S")
+    model_name = '__'.join([date_time, args.network, str(args.seed)])
+    return model_name
+
+
+def dict_to_namedtuple(d):
+    Args = collections.namedtuple('Args', sorted(d.keys()))
+
+    for k,v in d.items():
+        if type(v) is dict:
+            d[k] = dict_to_namedtuple(v)
+
+        elif type(v) is str:
+            try:
+                d[k] = eval(v)
+            except:
+                d[k] = v
+
+    args = Args(**d)
+    return args
+
+
+def parse_args(kwargs):
+    # combine with default args
+    kwargs['dataset'] =  kwargs['dataset'] if 'dataset' in kwargs else 'BraTS'
+    kwargs['network'] =  kwargs['network'] if 'network' in kwargs else 'resnet50'
+    kwargs['optimizer'] = kwargs['optimizer'] if 'optimizer' in kwargs else 'adam'
+    kwargs['learning_rate'] = kwargs['learning_rate'] if 'learning_rate' in kwargs else 0.0001
+    kwargs['seed'] =  kwargs['seed'] if 'seed' in kwargs else None
+    kwargs['use_cuda'] =  kwargs['use_cuda'] if 'use_cuda' in kwargs else True
+    kwargs['use_cuda'] =  kwargs['use_cuda'] and torch.cuda.is_available()
+    kwargs['num_workers'] = kwargs['num_workers'] if 'num_workers' in kwargs else 4
+    kwargs['print_step'] = kwargs['print_step'] if 'print_step' in kwargs else 500
+    kwargs['val_step'] = kwargs['val_step'] if 'val_step' in kwargs else 500
+    kwargs['scheduler'] = kwargs['scheduler'] if 'scheduler' in kwargs else 'exp'
+    kwargs['batch_size'] = kwargs['batch_size'] if 'batch_size' in kwargs else 128
+    kwargs['start_step'] = kwargs['start_step'] if 'start_step' in kwargs else 0
+    kwargs['max_step'] = kwargs['max_step'] if 'max_step' in kwargs else 5000
+    kwargs['augment_path'] = kwargs['augment_path'] if 'augment_path' in kwargs else None
+
+    # to named tuple
+    args = dict_to_namedtuple(kwargs)
+    return args, kwargs
+
+
+def select_model(args):
+    # grayResNet2
+    resnet_dict = {'resnet18':grayResNet2.resnet18(), 'resnet34':grayResNet2.resnet34(), 
+    'resnet50':grayResNet2.resnet50(), 'resnet101':grayResNet2.resnet101(), 'resnet152':grayResNet2.resnet152()}
+
+    if args.network in resnet_dict:
+        backbone = resnet_dict[args.network]
+        model = basenet.BaseNet(backbone, args)
+    else:
+        Net = getattr(importlib.import_module('networks.{}'.format(args.network)), 'Net')
+        model = Net(args)
+
+    #print(model) # print model architecture
+    return model
+
+
+def select_optimizer(args, model):
+    if args.optimizer == 'sgd':
+        optimizer = torch.optim.SGD(model.parameters(), lr=args.learning_rate, momentum=0.9, weight_decay=0.0001)
+    elif args.optimizer == 'rms':
+        optimizer = torch.optim.RMSprop(model.parameters(), lr=args.learning_rate)
+    elif args.optimizer == 'adam':
+        optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
+    else:
+        raise Exception('Unknown Optimizer')
+    return optimizer
+
+
+def select_scheduler(args, optimizer):
+    if not args.scheduler or args.scheduler == 'None':
+        return None
+    elif args.scheduler =='clr':
+        return torch.optim.lr_scheduler.CyclicLR(optimizer, 0.01, 0.015, mode='triangular2', step_size_up=250000, cycle_momentum=False)
+    elif args.scheduler =='exp':
+        return torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9999283, last_epoch=-1)
+    else:
+        raise Exception('Unknown Scheduler')
+
+
+class CustomDataset(Dataset): 
+  def __init__(self, data_path, csv_path):
+    self.len = len(self.imgs)
+    self.path = data_path
+    self.imgs = natsorted(os.listdir(data_path))
+  
+    df = pd.read_csv(csv_path)
+    targets_list = []
+
+    for fname in self.imgs:
+        row = df.loc[df['filename'] == fname]
+        targets_list.append(row.iloc[0, 1])
+
+    self.targets = targets_list
+
+  def __len__(self):
+      return self.len
+
+  def __getitem__(self, idx):
+    img_loc = os.path.join(self.path, self.imgs[idx])
+    targets = self.targets[idx]
+    image = Image.open(img_loc)
+    return image, targets
+
+
+
+def get_dataset(args, transform, split='train'):
+    assert split in ['train', 'val', 'test', 'trainval']
+
+    if split in ['train']:
+        dataset = CustomDataset(TRAIN_DATASET_PATH, TRAIN_TARGET_PATH, transform=transform)
+    else: #test
+        dataset = CustomDataset(VAL_DATASET_PATH, VAL_TARGET_PATH, transform=transform)
+
+    return dataset
+
+
+def get_dataloader(args, dataset, shuffle=False, pin_memory=True):
+    data_loader = torch.utils.data.DataLoader(dataset,
+                                              batch_size=args.batch_size,
+                                              shuffle=shuffle,
+                                              num_workers=args.num_workers,
+                                              pin_memory=pin_memory)
+    return data_loader
+
+
+def get_aug_dataloader(args, dataset, shuffle=False, pin_memory=True):
+    data_loader = torch.utils.data.DataLoader(dataset,
+                                              batch_size=args.batch_size,
+                                              shuffle=shuffle,
+                                              num_workers=args.num_workers,
+                                              pin_memory=pin_memory)
+    return data_loader
+
+
+def get_inf_dataloader(args, dataset):
+    global current_epoch
+    data_loader = iter(get_dataloader(args, dataset, shuffle=True))
+
+    while True:
+        try:
+            batch = next(data_loader)
+
+        except StopIteration:
+            current_epoch += 1
+            data_loader = iter(get_dataloader(args, dataset, shuffle=True))
+            batch = next(data_loader)
+
+        yield batch
+
+
+
+
+def train_step(args, model, optimizer, scheduler, criterion, batch, step, writer, device=None):
+    model.train()
+    images, target = batch
+
+    if device:
+        images = images.to(device)
+        target = target.to(device)
+
+    elif args.use_cuda:
+        images = images.cuda(non_blocking=True)
+        target = target.cuda(non_blocking=True)
+
+    # compute output
+    start_t = time.time()
+    output, first = model(images)
+    forward_t = time.time() - start_t
+    loss = criterion(output, target)
+
+    # measure accuracy and record loss
+    acc1, acc5 = accuracy(output, target, topk=(1, 5))
+    acc1 /= images.size(0)
+    acc5 /= images.size(0)
+
+    # compute gradient and do SGD step
+    optimizer.zero_grad()
+    start_t = time.time()
+    loss.backward()
+    backward_t = time.time() - start_t
+    optimizer.step()
+    if scheduler: scheduler.step()
+
+    if writer and step % args.print_step == 0:
+        n_imgs = min(images.size(0), 10)
+        tag = 'train/' + str(step)
+        for j in range(n_imgs):
+            writer.add_image(tag,
+                    concat_image_features(images[j], first[j]), global_step=step)
+
+    return acc1, acc5, loss, forward_t, backward_t
+
+
+#_acc1, _acc5 = accuracy(output, target, topk=(1, 5))
+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)
+
+        _, pred = output.topk(maxk, 1, True, True)
+        pred = pred.t()
+        correct = pred.eq(target.view(1, -1).expand_as(pred))
+
+        res = []
+        for k in topk:
+            correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
+            res.append(correct_k)
+        return res
+