def create_models():
models = []
for i in range(5):
model = create_model(f'../input/quest-models/best_{i}.pth')
model.eval()
models.append(model)
return models
def load_ensemble_from_checkpoints(checkpoints):
models = []
for chk in checkpoints:
model = get_model()
model.load_state_dict(chk["model"])
models.append(model)
ensemble = Ensemble(models)
ensemble.to(get_device())
return ensemble
def load_models(models_path, arch=None, n_folds=3, device='cuda'):
models = []
for i in range(n_folds):
models.append( AudioClassifier(arch_name=arch) )
models[i].to(device)
try:
models[i].load_from_checkpoint(os.path.join(models_path, f'ZINDI-GIZ-NLP-AGRI-KEYWORDS-{arch}-{i}-based.ckpt'))
except:
models[i].load_from_checkpoint(os.path.join(models_path, f'ZINDI-GIZ-NLP-AGRI-KEYWORDS-{arch}-{i}-based-v0.ckpt'))
models[i].eval()
return models
def create_models():
models = []
models.append(create_dense201())
models.append(create_dense161())
models.append(create_res101())
models.append(create_res152())
return models
def reload_models(model: nn.Module,
model_dir: str,
folder_name: str,
device="cuda",
debug=False) -> list:
'''Reloads multiple models based on a directory passed through. Useful for quickly loading directories
Parameters
----------
`model` : `nn.Module`\n
The model.
`model_dir` : `str`\n
Path to the directory.
`folder_name` : `str`\n
Name of the folder.
`device` : `str`, `optional`\n
String representation of the GPU core to use or the CPU, by default "cuda".
`debug` : `bool`, `optional`\n
Boolean indicating whether to print out debugging information or not.
Returns
-------
`models` : `list`\n
List of all the saved models in evaluation mode.
'''
models = []
print('Reading in models...')
path = os.path.join(model_dir, folder_name)
for i, (subdir, dirs, files) in enumerate(os.walk(path)):
if not files:
continue
for f in files:
if debug:
print(f'Reading {f}')
model = model.to(device)
weights = os.path.join(subdir, f)
model.load_state_dict(
state_dict=torch.load(weights)['model_state_dict'])
model.eval()
models.append(model)
return models
def reload_models(model, model_dir, folder_name, device="cuda"):
models = []
print('Reading in models...')
path = os.path.join(model_dir, folder_name)
for i, (subdir, dirs, files) in enumerate(os.walk(path)):
if not files:
continue
for f in files:
print(f'Reading {f}')
model = model.to(device)
model.load_state_dict(state_dict=torch.load(subdir+'/'+f)['model_state_dict'])
models.append(model)
return models
def load_models(model_dirs):
"""
load models from all the provided directories.
Any file with a .pth extension is considered a model file.
"""
models = []
for directory in model_dirs:
filenames = os.listdir(directory)
for filename in filenames:
if filename.endswith('.pth'):
model_path = os.path.join(directory, filename)
model = get_model()
target_device = None if torch.cuda.is_available() else 'cpu'
model.load_state_dict(
torch.load(model_path, map_location=target_device))
models.append(model)
return models
def get_models(cfg):
"""Get PyTorch model."""
models = list()
for i in range(len(cfg.modelnames)):
if cfg.modelnames[i].startswith("/timm/"):
model = timm.create_model(cfg.modelnames[i][6:], pretrained=False)
elif cfg.modelnames[i].startswith("/torch/"):
model = getattr(models, cfg.modelnames[i][7:])(pretrained=False)
lastlayer = list(model._modules)[-1]
try:
setattr(model, lastlayer, nn.Linear(in_features=getattr(model, lastlayer).in_features,
out_features=cfg.NUMCLASSES, bias=True))
except torch.nn.modules.module.ModuleAttributeError:
setattr(model, lastlayer, nn.Linear(in_features=getattr(model, lastlayer)[1].in_features,
out_features=cfg.NUMCLASSES, bias=True))/home/toefl/K/cassava/mendeley
model = model.to(cfg.device).eval()
models.append(model)
return models
def plot_image_with_models_benchmark_on_special_gpu_between_envs(gpu, phase, precision, big_data_frame):
df_envs_models_time = big_data_frame[(big_data_frame.gpus == gpu) & (
big_data_frame.phases == phase) & (big_data_frame.precisions == precision)]
df_envs_models_time = df_envs_models_time.sort_values(['envs', 'models'])
models = []
envs = list(set(df_envs_models_time['envs'].tolist()))
envs_time_dict = {}
for index, rows in df_envs_models_time.iterrows():
# print(index,rows)
if rows.envs in envs_time_dict:
envs_time_dict[rows.envs].append(rows.time)
else:
envs_time_dict[rows.envs] = [rows.time]
if rows.models not in models:
models.append(rows.models)
plotdata = pd.DataFrame(envs_time_dict, index=models)
plotdata = plotdata.sort_index(axis=1)
plotdata = plotdata.sort_index(axis=0)
plotdata.plot(figsize=(30, 13), kind="bar", rot=-15, alpha=0.4)
plt.xlabel("Models", fontsize=14)
plt.ylabel("Time", fontsize=14)
plt.title('{} {} models with {} precision'.format(
gpu, phase, precision), fontsize=16)
benchmark_images_save_dir = ENVS_BENCHMARK_IMAGE_SAVE_DIR + '/' + \
'{}_benchmark_bewteen_{}'.format(gpu, "_".join(sorted(envs)))
if not os.path.exists(benchmark_images_save_dir):
os.makedirs(benchmark_images_save_dir)
plt_image_name = '{} {}_models_with_{}_precision_between_{}'.format(
gpu, phase, precision, "_".join(sorted(envs)))
save_path = os.path.join(benchmark_images_save_dir, plt_image_name)
plt.savefig(save_path)
def plot_image_for_compare_model_benchmark_on_multiple_gpus(env, phase, precision, big_data_frame):
df_gpus_models_time = big_data_frame[(big_data_frame.envs == env) & (
big_data_frame.phases == phase) & (big_data_frame.precisions == precision)]
df_gpus_models_time = df_gpus_models_time.sort_values(['gpus', 'models'])
models = []
gpus = list(set(df_gpus_models_time['gpus'].tolist()))
gpus_time_dict = {}
for _, rows in df_gpus_models_time.iterrows():
if rows.gpus in gpus_time_dict:
gpus_time_dict[rows.gpus].append(rows.time)
else:
gpus_time_dict[rows.gpus] = [rows.time]
if rows.models not in models:
models.append(rows.models)
plotdata = pd.DataFrame(gpus_time_dict, index=models)
plotdata = plotdata.sort_index(axis=1)
plotdata = plotdata.sort_index(axis=0)
plotdata.plot(figsize=(30, 13), kind="bar", rot=-15, alpha=0.4)
plt.xlabel("Models", fontsize=14)
plt.ylabel("Time", fontsize=14)
plt.title('{} models with {} precision on multiples gpus'.format(
phase, precision), fontsize=16)
gpu_benchmark_images_save_dir = GPUS_BENCHMARK_IMAGE_SAVE_DIR + \
'/' + "{}_in_{}".format("_".join(sorted(gpus)), env)
if not os.path.exists(gpu_benchmark_images_save_dir):
os.makedirs(gpu_benchmark_images_save_dir)
plt_image_name = '{}_models_with_{}_precision_on_gpus_{}'.format(
phase, precision, "_".join(sorted(gpus)))
save_path = os.path.join(gpu_benchmark_images_save_dir, plt_image_name)
plt.savefig(save_path)
def predict(self, path, n_models):
"""
Use models from saved snapshots for prediction.
Parameters:
path - path to directory containing checkpoint files
n_models - number of models to use for prediction
(top n_models will be used,
models sorted based on validation accuracy)
"""
models = []
checkpoints = os.listdir(path)
for curr in checkpoints:
state = self.load_checkpoint(f'{path}/{curr}')
model = state['model']
valid_acc = state['valid_acc']
models.append((model, valid_acc))
models.sort(key=lambda x: x[1], reverse=True)
models = models[:n_models]
corrects = 0
for iteration, (test_input, test_label) in enumerate(self.test_dl, 1):
test_output_label = []
for curr_model, valid_acc in models:
self.model.load_state_dict(curr_model)
self.model.to(self.device)
test_output_label.append((self.test_batch(test_input)))
test_output_label = torch.tensor([x.cpu().numpy()
for x in test_output_label])
final_votes = torch.mode(test_output_label, dim=0)[0]
corrects += torch.sum(final_votes == test_label)
return corrects.item()/len(self.test_dl.dataset)
model = models.resnet34(pretrained=False)
train_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
test_transform = train_transform
train_dataset = datasets.ImageFolder(args.data_dir, train=True, download=False,
transform=train_transform)
test_dataset = datasets.ImageFolder(args.data_dir, train=False, download=False,
transform=test_transform)
else:
print('Model must be {} or {}!'.format('MnistCNN', 'AlexNet'))
sys.exit(-1)
models.append(model)
train_bsz = args.train_bsz
train_bsz /= len(workers)
train_bsz = int(train_bsz)
train_data = partition_dataset(train_dataset, workers)
train_data_list = []
for i in workers:
train_data_sub = select_dataset(workers, i, train_data, batch_size=train_bsz)
train_data_list.append(train_data_sub)
test_bsz = 400
# 用所有的测试数据测试
test_data = DataLoader(test_dataset, batch_size=test_bsz, shuffle = False)
iterations_epoch = int(len(train_dataset) / args.train_bsz)
def main():
sample_dir = './test_DI-2-FGSM-3/'
if not os.path.exists(sample_dir):
os.makedirs(sample_dir)
InceptionResnet_model_1 = InceptionResnetV1(
pretrained='vggface2').eval().to(device_0)
print('load InceptionResnet-vggface2.pt successfully')
# InceptionResnet_model_2 = InceptionResnetV1(pretrained='casia-webface').eval().to(device_0)
# print('load InceptionResnet-casia-webface.pt successfully')
IR_50_model_1 = IR_50([112, 112])
IR_50_model_1.load_state_dict(
torch.load(
'/notebooks/Workspace/tmp/pycharm_project_314/TianChi/Face_recognition/irse/model/backbone_ir50_asia.pth'
))
IR_50_model_1.eval().to(device_0)
print('load IR_50 successfully')
# IR_152_model_1 = IR_152([112, 112])
# IR_152_model_1.load_state_dict(
# torch.load(
# '/notebooks/Workspace/tmp/pycharm_project_314/TianChi/Face_recognition/irse/model/Backbone_IR_152_Epoch_112_Batch_2547328_Time_2019-07-13-02-59_checkpoint.pth'))
# IR_152_model_1.eval().to(device_0)
# print('load IR_152 successfully')
# IR_SE_50 = Backbone(50,mode='ir_se').eval().to(device_1)
# print('load IR_SE_50 successfully')
# mobileFaceNet = MobileFaceNet(512).eval().to(device_0)
# print('load mobileFaceNet successfully')
Insightface_iresnet34 = insightface.iresnet34(pretrained=True)
Insightface_iresnet34.eval().to(device_1)
print('load Insightface_iresnet34 successfully')
Insightface_iresnet50 = insightface.iresnet50(pretrained=True)
Insightface_iresnet50.eval().to(device_1)
print('load Insightface_iresnet50 successfully')
Insightface_iresnet100 = insightface.iresnet100(pretrained=True)
Insightface_iresnet100.eval().to(device_1)
print('load Insightface_iresnet100 successfully')
# ##########################vgg16
# from Face_recognition.vgg16.vgg16 import CenterLossModel,loadCheckpoint
# vgg16_checkpoint=loadCheckpoint('/notebooks/Workspace/tmp/pycharm_project_314/TianChi/Face_recognition/vgg16/model');
#
# VGG16 = CenterLossModel(embedding_size=512,num_classes=712,checkpoint=vgg16_checkpoint).eval().to(device_1)
# print('load VGG16 successfully')
arc_face_ir_se_50 = Arcface()
arc_face_ir_se_50.eval()
arc_face_ir_se_50.to(device_0)
models = []
models.append(InceptionResnet_model_1)
models.append(IR_50_model_1)
models.append(Insightface_iresnet34)
models.append(Insightface_iresnet50)
models.append(Insightface_iresnet100)
models.append(arc_face_ir_se_50)
criterion = nn.MSELoss()
# cpu
# collect all images to attack
paths = []
picpath = '/notebooks/Workspace/tmp/pycharm_project_314/TianChi/images'
for root, dirs, files in os.walk(picpath):
for f in files:
paths.append(os.path.join(root, f))
random.shuffle(paths)
# paras
eps = 1
steps = 50
output_path = './output_img'
momentum = 0.3
alpha = 0.35
beta = 0.3
gamma = 0.1
#####cal mean feature face
print('cal mean feature face #########################')
# ##########
# cal mean feature face on only 712 images
# mean_face_1 = torch.zeros(1,3,112,112).detach()
# for path in tqdm(paths):
# image = Image.open(path)
# in_tensor_1 = img2tensor(np.array(image))
# mean_face_1 += in_tensor_1
# mean_face_1 = mean_face_1 / 712
# ##########
# with torch.no_grad():
# mean_face = torch.zeros(512).detach()
# for path in tqdm(paths):
# start = time.time()
# print('cal mean face ' + path + ' ===============>')
# image = Image.open(path)
#
#
# # define paras
# # in_tensor is origin tensor of image
# # in_variable changes with gradient
#
# in_tensor_1 = img2tensor(np.array(image))
# # print(in_tensor.shape)
# this_feature_face = None
#
#
# # # origin feature
#
# _origin_InceptionResnet_model_1 = InceptionResnet_model_1(in_tensor_1.to(device_0)).cpu()
# ####################
# # _origin_InceptionResnet_model_2 = InceptionResnet_model_2(in_tensor_1.to(device_0)).cpu()
# ######################
# # _origin_IR_50_model_1 = IR_50_model_1(in_tensor_1.to(device_0)).cpu()
# ###########################
# # _origin_IR_152_model_1 = IR_152_model_1(in_tensor_1.to(device_0)).cpu()
# # _origin_IR_SE_50 = IR_SE_50(in_tensor_1.to(device_1)).cpu()
# # _origin_mobileFaceNet = mobileFaceNet(in_tensor_1.to(device_0)).cpu()
# #############################
#
# _origin_Insightface_iresent34 = Insightface_iresnet34(in_tensor_1.to(device_1)).cpu()
#
#
# _origin_Insightface_iresent50 = Insightface_iresnet50(in_tensor_1.to(device_1)).cpu()
#
#
# _origin_Insightface_iresent100 = Insightface_iresnet100(in_tensor_1.to(device_1)).cpu()
#
#
# _origin_arcface = arc_face_ir_se_50(in_tensor_1.to(device_0)).cpu()
#
# ########################
# # _origin_VGG16 = VGG16.forward_GetFeature(in_tensor_1.to(device_1)).cpu()
# ########################
#
# this_feature_face = _origin_InceptionResnet_model_1 + \
# _origin_Insightface_iresent34 + \
# _origin_Insightface_iresent50 + \
# _origin_Insightface_iresent100 + \
# _origin_arcface
#
# # this_feature_face = _origin_InceptionResnet_model_1 + \
# # _origin_InceptionResnet_model_2 +\
# # _origin_IR_50_model_1 + \
# # _origin_IR_152_model_1 +\
# # _origin_IR_SE_50 +\
# # _origin_mobileFaceNet +\
# # _origin_Insightface_iresent34 + \
# # _origin_Insightface_iresent50 + \
# # _origin_Insightface_iresent100 + \
# # _origin_arcface +\
# # _origin_VGG16
#
#
# this_feature_face = this_feature_face / 5.
# mean_face = mean_face + this_feature_face
#
# # del _origin_InceptionResnet_model_1
# # del _origin_InceptionResnet_model_2
# # del _origin_IR_50_model_1
# # del _origin_IR_152_model_1
# # del _origin_IR_SE_50
# # del _origin_mobileFaceNet
# # del _origin_Insightface_iresent34
# # del _origin_Insightface_iresent50
# # del _origin_Insightface_iresent100
# # del _origin_VGG16
# # del _origin_arcface
# # del this_feature_face
# # del in_tensor_1
#
# del _origin_InceptionResnet_model_1
# # del _origin_IR_50_model_1
# del _origin_Insightface_iresent34
# del _origin_Insightface_iresent50
# del _origin_Insightface_iresent100
# del _origin_arcface
# del this_feature_face
# del in_tensor_1
#
# mean_face = mean_face / 712.
mean_face = cal_mean_face_by_extend_dataset(models)
print('finish cal mean face...')
############################
print('######attack...##################')
from mydataset import CustomDataset
custom_dataset = CustomDataset()
train_loader = torch.utils.data.DataLoader(dataset=custom_dataset,
batch_size=6,
shuffle=True)
count = 0
progressRate = 0.0
for i, (x, path) in enumerate(train_loader):
start = time.time()
print('processing ' + str(progressRate) + ' ===============>')
in_tensor = x
origin_variable = in_tensor.detach()
origin_variable = origin_variable
in_variable = in_tensor.detach()
in_variable = in_variable
##########
in_variable_max = in_tensor.detach()
in_variable_min = in_tensor.detach()
in_variable_max = in_variable + 0.1
in_variable_min = in_variable - 0.1
##########
in_tensor = in_tensor.squeeze()
in_tensor = in_tensor
adv = None
perturbation = torch.Tensor(x.size(0), 3, 112,
112).uniform_(-0.05, 0.05) ###这里测试
perturbation = perturbation
in_variable += perturbation
in_variable.data.clamp_(-1.0, 1.0)
in_variable.requires_grad = True
g_noise = torch.zeros_like(in_variable)
g_noise = g_noise
origin_InceptionResnet_model_1 = InceptionResnet_model_1(
origin_variable.to(device_0)).cpu()
# origin_InceptionResnet_model_2 = InceptionResnet_model_2(origin_variable.to(device_0)).cpu()
origin_IR_50_model_1 = IR_50_model_1(
origin_variable.to(device_0)).cpu()
# origin_IR_152_model_1 = IR_152_model_1(origin_variable.to(device_0)).cpu()
# origin_IR_SE_50 = IR_SE_50(origin_variable.to(device_1)).cpu()
# origin_mobileFaceNet = mobileFaceNet(origin_variable.to(device_0)).cpu()
origin_Insightface_iresent34 = Insightface_iresnet34(
origin_variable.to(device_1)).cpu()
origin_Insightface_iresent50 = Insightface_iresnet50(
origin_variable.to(device_1)).cpu()
origin_Insightface_iresent100 = Insightface_iresnet100(
origin_variable.to(device_1)).cpu()
origin_arcface = arc_face_ir_se_50(origin_variable.to(device_0)).cpu()
# origin_VGG16 = VGG16.forward_GetFeature(origin_variable.to(device_1)).cpu()
# origin_average_out = (origin_InceptionResnet_model_1+origin_IR_50_model_1+origin_Insightface_iresent34+\
# origin_Insightface_iresent50+origin_Insightface_iresent100+origin_arcface)/6
# origin_average_out =(origin_InceptionResnet_model_1+\
# origin_InceptionResnet_model_2+ \
# origin_IR_50_model_1+\
# origin_IR_152_model_1+\
# origin_IR_SE_50+\
# origin_mobileFaceNet+\
# origin_Insightface_iresent34+\
# origin_Insightface_iresent50 +\
# origin_Insightface_iresent100 +\
# origin_arcface +\
# origin_VGG16) /11.
origin_average_out =(origin_InceptionResnet_model_1+ \
origin_IR_50_model_1 +\
origin_Insightface_iresent34+\
origin_Insightface_iresent50 +\
origin_Insightface_iresent100 +\
origin_arcface ) /6.
# target pix mean face
# After verification, it found no use.
# target_mean_face_InceptionResnet_model_1 = InceptionResnet_model_1(mean_face_1.to(device_0)).cpu()
# target_mean_face_IR_50_model_1 = IR_50_model_1(mean_face_1.to(device_0)).cpu()
# target_mean_face_Insightface_iresent34 = Insightface_iresnet34(mean_face_1.to(device_1)).cpu()
# target_mean_face_Insightface_iresent50 = Insightface_iresnet50(mean_face_1.to(device_1)).cpu()
# target_mean_faceInsightface_iresent100 = Insightface_iresnet100(mean_face_1.to(device_1)).cpu()
# target_mean_face_arcface = arc_face_ir_se_50(mean_face_1.to(device_0)).cpu()
# target_mean_face_average_out = (target_mean_face_InceptionResnet_model_1 + target_mean_face_IR_50_model_1 + target_mean_face_Insightface_iresent34 + target_mean_face_Insightface_iresent50 + target_mean_faceInsightface_iresent100 + target_mean_face_arcface)/ 6
# sum gradient
for i in range(steps):
print('step: ' + str(i))
# new_variable = input_diversity(in_variable,112,0.5)
# 通过随机的size的padding，增加input的多样性
mediate_InceptionResnet_model_1 = InceptionResnet_model_1(
in_variable.to(device_0)).cpu()
# mediate_InceptionResnet_model_2 = InceptionResnet_model_2(new_variable.to(device_0)).cpu()
mediate_IR_50_model_1 = IR_50_model_1(
in_variable.to(device_0)).cpu()
# mediate_IR_152_model_1 = IR_152_model_1(new_variable.to(device_0)).cpu()
# mediate_IR_SE_50 = IR_SE_50(new_variable.to(device_1)).cpu()
# mediate_mobileFaceNet = mobileFaceNet(new_variable.to(device_0)).cpu()
mediate_Insightface_iresent34 = Insightface_iresnet34(
in_variable.to(device_1)).cpu()
mediate_Insightface_iresent50 = Insightface_iresnet50(
in_variable.to(device_1)).cpu()
mediate_Insightface_iresent100 = Insightface_iresnet100(
in_variable.to(device_1)).cpu()
# mediate_VGG16 = VGG16.forward_GetFeature(new_variable.to(device_1)).cpu()
mediate_arcface = arc_face_ir_se_50(in_variable.to(device_0)).cpu()
# average_out = (mediate_InceptionResnet_model_1+mediate_InceptionResnet_model_2+mediate_IR_50_model_1+\
# mediate_IR_152_model_1+mediate_IR_SE_50+mediate_mobileFaceNet+mediate_Insightface_iresent34+\
# mediate_Insightface_iresent50+mediate_Insightface_iresent100+mediate_VGG16)/10
# mediate_average_out = (mediate_InceptionResnet_model_1+mediate_IR_50_model_1+mediate_Insightface_iresent34+\
# mediate_Insightface_iresent50+mediate_Insightface_iresent100+mediate_arcface)/6
# mediate_average_out = (mediate_InceptionResnet_model_1+\
# mediate_InceptionResnet_model_2+\
# mediate_IR_50_model_1+\
# mediate_IR_152_model_1+\
# mediate_IR_SE_50+\
# mediate_mobileFaceNet+\
# mediate_Insightface_iresent34+\
# mediate_Insightface_iresent50+\
# mediate_Insightface_iresent100 +\
# mediate_VGG16+\
# mediate_arcface) /11.
mediate_average_out = (mediate_InceptionResnet_model_1+ \
mediate_IR_50_model_1 +\
mediate_Insightface_iresent34+\
mediate_Insightface_iresent50+\
mediate_Insightface_iresent100 +\
mediate_arcface) /6.
# loss1 = criterion(mediate_InceptionResnet_model_1, origin_InceptionResnet_model_1) + \
# criterion(mediate_InceptionResnet_model_2, origin_InceptionResnet_model_2) + \
# criterion(mediate_IR_50_model_1, origin_IR_50_model_1) + \
# criterion(mediate_IR_152_model_1, origin_IR_152_model_1) + \
# criterion(mediate_IR_SE_50, origin_IR_SE_50) + \
# criterion(mediate_mobileFaceNet, origin_mobileFaceNet)+ \
# criterion(mediate_Insightface_iresent34, origin_Insightface_iresent34)+ \
# criterion(mediate_Insightface_iresent50, origin_Insightface_iresent50) + \
# criterion(mediate_Insightface_iresent100, origin_Insightface_iresent100) + \
# criterion(mediate_VGG16, origin_VGG16)
loss1 = criterion(mediate_average_out, origin_average_out)
# loss2 = criterion(mediate_InceptionResnet_model_1, mean_face) + \
# criterion(mediate_InceptionResnet_model_2, mean_face) + \
# criterion(mediate_IR_50_model_1, mean_face) + \
# criterion(mediate_IR_152_model_1, mean_face) +\
# criterion(mediate_IR_SE_50, mean_face) + \
# criterion(mediate_mobileFaceNet, mean_face) + \
# criterion(mediate_Insightface_iresent34, mean_face) + \
# criterion(mediate_Insightface_iresent50, mean_face) + \
# criterion(mediate_Insightface_iresent100, mean_face) + \
# criterion(mediate_VGG16, mean_face)
# loss2 = criterion(mediate_average_out, target_mean_face_average_out)
# loss3 = criterion(mediate_average_out,torch.zeros(512).detach())
loss2 = criterion(mediate_average_out, mean_face)
# loss3 = criterion(mediate_InceptionResnet_model_1,average_out)+ \
# criterion(mediate_InceptionResnet_model_2,average_out)+ \
# criterion(mediate_IR_50_model_1,average_out) + \
# criterion(mediate_IR_152_model_1,average_out) + \
# criterion(mediate_mobileFaceNet,average_out) + \
# criterion(mediate_Insightface_iresent34,average_out)+ \
# criterion(mediate_Insightface_iresent50,average_out) + \
# criterion(mediate_Insightface_iresent100,average_out)+ \
# criterion(mediate_VGG16,average_out)+ \
# criterion(mediate_IR_SE_50,average_out)
#
# loss = alpha * loss1 - beta* loss2 - gamma*loss3
loss = alpha * loss1 - beta * loss2
# print('loss : %f ' % loss,'loss1 : %f ' % loss1,'loss2 : %f ' % loss2,'loss3 : %f ' % loss3)
# compute gradients
loss.backward(retain_graph=True)
g_noise = momentum * g_noise + (in_variable.grad /
in_variable.grad.data.norm(1))
g_noise = g_noise / g_noise.data.norm(1)
g1 = g_noise
g2 = g_noise
# if i % 3 == 0 :
kernel = gkern(3, 2).astype(np.float32)
gaussian_blur1 = GaussianBlur(kernel)
gaussian_blur1
g1 = gaussian_blur1(g1)
# else:
addition = TVLoss()
addition
g2 = addition(g2)
g_noise = 0.25 * g1 + 0.75 * g2
in_variable.data = in_variable.data + (
(eps / 255.) * torch.sign(g_noise)
) # * torch.from_numpy(mat).unsqueeze(0).float()
in_variable.data = clip_by_tensor(in_variable.data,
in_variable_min.data,
in_variable_max.data)
in_variable.grad.data.zero_() # unnecessary
# del new_variable
# g_noise = in_variable.data - origin_variable
# g_noise.clamp_(-0.2, 0.2)
# in_variable.data = origin_variable + g_noise
# deprocess image
for i in range(len(in_variable.data.cpu().numpy())):
adv = in_variable.data.cpu().numpy()[i] # (3, 112, 112)
perturbation = (adv - in_tensor.cpu().numpy())
adv = adv * 128.0 + 127.0
adv = adv.swapaxes(0, 1).swapaxes(1, 2)
adv = adv[..., ::-1]
adv = np.clip(adv, 0, 255).astype(np.uint8)
# sample_dir = './target_mean_face/'
# if not os.path.exists(sample_dir):
# os.makedirs(sample_dir)
advimg = sample_dir + path[i].split('/')[-1].split(
'.')[-2] + '.jpg'
print(advimg)
cv2.imwrite(advimg, adv)
print("save path is " + advimg)
print('cost time is %.2f s ' % (time.time() - start))
count += 6
progressRate = count / 712.
def run(size):
models = []
anchor_models = []
optimizers = []
ratios = []
iters = []
cps = args.cp
save_names = []
loss_Meters = []
top1_Meters = []
best_test_accs = []
if args.constant_cp:
cps = args.cp * args.size
elif args.persistent:
cps = [5, 5, 5, 5, 5, 5, 5, 20, 20, 20]
else:
local_cps = args.cp * np.ones(size, dtype=int)
num_slow_nodes = int(size * args.slowRatio)
np.random.seed(2020)
random_cps = 5 + np.random.randn(num_slow_nodes) * 2
for i in range(len(random_cps)):
random_cps[i] = round(random_cps[i])
local_cps[:num_slow_nodes] = random_cps
# local_iterations = local_cps[rank]
cps = local_cps
for rank in range(args.size):
# initiate experiments folder
save_path = 'new_results/'
folder_name = save_path + args.name
if rank == 0 and os.path.isdir(folder_name) == False and args.save:
os.mkdir(folder_name)
# initiate log files
tag = '{}/lr{:.3f}_bs{:d}_cr{:d}_avgcp{:.3f}_e{}_r{}_n{}.csv'
saveFileName = tag.format(folder_name, args.lr, args.bs, args.cr,
np.mean(args.cp), args.seed, rank, size)
args.out_fname = saveFileName
save_names.append(saveFileName)
with open(args.out_fname, 'w+') as f:
print('BEGIN-TRAINING\n'
'World-Size,{ws}\n'
'Batch-Size,{bs}\n'
'itr,'
'Loss,avg:Loss,Prec@1,avg:Prec@1,val'.format(ws=args.size,
bs=args.bs),
file=f)
globalCp = args.globalCp
total_size = args.total_size
# seed for reproducibility
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.deterministic = True
# load datasets
train_loader, test_loader, dataRatio, x, y = partition_dataset(
rank, total_size, 1, args.alpha, args.beta, args)
ratios.append(dataRatio)
print(sum([len(i) for i in x]))
data_iter = iter(train_loader)
iters.append(data_iter)
# define neural nets model, criterion, and optimizer
model = util.select_model(args.model, args)
anchor_model = util.select_model(args.model, args)
models.append(model)
anchor_models.append(anchor_model)
criterion = nn.CrossEntropyLoss()
if args.FedProx:
optimizer = FedProx.FedProxSGD(model.parameters(),
lr=args.lr,
momentum=0,
nesterov=False,
weight_decay=1e-4)
else:
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=0,
nesterov=False,
weight_decay=1e-4)
optimizers.append(optimizer)
batch_idx = 0
best_test_accuracy = 0
best_test_accs.append(best_test_accuracy)
losses = util.Meter(ptag='Loss')
top1 = util.Meter(ptag='Prec@1')
loss_Meters.append(losses)
top1_Meters.append(top1)
model.train()
tic = time.time()
print(dataRatio, len(train_loader), len(test_loader))
round_communicated = 0
while round_communicated < args.cr:
for rank in range(args.size):
model = models[rank]
anchor_model = anchor_models[rank]
data_iter = iters[rank]
optimizer = optimizers[rank]
losses = loss_Meters[rank]
top1 = top1_Meters[rank]
for cp in range(cps[rank]):
try:
data, target = data_iter.next()
except StopIteration:
data_iter = iter(train_loader)
data, target = data_iter.next()
# data loading
data = data
target = target
# forward pass
output = model(data)
loss = criterion(output, target)
# backward pass
loss.backward()
if args.FedProx:
optimizer.step(anchor_model, args.mu)
else:
optimizer.step()
optimizer.zero_grad()
train_acc = util.comp_accuracy(output, target)
losses.update(loss.item(), data.size(0))
top1.update(train_acc[0].item(), data.size(0))
# batch_idx += 1
# change the worker
train_loader, dataRatio = get_next_trainloader(
round_communicated, x, y, rank, args)
data_iter = iter(train_loader)
iters[rank] = data_iter
ratios[rank] = dataRatio
if args.NSGD:
NormalSGDALLreduce(models, anchor_models, cps, globalCp, ratios)
elif args.FedProx:
FedProx_SyncAllreduce(models, ratios, anchor_models)
else:
unbalanced_SyncAllreduce(models, ratios)
round_communicated += 1
# update_lr(optimizer, round_communicated)
if round_communicated % 4 == 0:
for rank in range(args.size):
name = save_names[rank]
losses = loss_Meters[rank]
top1 = top1_Meters[rank]
with open(name, '+a') as f:
print('{itr},'
'{loss.val:.4f},{loss.avg:.4f},'
'{top1.val:.3f},{top1.avg:.3f},-1'.format(
itr=round_communicated, loss=losses, top1=top1),
file=f)
if round_communicated % 12 == 0:
for rank in range(args.size):
name = save_names[rank]
model = models[rank]
losses = loss_Meters[rank]
top1 = top1_Meters[rank]
name = save_names[rank]
test_acc, global_loss = evaluate(model, test_loader, criterion)
if test_acc > best_test_accs[rank]:
best_test_accs[rank] = test_acc
print('itr {}, '
'rank {}, loss value {:.4f}, '
'train accuracy {:.3f}, test accuracy {:.3f}, '
'elasped time {:.3f}'.format(round_communicated, rank,
losses.avg, top1.avg,
test_acc,
time.time() - tic))
with open(name, '+a') as f:
print('{itr},{filler},{filler},'
'{filler},{loss:.4f},'
'{val:.4f}'.format(itr=-1,
filler=-1,
loss=global_loss,
val=test_acc),
file=f)
losses.reset()
top1.reset()
tic = time.time()
# return
for rank in range(args.size):
name = save_names[rank]
with open(name, '+a') as f:
print('{itr} best test accuracy: {val:.4f}'.format(
itr=-2, val=best_test_accs[rank]),
file=f)
def main(args):
#load the dataset
num_tasks = 2 #how many tasks do we have?
emotion_folder = args['fer_path']
images_path = args['faces_path']
num_classes_emotion = len(emotion_table)
msra_cfw_faceid_datasets = {
x: msra.MSRA_CFW_FaceIDDataset(root_dir=images_path,
mode=x,
validation_folds=4,
test_split=0.0)
for x in ['train', 'val']
}
msra_cfw_dataloaders = {
x: torch.utils.data.DataLoader(msra_cfw_faceid_datasets[x],
batch_size=4,
shuffle=True,
num_workers=2)
for x in ['train', 'val']
}
# read FER+ dataset.
print("Loading data...")
fer_datasets = {
x: fplus_data.ferplus_Dataset(base_folder=emotion_folder,
train_folders=train_folders,
valid_folders=valid_folders,
mode=x,
classes=emotion_table)
for x in ['train', 'val']
}
fer_dataloaders = {
x: torch.utils.data.DataLoader(fer_datasets[x],
batch_size=4,
shuffle=True,
num_workers=2)
for x in ['train', 'val']
}
dataset_sizes_face = {
x: len(msra_cfw_faceid_datasets[x])
for x in ['train', 'val']
}
class_names_face = msra_cfw_faceid_datasets['train'].classes
num_classes_face = msra_cfw_faceid_datasets['train'].num_classes
#
print('Num batches : {}'.format(len(msra_cfw_dataloaders['train'])))
print('Dataset size : {}'.format(dataset_sizes_face['train']))
print('Number of classes: {}'.format(num_classes_face))
dataset_sizes_emotion = {x: len(fer_datasets[x]) for x in ['train', 'val']}
print('Num batches : {}'.format(len(fer_dataloaders['train'])))
print('Dataset size : {}'.format(dataset_sizes_emotion['train']))
print('Number of classes: {}'.format(num_classes_emotion))
use_gpu = torch.cuda.is_available()
dataloaders = [msra_cfw_dataloaders, fer_dataloaders]
dataset_sizes = [dataset_sizes_face, dataset_sizes_emotion]
num_classes = [num_classes_face, num_classes_emotion]
#load the model
weights_path = args['weights_path']
models = []
models_for_task = []
for task in range(0, num_tasks):
for col in range(0, task + 1):
model_vggf = vggf.imagenet_matconvnet_vgg_f_dag(col, weights_path)
num_ftrs = model_vggf.fc8.in_features # fc7 or fc8 ????
model_vggf.fc8 = nn.Linear(num_ftrs, num_classes[task])
models_for_task.append(model_vggf)
print(model_vggf)
models.append(models_for_task)
optimizer_fer = optim.SGD(models[1][1].parameters(),
lr=args['fer_lr'],
momentum=0.9)
optimizer_faces = optim.SGD(models[0][0].parameters(),
lr=args['faces_lr'],
momentum=0.9)
optimizers_vggf = [optimizer_faces, optimizer_fer]
scheduler_faces = lr_scheduler.StepLR(optimizer_faces,
step_size=args['faces_step'],
gamma=args['faces_gamma'])
scheduler_fer = lr_scheduler.StepLR(optimizer_fer,
step_size=args['fer_step'],
gamma=args['fer_gamma'])
schedulers_vggf = [scheduler_faces, scheduler_fer]
if use_gpu:
for task_id in range(0, num_tasks):
for col in range(0, task_id + 1):
models[task_id][col].cuda()
criterion = nn.CrossEntropyLoss()
models = train_model(num_tasks,
models,
dataloaders,
dataset_sizes,
criterion,
optimizers_vggf,
schedulers_vggf,
epochs=args['epochs'])
return cams
gallery_path = image_datasets['gallery'].imgs
query_path = image_datasets['query'].imgs
######################################################################
names = opt.names.split(',')
models = nn.ModuleList()
for name in names:
model_tmp, _, epoch = load_network(name, opt)
model_tmp.classifier.classifier = nn.Sequential()
model_tmp = torch.nn.DataParallel(model_tmp)
models.append(model_tmp.cuda().eval())
# Extract feature\
snapshot_feature_mat = './feature/submit_result_%s.mat' % opt.names
print('Feature Output Path: %s' % snapshot_feature_mat)
if not os.path.isfile(snapshot_feature_mat):
with torch.no_grad():
gallery_feature, query_feature = torch.FloatTensor(
), torch.FloatTensor()
for model in models:
q_f = extract_feature(model, dataloaders['query'])
q_f_crop = extract_feature(model, cropped_dataloaders['query'])
q_f = q_f + q_f_crop
qnorm = torch.norm(q_f, p=2, dim=1, keepdim=True)
q_f = q_f.div(qnorm.expand_as(q_f)) / np.sqrt(len(names))
def kaggle_bagging_test(test_data_dir,
model_name,
cpp1=None,
cpp2=None,
cpp3=None,
cpp4=None,
csv_path='./result.csv',
batch_size=BATCH_SIZE):
models = []
devices = []
image_size = make_model_setting(model_name=model_name)
print('===== MODEL INFO =====')
print('image size = {}'.format(image_size))
print('======================')
checkpoint_paths = [cpp1, cpp2, cpp3, cpp4]
if any(checkpoint_paths) is False:
print('[ERROR]all checkpoint files are empty')
return
checkpoint_paths = [cpp for cpp in checkpoint_paths if cpp is not None]
for i, checkpoint_path in enumerate(checkpoint_paths):
model_path = None
print('[INFO]read checkpoint: {}'.format(checkpoint_path))
with open(checkpoint_path, 'r') as load_f:
config = json.load(load_f)
model_path = config['model_path']
print(' read model: {}'.format(model_path))
# select device id
device_id = 'cuda:{}'.format(i)
device = torch.device(device_id)
model = make_model(model_path,
on_client=False,
model_name=model_name,
map_location=device)
model.eval()
models.append(model)
devices.append(device)
print('[INFO]models generated')
csv_path = os.path.abspath(csv_path)
csv_file, csv_write = generate_csv_handle(csv_path)
print('[INFO]create csvfile ok')
test_data_dir = os.path.abspath(test_data_dir)
test_transorms = default_transorms(image_size=image_size)
test_gen = TestDataset(test_data_dir, test_transorms=test_transorms)
test_dataiter = DataLoader(test_gen, batch_size=batch_size, shuffle=False)
print('[INFO]generate datasets ok')
preds = []
row = []
with torch.no_grad():
for i, data in enumerate(test_dataiter):
if i % 1000 == 0:
print('running on {}th batch'.format(i))
image = data[0]
filenames = data[1]
preds.clear()
for j, model in enumerate(models):
device = devices[j]
image = image.to(device)
pred = model(image)
pred = torch.nn.functional.softmax(pred, dim=0)
#pred = pred.cuda().data.cpu().numpy()
preds.append(pred)
preds_tensor = torch.stack(preds, dim=0)
preds_mean = preds_tensor.mean(dim=0)
preds_mean = preds_mean.cuda().data.cpu().numpy()
#pred = preds_mean.max(1, keepdim=True)[1]
row.clear()
for (filename, probs) in zip(filenames, preds_mean):
row.append(filename)
row.extend(probs)
csv_write.writerow(row)
row.clear()
csv_file.close()
print('save csv to {}'.format(csv_path))
def bagging_test(data_dir,
model_name,
cpp1=None,
cpp2=None,
cpp3=None,
cpp4=None,
batch_size=BATCH_SIZE,
incorrects_log='./incorrects.log',
valid_drivers=None):
models = []
devices = []
image_size = make_model_setting(model_name=model_name)
print('===== MODEL INFO =====')
print('image size = {}'.format(image_size))
print('======================')
checkpoint_paths = [cpp1, cpp2, cpp3, cpp4]
if any(checkpoint_paths) is False:
print('[ERROR]all checkpoint files are empty')
return
checkpoint_paths = [cpp for cpp in checkpoint_paths if cpp is not None]
for i, checkpoint_path in enumerate(checkpoint_paths):
model_path = None
print('[INFO]read checkpoint: {}'.format(checkpoint_path))
with open(checkpoint_path, 'r') as load_f:
config = json.load(load_f)
model_path = config['model_path']
print(' read model: {}'.format(model_path))
device_id = 'cuda:{}'.format(i)
device = torch.device(device_id)
model = make_model(model_path,
on_client=False,
model_name=model_name,
map_location=device)
model = model.to(device)
model.eval()
models.append(model)
devices.append(device)
print('[INFO]models generated')
valid_transorms = default_transorms(image_size=image_size)
#valid_dataset = ImageFolder(valid_data_dir, transform=valid_transorms)
valid_dataset = DriverDataset(data_dir, valid_transorms, valid_drivers)
print('[INFO]generate datasets ok')
# output incorrects to file
inc_f = open(incorrects_log, 'w')
def incorrect_record(info=None, records=None):
if info is not None:
inc_f.write(info)
inc_f.write('\n')
if records is not None:
for record in records:
read_index = record[0]
pred = record[1]
data_index = valid_dataset.used_images[read_index]
filename = valid_dataset.image_paths[data_index]
label = valid_dataset.labels[filename]
text = '{}:{}:{}\n'.format(filename, label, pred)
inc_f.write(text)
criterion = torch.nn.CrossEntropyLoss()
loss, correct, _, incorrects = bagging_valid(models, criterion,
valid_dataset, devices)
print('Valid set: Average of loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.
format(loss, correct, len(valid_dataset),
100. * correct / len(valid_dataset)))
incorrect_record(records=incorrects)
inc_f.close()
def main():
eps = FLAGS.max_epsilon / 255.0
num_iter = FLAGS.num_iter
alpha = eps / num_iter
momentum = FLAGS.momentum
num_classes = 1000
batch_shape = [FLAGS.batch_size, 3, FLAGS.image_height, FLAGS.image_width]
# model selection
main_device = 'cuda:0'
model_names = [
'tf_efficientnet_b6_ns', 'resnest269e', 'vit_large_patch16_384',
'tf_efficientnet_b6_ap'
]
models = []
for i, model_name in enumerate(model_names):
model = timm.create_model(model_name,
num_classes=1000,
pretrained=True)
model = model.to('cuda:{}'.format(i))
model.eval()
models.append(model)
def forward_map_func(args_dict, q):
# with global variables mdoels and main_device
i = args_dict['id']
x_adv = args_dict['tensor']
diverse_input = input_diversity(x_adv)
image_resize = models[i].default_cfg['input_size'][1:]
mean = torch.tensor(models[i].default_cfg['mean']).view(
3, 1, 1).to(main_device)
std = torch.tensor(models[i].default_cfg['std']).view(
3, 1, 1).to(main_device)
resized_tensor = F.interpolate(diverse_input,
size=image_resize,
mode='bicubic')
gaussian_tensor = functional.gaussian_blur(resized_tensor,
kernel_size=(5, 5),
sigma=(0.9, 0.9))
normalized_tensor = (gaussian_tensor - mean) / std
output = models[i](normalized_tensor.to(
'cuda:{}'.format(i))).to(main_device)
q.put(output)
print(time.time() - start_time)
for filenames, images, labels in load_images(
os.path.join(FLAGS.input_dir, 'images'), batch_shape):
batch_start = time.time()
input_image = torch.from_numpy(images).float().to(main_device)
input_tensor = input_image.to(main_device)
print(labels)
target = torch.from_numpy(labels).long().to(main_device)
grad = torch.zeros_like(input_tensor)
clip_tensor_one = torch.ones_like(input_tensor)
clip_tensor_zero = torch.zeros_like(input_tensor)
x_max = clip_by_tensor(input_tensor + eps, clip_tensor_zero,
clip_tensor_one)
x_min = clip_by_tensor(input_tensor - eps, clip_tensor_zero,
clip_tensor_one)
x_adv = input_tensor
for i in range(FLAGS.num_iter):
x_adv = x_adv.clone().detach().requires_grad_(True)
import threading
from queue import Queue
q = Queue()
threads = []
for d in range(len(model_names)):
t = threading.Thread(target=forward_map_func,
args=({
'id': d,
'tensor': x_adv
}, q))
threads.append(t)
t.start()
[thread.join() for thread in threads]
logits = torch.zeros(
(FLAGS.batch_size, num_classes)).to(main_device)
for index in range(len(threads)):
logits += q.get().to(main_device) / len(models)
# loss = F.cross_entropy(logits, target)
loss = CW_loss(logits, target)
loss.backward()
noise = x_adv.grad
noise = noise / torch.mean(
torch.abs(noise), dim=[1, 2, 3], keepdim=True)
noise = momentum * grad + noise
x_adv = x_adv + alpha * torch.sign(noise)
x_adv = clip_by_tensor(x_adv, x_min, x_max)
grad = noise
save_images(
x_adv.permute(0, 2, 3, 1).detach().cpu().numpy(), filenames,
FLAGS.output_dir)
print(time.time() - batch_start)
def create_network(blocks):
models = nn.ModuleList()
prev_filters = 3
out_filters = []
conv_id = 0
for block in blocks:
if block['type'] == 'net':
prev_filters = int(block['channels'])
continue
elif block['type'] == 'convolutional':
conv_id = conv_id + 1
batch_normalize = int(block['batch_normalize'])
filters = int(block['filters'])
kernel_size = int(block['size'])
stride = int(block['stride'])
is_pad = int(block['pad'])
pad = (kernel_size - 1) // 2 if is_pad else 0
activation = block['activation']
model = nn.Sequential()
if batch_normalize:
model.add_module(
'conv{0}'.format(conv_id),
nn.Conv2d(prev_filters,
filters,
kernel_size,
stride,
pad,
bias=False))
model.add_module('bn{0}'.format(conv_id),
nn.BatchNorm2d(filters))
#model.add_module('bn{0}'.format(conv_id), BN2d(filters))
else:
model.add_module(
'conv{0}'.format(conv_id),
nn.Conv2d(prev_filters, filters, kernel_size, stride, pad))
if activation == 'leaky':
model.add_module('leaky{0}'.format(conv_id),
nn.LeakyReLU(0.1, inplace=True))
elif activation == 'relu':
model.add_module('relu{0}'.format(conv_id),
nn.ReLU(inplace=True))
prev_filters = filters
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'maxpool':
pool_size = int(block['size'])
stride = int(block['stride'])
if stride > 1:
model = nn.MaxPool2d(pool_size, stride)
else:
model = MaxPoolStride1()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'avgpool':
model = GlobalAvgPool2d()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'softmax':
model = nn.Softmax()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'cost':
if block['_type'] == 'sse':
model = nn.MSELoss(size_average=True)
elif block['_type'] == 'L1':
model = nn.L1Loss(size_average=True)
elif block['_type'] == 'smooth':
model = nn.SmoothL1Loss(size_average=True)
out_filters.append(1)
models.append(model)
elif block['type'] == 'reorg':
stride = int(block['stride'])
prev_filters = stride * stride * prev_filters
out_filters.append(prev_filters)
models.append(Reorg(stride))
elif block['type'] == 'route':
layers = block['layers'].split(',')
ind = len(models)
layers = [int(i) if int(i) > 0 else int(i) + ind for i in layers]
if len(layers) == 1:
prev_filters = out_filters[layers[0]]
elif len(layers) == 2:
assert (layers[0] == ind - 1)
prev_filters = out_filters[layers[0]] + out_filters[layers[1]]
out_filters.append(prev_filters)
models.append(EmptyModule())
elif block['type'] == 'shortcut':
ind = len(models)
prev_filters = out_filters[ind - 1]
out_filters.append(prev_filters)
models.append(EmptyModule())
elif block['type'] == 'connected':
filters = int(block['output'])
if block['activation'] == 'linear':
model = nn.Linear(prev_filters, filters)
elif block['activation'] == 'leaky':
model = nn.Sequential(nn.Linear(prev_filters, filters),
nn.LeakyReLU(0.1, inplace=True))
elif block['activation'] == 'relu':
model = nn.Sequential(nn.Linear(prev_filters, filters),
nn.ReLU(inplace=True))
prev_filters = filters
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'region':
loss = RegionLoss()
anchors = block['anchors'].split(',')
loss.anchors = [float(i) for i in anchors]
loss.num_classes = int(block['classes'])
loss.num_anchors = int(block['num'])
loss.anchor_step = len(loss.anchors) / loss.num_anchors
loss.object_scale = float(block['object_scale'])
loss.noobject_scale = float(block['noobject_scale'])
loss.class_scale = float(block['class_scale'])
loss.coord_scale = float(block['coord_scale'])
out_filters.append(prev_filters)
models.append(loss)
else:
print('unknown type %s' % (block['type']))
return models
