def from_name(cls, model_name, in_channels=3, **override_params): cls._check_model_name_is_valid(model_name) blocks_args, global_params = get_model_params(model_name, override_params) model = cls(blocks_args, global_params) model._change_in_channels(in_channels) return model
def __init__(self, skip_connections, model_name): blocks_args, global_params = get_model_params(model_name, override_params=None) super().__init__(blocks_args, global_params) self._skip_connections = list(skip_connections) self._skip_connections.append(len(self._blocks)) del self._fc
def make_benchmark_model(): from efficientnet_pytorch import EfficientNet from efficientnet_pytorch import utils block_args, global_params = utils.get_model_params("efficientnet-b0", None) net = EfficientNet(block_args, global_params._replace(num_classes=N_CLASSES)) return net
def from_name(cls, model_name, num_classes, dropout_rate=0.0): cls._check_model_name_is_valid(model_name) override_params = { 'num_classes': num_classes, 'dropout_rate': dropout_rate } blocks_args, global_params = get_model_params(model_name, override_params) return cls(blocks_args, global_params)
def __init__(self, skip_connections, model_name): blocks_args, global_params = get_model_params(model_name, override_params=None) super().__init__(blocks_args, global_params) self._skip_connections = list(skip_connections) self._skip_connections.append(len(self._blocks)) self.channels = [round_filters(1280, self._global_params)] del self._fc
def TwoWayFPNBackbone(): out_channels = 256 override_params = {'num_classes': 1000} paras = get_model_params('efficientnet-b5', override_params) model = EfficientNet(paras[0], paras[1]) arr = model.return_sub() fpn = FPN(arr, paras[0], paras[1], out_channels=out_channels) return fpn
def __init__(self, stage_idxs, out_channels, model_name, depth=5): blocks_args, global_params = get_model_params(model_name, override_params=None) super().__init__(blocks_args, global_params) self._stage_idxs = list(stage_idxs) + [len(self._blocks)] self._out_channels = out_channels self._depth = depth self._in_channels = 3 del self._fc
def __init__(self, model_cfg): blocks_args, global_params = get_model_params(model_cfg.arch, dict(image_size=None)) super().__init__(blocks_args, global_params) self.multi_scale_output = model_cfg.multi_scale_output self.stage_specs = sys.modules[__name__].__getattribute__( model_cfg.arch.replace("-", "_")) self.num_blocks = len(self._blocks) del self._fc, self._conv_head, self._bn1, self._avg_pooling, self._dropout
def from_name(cls, model_name, override_params=None, first_stride=True, ktype='ori', cifar=False): cls._check_model_name_is_valid(model_name) blocks_args, global_params = get_model_params(model_name, override_params) if cifar: blocks_args[5].stride = [1] return cls(blocks_args, global_params, first_stride, ktype)
def from_name(cls, model_name, in_channels=3, n_classes=4, use_scSE=False, **override_params): from efficientnet_pytorch.utils import get_model_params cls._check_model_name_is_valid(model_name) blocks_args, global_params = get_model_params(model_name, override_params) model = cls(blocks_args, global_params, n_classes=n_classes, use_scSE=use_scSE) model._change_in_channels(in_channels) return model
def from_name(cls, model_name, override_params=None): cls._check_model_name_is_valid(model_name) blocks_args, global_params = get_model_params(model_name, override_params) # del blocks_args[0:3] # In order to use as many pre-trained weights as possible, we will not # be deleting any of the existing block args, instead we will be # creating every block and loading pre-trained weights (except for the # case of the block where we will change the input channels from 40 to # 60), then only using the ones we are interested in, i.e., blocks 4 # through 8. # blocks_args[3] = blocks_args[3]._replace(input_filters=64) # for _ in blocks_args: # print(_) # exit() return cls(blocks_args, global_params)
def TwoWayFPNBackbone(preTrained=True): ## output channels for each size is = 256 out_channels = 256 ## getting the parameters for efficient-b5 override_params = {'num_classes': 1000} paras = get_model_params('efficientnet-b5', override_params) # getting the pretrained model device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net = get_net().to(device) # Replacing the BatchNorm with InPlaceABN Sync layers model = convert_layers(net, nn.BatchNorm2d, InPlaceABN, True) # getting the blocks only from full model since we are setting initial and final layers by ourselfs final_block = list(model._blocks) # the first loop iterate over each MBConv block and second loop iterate over each element final_arr = [] for block in range(len(final_block)): temp = [] i = -1 lis = list(final_block[block].children()) for idx, m in final_block[block].named_children(): i = i + 1 if idx in ['_se_reduce', '_se_expand']: continue else: if idx not in ['_bn0', '_bn1', '_bn2']: for param in lis[i].parameters(): param.requires_grad = False temp.append(lis[i]) final_arr.append(nn.Sequential(*temp)) # the efficientNet-B5 is divided into 7 big blocks passing_arr = [] passing_arr.append(nn.Sequential(*final_arr[0:3])) passing_arr.append(nn.Sequential(*final_arr[3:8])) passing_arr.append(nn.Sequential(*final_arr[8:13])) passing_arr.append(nn.Sequential(*final_arr[13:20])) passing_arr.append(nn.Sequential(*final_arr[20:27])) passing_arr.append(nn.Sequential(*final_arr[27:36])) passing_arr.append(nn.Sequential(*final_arr[36:])) # Feature Pyramid Networks return FPN(passing_arr, paras[0], paras[1], out_channels=out_channels)
def load_state_dict(self, state_dict, **kwargs): state_dict.pop("_fc.bias") if '_fc.bias' in state_dict.keys( ) else print('fc.bias not in dict') state_dict.pop("_fc.weight") if '_fc.weight' in state_dict.keys( ) else print('fc.weight not in dict') super().load_state_dict(state_dict, **kwargs) blocks_args, global_params = get_model_params('efficientnet-b0', override_params=None) Conv2d = get_same_padding_conv2d(image_size=global_params.image_size) self._conv_stem_st = Conv2d(3, 32, kernel_size=3, stride=1, bias=False) self._conv_stem_st.weight.data = self._conv_stem.weight.data bn_mom = 1 - global_params.batch_norm_momentum bn_eps = global_params.batch_norm_epsilon self._bn0_st = nn.BatchNorm2d(num_features=32, momentum=bn_mom, eps=bn_eps)
def TwoWayFPNBackbone(preTrained = True): ## output channels for each size is = 256 out_channels = 256 ## getting the parameters for efficient-b5 override_params={'num_classes': 1000} paras = get_model_params( 'efficientnet-b5', override_params ) # getting the pretrained model device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net = get_net().to(device) # getting the blocks only from full model since we are setting initial and final layers by ourselfs final_block = list(net._blocks) # the first loop iterate over each MBConv block and second loop iterate over each element final_arr = final_block # the efficientNet-B5 is divided into 7 big blocks passing_arr = [] passing_arr.append(nn.Sequential(*final_arr[0:3])) passing_arr.append(nn.Sequential(*final_arr[3:8])) passing_arr.append(nn.Sequential(*final_arr[8:13])) passing_arr.append(nn.Sequential(*final_arr[13:20])) passing_arr.append(nn.Sequential(*final_arr[20:27])) passing_arr.append(nn.Sequential(*final_arr[27:36])) passing_arr.append(nn.Sequential(*final_arr[36:])) # Feature Pyramid Networks del final_block del final_arr for model in passing_arr: for param in model.parameters(): param.requires_grad = False fpn = FPN( passing_arr, paras[0], paras[1], out_channels=out_channels ) return fpn
import torch #from efficientnet_pytorch import EfficientNet # In[20]: #model = EfficientNet.from_pretrained('efficientnet-b7') # print(model) # In[21]: from efficientnet_pytorch.utils import get_model_params blocks_args, global_params = get_model_params('efficientnet-b7', None) print(blocks_args) #[BlockArgs(num_repeat=1, kernel_size=3, stride=[1], expand_ratio=1, input_filters=32, output_filters=16, se_ratio=0.25, id_skip=True), # BlockArgs(num_repeat=2, kernel_size=3, stride=[2], expand_ratio=6, input_filters=16, output_filters=24, se_ratio=0.25, id_skip=True), # BlockArgs(num_repeat=2, kernel_size=5, stride=[2], expand_ratio=6, input_filters=24, output_filters=40, se_ratio=0.25, id_skip=True), # BlockArgs(num_repeat=3, kernel_size=3, stride=[2], expand_ratio=6, input_filters=40, output_filters=80, se_ratio=0.25, id_skip=True), # BlockArgs(num_repeat=3, kernel_size=5, stride=[1], expand_ratio=6, input_filters=80, output_filters=112, se_ratio=0.25, id_skip=True), # BlockArgs(num_repeat=4, kernel_size=5, stride=[2], expand_ratio=6, input_filters=112, output_filters=192, se_ratio=0.25, id_skip=True), # BlockArgs(num_repeat=1, kernel_size=3, stride=[1], expand_ratio=6, input_filters=192, output_filters=320, se_ratio=0.25, id_skip=True)] print(global_params) # In[23]: from efficientnet_pytorch.model import EfficientNet
def from_name(cls, model_name, override_params=None): cls._check_model_name_is_valid(model_name) blocks_args, global_params = get_model_params(model_name, override_params) return cls(blocks_args, global_params)
def main(): criterion = nn.CrossEntropyLoss().cuda() if args.model == 'effnet': blocks_args, global_params = get_model_params('efficientnet-b5', None) blocks_args.append( BlockArgs(kernel_size=3, num_repeat=3, input_filters=320, output_filters=480, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25)) model = EfficientNet(blocks_args, global_params) pretrained_dict = model_zoo.load_url(url_map['efficientnet-b5']) model_dict = model.state_dict() del pretrained_dict['_conv_head.weight'] pretrained_dict = { k: v for k, v in pretrained_dict.items() if k in model_dict } model_dict.update(pretrained_dict) model.load_state_dict(model_dict) model._fc = nn.Sequential( nn.BatchNorm1d(2048), nn.Dropout(p=0.5), nn.Linear(in_features=2048, out_features=500, bias=True), nn.ReLU(), nn.BatchNorm1d(500), nn.Dropout(p=0.5), nn.Linear(in_features=500, out_features=60, bias=True), nn.ReLU(), nn.BatchNorm1d(60), nn.Dropout(p=0.5), nn.Linear(in_features=60, out_features=1, bias=True)) if args.model.startswith('efficientnet'): msize = int(args.model[-1]) if msize < 6: model = EfficientNet.from_pretrained(args.model) else: model = EfficientNet.from_name(args.model) model._fc = nn.Sequential( nn.BatchNorm1d(2048), nn.Dropout(p=0.4), nn.Linear(in_features=2048, out_features=500, bias=True), nn.ReLU(), nn.BatchNorm1d(500), nn.Dropout(p=0.4), nn.Linear(in_features=500, out_features=60, bias=True), nn.ReLU(), nn.BatchNorm1d(60), nn.Dropout(p=0.4), nn.Linear(in_features=60, out_features=1, bias=True)) elif args.model == 'pnasv2': _, global_params = get_model_params('efficientnet-b1', None) model = pretrainedmodels.__dict__['pnasnet5large']( num_classes=1000, pretrained='imagenet') model.avg_pool = nn.Sequential( MBConvBlock( BlockArgs(kernel_size=3, num_repeat=3, input_filters=4320, output_filters=2160, expand_ratio=3, id_skip=True, stride=[2], se_ratio=0.25), global_params), nn.AdaptiveAvgPool2d(1)) model.last_linear = nn.Sequential( nn.BatchNorm1d(2160), nn.Dropout(p=0.25), nn.Linear(in_features=2160, out_features=400, bias=True), nn.ReLU(), nn.BatchNorm1d(400), nn.Dropout(p=0.25), nn.Linear(in_features=400, out_features=5, bias=True), ) elif args.model in pretrainedmodels.__dict__.keys(): model = pretrainedmodels.__dict__[args.model](num_classes=1000, pretrained='imagenet') model.avg_pool = nn.AdaptiveAvgPool2d(1) model.last_linear = nn.Sequential( nn.BatchNorm1d(4320), nn.Dropout(p=0.5), nn.Linear(in_features=4320, out_features=600, bias=True), nn.ReLU(), nn.BatchNorm1d(600), nn.Dropout(p=0.5), nn.Linear(in_features=600, out_features=100, bias=True), nn.ReLU(), nn.BatchNorm1d(100), nn.Dropout(p=0.5), nn.Linear(in_features=100, out_features=5, bias=True), ) elif args.model == 'nasnetv2': model = nasnetv2() #print(model) model = model.to(device) if torch.cuda.is_available(): model = nn.DataParallel(model) cudnn.benchmark = True if args.checkpoint: print('Resuming training from epoch {}, loading {}...'.format( args.resume, args.checkpoint)) weight_file = os.path.join(args.root, args.checkpoint) model.load_state_dict( torch.load(weight_file, map_location=lambda storage, loc: storage)) optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=args.weight_decay) scheduler = MultiStepLR( optimizer, milestones=(np.array([1 / 3, 1 / 2, 2 / 3, 5 / 6]) * args.epochs).astype(int).tolist(), gamma=0.1) train_csv = os.path.join(args.root, 'train.csv') #dist= df.groupby('diagnosis').count().values.reshape(5) df1 = pd.read_csv(train_csv, header=1, names=['id', 'diagnosis'], dtype={ 'id': str, 'diagnosis': np.int8 }) df1['dataset'] = 0 df1, df_val = \ train_test_split(df1, test_size=0.05, random_state=40) print('Current Competition:') print(df1.groupby('diagnosis').count()) #Previous dataset ext_csv = os.path.join(args.root, 'exter-resized', 'trainLabels_cropped.csv') df2 = pd.read_csv(ext_csv, header=1, names=['id', 'diagnosis'], usecols=[2, 3], dtype={ 'id': str, 'diagnosis': np.int8 }) df2['diagnosis'] = df2['diagnosis'].astype(int) df2['dataset'] = 1 print('Previous Dataset:') print(df2.groupby('diagnosis').count()) #IEEE df3 = pd.read_csv('IEEE/label/train.csv', header=1, names=['id', 'diagnosis'], usecols=[0, 1], dtype={ 'id': str, 'diagnosis': np.int8 }) df3 = df3.append( pd.read_csv('IEEE/label/test.csv', header=1, names=['id', 'diagnosis'], usecols=[0, 1], dtype={ 'id': str, 'diagnosis': np.int8 })) df3['dataset'] = 2 print('IEEE') print(df3.groupby('diagnosis').count()) #messidor ''' df4=pd.DataFrame() for i in range(1,4): for j in range(1,5): df4=df4.append(pd.read_excel( 'messidor/Annotation_Base'+str(i)+str(j)+'.xls',header=1, names =['id', 'diagnosis'], usecols=[0,2], dtype={'id':str, 'diagnosis':np.int8})) df4['dataset'] = 3 print('Messidor:') print(df4.groupby('diagnosis').count()) ''' print('Overall val:') print(df_val.groupby('diagnosis').count()) for i in range(args.resume): scheduler.step() for epoch in range(args.resume, args.epochs): df = pd.DataFrame() df = df.append( df1.groupby('diagnosis').apply( lambda x: x.sample(200, replace=True)).reset_index(drop=True)) df = df.append( df2.groupby('diagnosis').apply( lambda x: x.sample(700, replace=True)).reset_index(drop=True)) df = df.append( df3.groupby('diagnosis').apply( lambda x: x.sample(20, replace=True)).reset_index(drop=True)) print('Overall train:', len(df)) print(df.groupby('diagnosis').count()) data = {'train': df, 'val': df_val} dataset = { x: APTOSDataset(x, data[x], transform[x]) for x in ['train', 'val'] } dataloader = { x: DataLoader(dataset[x], batch_size=args.batch, shuffle=(x == 'train'), num_workers=args.workers, pin_memory=True) for x in ['train', 'val'] } print('Epoch {}/{}'.format(epoch + 1, args.epochs)) print('-' * 10) for phase in ['train', 'val']: if phase == 'train': scheduler.step() model.train() else: model.eval() nb = 0 num = 0 running_loss = 0 running_correct = 0 predict = [] truth = [] for inputs, targets in dataloader[phase]: t1 = time.time() batch = inputs.size(0) inputs = inputs.to(device).float() targets = targets.to(device).long() optimizer.zero_grad() with torch.set_grad_enabled(phase == 'train'): outputs = model(inputs) loss = criterion(outputs, targets) if phase == 'train': loss.backward() optimizer.step() nb += 1 num += batch loss = loss.item() running_loss += loss * inputs.size(0) #propose=outputs.round().long().clamp(0,4) max, propose = outputs.data.max(1) correct = (propose == targets).sum().item() acc = correct / batch * 100 running_correct += correct p = propose.cpu().tolist() t = targets.cpu().tolist() predict += p truth += t t2 = time.time() if nb % args.print == 0: print('|'.join(str(x) for x in p)) print('|'.join(str(x) for x in t)) print('n:{:d}, l:{:.4f}|{:.4f}, a:{:.4f}|{:.4f}, t:{:.4f}' \ .format(num, loss, running_loss/num, acc, running_correct/num*100, t2-t1)) print('num:', num, len(truth)) cm = confusion_matrix(truth, predict, labels=[0, 1, 2, 3, 4]) ht = histogram(truth, 0, 4) hp = histogram(predict, 0, 4) hm = np.outer(ht, hp) / np.float(num) kappa = cohen_kappa_score(truth, predict, labels=[0, 1, 2, 3, 4]) kappa2 = quadratic_weighted_kappa(truth, predict, 0, 4) print('=' * 5, phase, '=' * 5) print("Confusion matrix") print(cm) print("Hist matrix") print(ht) print(hp) print(hm) print('{:s}:{:d}, n:{:d}, l:{:.4f}, a:{:.4f}, k:{:.4f}, k2:{:.4f}, t:{:.4f}' \ .format(phase, epoch+1, num, running_loss/num, \ running_correct/num*100, kappa, kappa2, t2-t1)) print('=' * 15) if phase == 'val': torch.save( model.state_dict(), os.path.join(args.save_folder, 'out_' + str(epoch + 1) + '.pth')) print()
def __init__(self, model_name, **override_params): blocks_args, global_params = get_model_params(model_name, override_params) self.backbone_indices = backbone_indices[model_name] super().__init__(blocks_args, global_params) del self._fc
import torch
def __init__(self, model_name='efficientnet-b0'): blocks_args, global_params = get_model_params(model_name, override_params={}) super().__init__(blocks_args, global_params) load_pretrained_weights(self, model_name=model_name, load_fc=True) self.model_name = model_name
def from_name(cls, model_name, override_params=None, **kways): cls._check_model_name_is_valid(model_name) blocks_args, global_params = get_model_params(model_name, override_params) return EfficientNet_encoder(blocks_args, global_params, **kways)