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)
