def main(args):
if args.method == 'dann':
train_fn = train_dann.train_dann
elif args.method == 'adda':
train_fn = train_adda.train_adda
elif args.method == 'dcc':
train_fn = train_dcc.train_dcc
elif args.method == 'cleitcs':
train_fn = train_cleitcs.train_cleitcs
else:
train_fn = train_coral.train_coral
device = 'cuda' if torch.cuda.is_available() else 'cpu'
with open(os.path.join('model_save', 'train_params.json'), 'r') as f:
training_params = json.load(f)
training_params.update(
{
'device': device,
'model_save_folder': os.path.join('model_save', args.method, 'labeled'),
})
safe_make_dir(training_params['model_save_folder'])
data_provider = DataProvider(batch_size=training_params['labeled']['batch_size'],
target=args.measurement)
training_params.update(
{
'input_dim': data_provider.shape_dict['gex'],
'output_dim': data_provider.shape_dict['target']
}
)
s_labeled_dataloader = data_provider.get_labeled_gex_dataloader()
labeled_dataloader_generator = data_provider.get_drug_labeled_mut_dataloader()
s_ft_evaluation_metrics = defaultdict(list)
t_ft_evaluation_metrics = defaultdict(list)
val_ft_evaluation_metrics = defaultdict(list)
test_ft_evaluation_metrics = defaultdict(list)
fold_count = 0
for train_labeled_dataloader, val_labeled_dataloader, test_labeled_dataloader in labeled_dataloader_generator:
target_regressor, train_historys = train_fn(s_dataloaders=s_labeled_dataloader,
t_dataloaders=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=test_labeled_dataloader,
metric_name=args.metric,
seed = fold_count,
**wrap_training_params(training_params, type='labeled'))
for metric in ['dpearsonr', 'dspearmanr', 'drmse', 'cpearsonr', 'cspearmanr', 'crmse']:
val_ft_evaluation_metrics[metric].append(train_historys[-2][metric][train_historys[-2]['best_index']])
test_ft_evaluation_metrics[metric].append(train_historys[-1][metric][train_historys[-2]['best_index']])
fold_count += 1
with open(os.path.join(training_params['model_save_folder'], f'test_ft_evaluation_results.json'), 'w') as f:
json.dump(test_ft_evaluation_metrics, f)
with open(os.path.join(training_params['model_save_folder'], f'ft_evaluation_results.json'), 'w') as f:
json.dump(val_ft_evaluation_metrics, f)
def main(args):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
with open(os.path.join('model_save', 'train_params.json'), 'r') as f:
training_params = json.load(f)
training_params.update(
{
'device': device,
'model_save_folder': os.path.join('model_save', 'mlp', args.omics),
})
data_provider = DataProvider(batch_size=training_params['unlabeled']['batch_size'],
target=args.measurement)
training_params.update(
{
'input_dim': data_provider.shape_dict[args.omics],
'output_dim': data_provider.shape_dict['target']
}
)
ft_evaluation_metrics = defaultdict(list)
if args.omics == 'gex':
labeled_dataloader_generator = data_provider.get_drug_labeled_gex_dataloader()
fold_count = 0
for train_labeled_dataloader, val_labeled_dataloader in labeled_dataloader_generator:
target_regressor, ft_historys = fine_tune_encoder(
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=val_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
**wrap_training_params(training_params, type='labeled')
)
for metric in ['dpearsonr', 'dspearmanr','drmse', 'cpearsonr', 'cspearmanr','crmse']:
ft_evaluation_metrics[metric].append(ft_historys[-2][metric][ft_historys[-2]['best_index']])
fold_count += 1
else:
labeled_dataloader_generator = data_provider.get_drug_labeled_mut_dataloader()
fold_count = 0
test_ft_evaluation_metrics = defaultdict(list)
for train_labeled_dataloader, val_labeled_dataloader, test_labeled_dataloader in labeled_dataloader_generator:
target_regressor, ft_historys = fine_tune_encoder(
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=test_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
**wrap_training_params(training_params, type='labeled')
)
for metric in ['dpearsonr', 'dspearmanr','drmse', 'cpearsonr', 'cspearmanr','crmse']:
ft_evaluation_metrics[metric].append(ft_historys[-2][metric][ft_historys[-2]['best_index']])
test_ft_evaluation_metrics[metric].append(ft_historys[-1][metric][ft_historys[-2]['best_index']])
fold_count += 1
with open(os.path.join(training_params['model_save_folder'], f'test_ft_evaluation_results.json'), 'w') as f:
json.dump(test_ft_evaluation_metrics, f)
with open(os.path.join(training_params['model_save_folder'], f'ft_evaluation_results.json'), 'w') as f:
json.dump(ft_evaluation_metrics, f)
def test_gan(gan_type,
g_input,
g_output,
d_input,
d_output,
epochs=3,
verbose=False):
# we have to reinstantiate the generator and discriminator or the weights won't be reset
generator = Model(g_input, g_output, name='generator')
discriminator = Model(d_input, d_output, name='discriminator')
gan_model = gan_type(generator, discriminator)
gan_model.num_data = len(metadata)
gan_model.compile()
data_train = DataProvider(metadata_train)
# build a dictionary mapping between name strings and ids
data_train.class_to_id = dict((n, i) for i, n in enumerate(classes))
data_train.id_to_class = dict((i, n) for i, n in enumerate(classes))
data_test = DataProvider(metadata_test)
data_test.class_to_id = dict((n, i) for i, n in enumerate(classes))
data_test.id_to_class = dict((i, n) for i, n in enumerate(classes))
gan_model.train(epochs, data_train, data_test, verbose=verbose)
def main():
hidden_units = 15
outputs = 1
inputs = 5
examples = 100
sequence_length = 10
learning_rate = 0.001
# Shapes of weights:
# Input -> hidden connections
# W_ih.shape = (inputs, hidden_units)
# b_ih.shape = (hidden_units,)
# Hidden -> hidden connections
# W_hh.shape = (hidden_units, hidden_units)
# Hidden -> output connections
# W_hk.shape = (hidden_units, outputs)
# b_hk.shape = (outputs,)
# Load trained network.
filename = r"model/trained_net.wts.npz"
W_ih, b_ih, W_hh, W_hk, b_hk = load_params(filename)
# Get training set.
d = DataProvider(examples, sequence_length, inputs, outputs)
# x.shape = (sequence_length, inputs)
# z.shape = (sequence_length, 1)
x, z = d.get_example(0)
# dictionary where key is the timestamp.
a_h = {}
b_h = dict()
b_h[-1] = np.zeros_like(b_ih)
a_k = {}
y = {}
for t in range(sequence_length):
a_h[t] = None # TODO: (3.30), don't forget bias parameter
b_h[t] = None # TODO: (3.31), hint: theta_h = tanh
a_k[t] = None # TODO: (3.32), don't forget bias parameter
y[t] = None # TODO: Binary classification
plot_predictions(y)
def main():
global cfg
cfg = DefaultConfig()
args = {
'resnet18': RESNET18_SUNRGBD_CONFIG().args(),
}
# Setting random seed
# if cfg.MANUAL_SEED is None:
# cfg.MANUAL_SEED = random.randint(1, 10000)
# random.seed(cfg.MANUAL_SEED)
# torch.manual_seed(cfg.MANUAL_SEED)
# args for different backbones
cfg.parse(args['resnet18'])
run_id = random.randint(1, 100000)
summary_dir = '/home/lzy/summary/generateDepth/' + 'train_rgb_' + str(
run_id)
if not os.path.exists(summary_dir):
os.mkdir(summary_dir)
writer = SummaryWriter(summary_dir)
cfg.LR = 0.0001
os.environ["CUDA_VISIBLE_DEVICES"] = '1,2'
device_ids = torch.cuda.device_count()
print('device_ids:', device_ids)
# project_name = reduce(lambda x, y: str(x) + '/' + str(y), os.path.realpath(__file__).split(os.sep)[:-1])
# util.mkdir('logs')
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
# normalize=transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# data
train_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
val_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
# train_loader = torch.utils.data.DataLoader(
# train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True,
# num_workers=4, pin_memory=True, sampler=None)
# val_loader = torch.utils.data.DataLoader(
# val_dataset,batch_size=16, shuffle=False,
# num_workers=4, pin_memory=True)
train_loader = DataProvider(cfg,
dataset=train_dataset,
batch_size=40,
shuffle=True)
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=10,
shuffle=False)
# class weights
# num_classes_train = list(Counter([i[1] for i in train_loader.dataset.imgs]).values())
# cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train)
# writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard
# net_classification_1=resnet50(pretrained=True)
# net_classification_2=resnet50(pretrained=True)
# net_classification_1 = models.__dict__['resnet18'](num_classes=365)
# net_classification_2 = models.__dict__['resnet18'](num_classes=365)
net_classification_1 = torch.hub.load('facebookresearch/WSL-Images',
'resnext101_32x16d_wsl')
# net_classification_2=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl')
# for param in net_classification_1.parameters():
# param.requires_grad = False
# for param in net_classification_2.parameters():
# param.requires_grad = True
net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),
nn.Linear(2048, 1024),
nn.LeakyReLU(inplace=True),
nn.Linear(1024, 67))
# net_classification_2.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048, 1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67))
net_classification_1.load_state_dict(
torch.load(
"./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl"))
# net_classification_2.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl"))
# net_classification_2
# load_path = "/home/dudapeng/workspace/pretrained/place/resnet18_places365.pth"
# checkpoint = torch.load(load_path, map_location=lambda storage, loc: storage)
# state_dict = {str.replace(k, 'module.', ''): v for k, v in checkpoint['state_dict'].items()}
# net_classification_1.load_state_dict(state_dict)
# net_classification_2.load_state_dict(state_dict)
print(net_classification_1)
# num_ftrs = net_classification_1.fc.in_features
# net_classification_1.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES)
# num_ftrs = net_classification_2.fc.in_features
# net_classification_2.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES)
net_classification_1.cuda()
# net_classification_2.cuda()
cudnn.benchmark = True
# if cfg.GENERATE_Depth_DATA:
# print('GENERATE_Depth_DATA model set')
# cfg_generate = copy.deepcopy(cfg)
# cfg_generate.CHECKPOINTS_DIR='/home/lzy/generateDepth/checkpoints/best_AtoB/trecg_AtoB_best.pth'
# cfg_generate.GENERATE_Depth_DATA = False
# cfg_generate.NO_UPSAMPLE = False
# checkpoint = torch.load(cfg_generate.CHECKPOINTS_DIR)
# model = define_TrecgNet(cfg_generate, upsample=True,generate=True)
# load_checkpoint_depth(model,cfg_generate.CHECKPOINTS_DIR, checkpoint, data_para=True)
# generate_model = torch.nn.DataParallel(model).cuda()
# generate_model.eval()
net_classification_1 = torch.nn.DataParallel(net_classification_1).cuda()
# net_classification_2 = torch.nn.DataParallel(net_classification_2).cuda()
criterion = nn.CrossEntropyLoss().cuda()
best_mean_1 = 0
# best_mean_2=0
# optimizer = optim.SGD(model_ft.parameters(), lr=0.05,momentum=0.9)#,weight_decay=0.00005)
optimizer_1 = torch.optim.SGD(net_classification_1.parameters(),
lr=cfg.LR,
momentum=cfg.MOMENTUM,
weight_decay=cfg.WEIGHT_DECAY)
# optimizer_2 = torch.optim.SGD(net_classification_2.parameters(),lr=cfg.LR,momentum=cfg.MOMENTUM,weight_decay=cfg.WEIGHT_DECAY)
for epoch in range(0, 100):
adjust_learning_rate(optimizer_1, epoch)
# meanacc_1,meanacc_2=validate(val_loader, net_classification_1,net_classification_2,generate_model,criterion,epoch)
#
train(train_loader, net_classification_1, criterion, optimizer_1,
epoch, writer)
meanacc_1 = validate(val_loader, net_classification_1, criterion,
epoch, writer)
# meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer)
# train(train_loader,net_classification_2,generate_model,criterion,optimizer_2,epoch,writer)
# meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer)
# writer.add_image(depth_image[0])
# save best
if meanacc_1 > best_mean_1:
best_mean_1 = meanacc_1
print('best_mean_color:', str(best_mean_1))
save_checkpoint(
{
'epoch': epoch,
'arch': cfg.ARCH,
'state_dict': net_classification_1.state_dict(),
'best_mean_1': best_mean_1,
'optimizer': optimizer_1.state_dict(),
},
CorD=True)
# if meanacc_2>best_mean_2:
# best_mean_2=meanacc_2
# print('best_mean_depth:',str(best_mean_2))
# save_checkpoint({
# 'epoch': epoch,
# 'arch': cfg.ARCH,
# 'state_dict': net_classification_2.state_dict(),
# 'best_mean_2': best_mean_2,
# 'optimizer' : optimizer_2.state_dict(),
# },CorD=False)
print('best_mean_color:', str(best_mean_1))
writer.add_scalar('mean_acc_color', meanacc_1, global_step=epoch)
# writer.add_scalar('mean_acc_depth', meanacc_2, global_step=epoch)
writer.add_scalar('best_meanacc_color', best_mean_1, global_step=epoch)
# writer.add_scalar('best_meanacc_depth', best_mean_2, global_step=epoch)
writer.close()
def build_encoder(args):
train_fn = train_vae.train_vae
device = 'cuda' if torch.cuda.is_available() else 'cpu'
with open(os.path.join('model_save', 'train_params.json'), 'r') as f:
training_params = json.load(f)
parsed_ft_params = parsing_utils.parse_hyper_vae_ft_evaluation_result(
metric_name=args.metric)
training_params['unlabeled'].update(parsed_ft_params[0])
training_params['labeled']['train_num_epochs'] = parsed_ft_params[1]
training_params.update({
'device':
device,
'model_save_folder':
os.path.join('model_save', 'ae500'),
'es_flag':
False,
'retrain_flag':
True
})
task_save_folder = training_params['model_save_folder']
safe_make_dir(training_params['model_save_folder'])
random.seed(2020)
data_provider = DataProvider(
batch_size=training_params['unlabeled']['batch_size'],
target=args.measurement)
training_params.update({
'input_dim': data_provider.shape_dict['gex'],
'output_dim': data_provider.shape_dict['target']
})
encoder, historys = train_fn(
dataloader=data_provider.get_unlabeled_gex_dataloader(),
**wrap_training_params(training_params, type='unlabeled'))
with open(
os.path.join(training_params['model_save_folder'],
f'unlabel_train_history.pickle'), 'wb') as f:
for history in historys:
pickle.dump(dict(history), f)
ft_evaluation_metrics = defaultdict(list)
labeled_dataloader = data_provider.get_labeled_gex_dataloader()
ft_encoder = deepcopy(encoder)
target_regressor, ft_historys = fine_tuning.fine_tune_encoder_new(
encoder=ft_encoder,
train_dataloader=labeled_dataloader,
val_dataloader=labeled_dataloader,
test_dataloader=None,
seed=2021,
metric_name=args.metric,
task_save_folder=task_save_folder,
**wrap_training_params(training_params, type='labeled'))
for metric in ['dpearsonr', 'drmse', 'cpearsonr', 'crmse']:
try:
ft_evaluation_metrics[metric].append(ft_historys[-2][metric][-1])
except:
pass
with open(os.path.join(task_save_folder, f'ft_evaluation_results.json'),
'w') as f:
json.dump(ft_evaluation_metrics, f)
torch.save(target_regressor.encoder.state_dict(),
os.path.join('model_save', 'reference_encoder.pt'))
cfg,
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose(train_transforms))
val_dataset = SPL10.SPL10_Dataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
SPL10.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
SPL10.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
RGB2Lab(),
SPL10.ToTensor(),
SPL10.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
train_loader = DataProvider(cfg, dataset=train_dataset)
val_loader = DataProvider(cfg, dataset=val_dataset, shuffle=False)
num_classes_train = list(
Counter([i[1] for i in train_loader.dataset.imgs]).values())
cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train)
model = Contrastive_CrossModal_Conc(cfg, device=device)
model = nn.DataParallel(model).to(device)
optim = Adam(model.parameters(), lr=cfg.LR)
load_model = False
if load_model:
model = torch.load('./checkpoint/model_1_LAB.mdl')
print("load pretrained model")
# loss_optim = Adam(infomax_fn.parameters(), lr=2e-4)
# cls_criterion = torch.nn.CrossEntropyLoss(cfg.CLASS_WEIGHTS_TRAIN.to(device))
def main(args, update_params_dict):
if args.method == 'cleitm':
train_fn = train_cleitm.train_cleitm
elif args.method == 'cleita':
train_fn = train_cleita.train_cleita
elif args.method == 'cleitc':
train_fn = train_cleitc.train_cleitc
elif args.method == 'dsn':
train_fn = train_dsn.train_dsn
else:
train_fn = train_cleit.train_cleit
device = 'cuda' if torch.cuda.is_available() else 'cpu'
with open(os.path.join('model_save', 'train_params.json'), 'r') as f:
training_params = json.load(f)
training_params['unlabeled'].update(update_params_dict)
param_str = dict_to_str(update_params_dict)
training_params.update({
'device':
device,
'model_save_folder':
os.path.join('model_save', args.method, param_str),
'es_flag':
False,
'retrain_flag':
args.retrain_flag
})
task_save_folder = os.path.join('model_save', args.method,
args.measurement)
safe_make_dir(training_params['model_save_folder'])
safe_make_dir(task_save_folder)
data_provider = DataProvider(
batch_size=training_params['unlabeled']['batch_size'],
target=args.measurement)
training_params.update({
'input_dim': data_provider.shape_dict['gex'],
'output_dim': data_provider.shape_dict['target']
})
random.seed(2020)
labeled_dataloader_generator = data_provider.get_labeled_data_generator(
omics='mut')
ft_evaluation_metrics = defaultdict(list)
test_ft_evaluation_metrics = defaultdict(list)
fold_count = 0
# start unlabeled training
if 'cleit' not in args.method:
encoder, historys = train_fn(
s_dataloaders=data_provider.get_unlabeld_mut_dataloader(
match=True),
t_dataloaders=data_provider.get_unlabeled_gex_dataloader(),
**wrap_training_params(training_params, type='unlabeled'))
with open(
os.path.join(training_params['model_save_folder'],
f'unlabel_train_history.pickle'), 'wb') as f:
for history in historys:
pickle.dump(dict(history), f)
for train_labeled_dataloader, val_labeled_dataloader, test_labeled_dataloader in labeled_dataloader_generator:
ft_encoder = deepcopy(encoder)
target_regressor, ft_historys = fine_tuning.fine_tune_encoder(
encoder=ft_encoder,
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=test_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
task_save_folder=task_save_folder,
**wrap_training_params(training_params, type='labeled'))
with open(
os.path.join(training_params['model_save_folder'],
f'ft_train_history_{fold_count}.pickle'),
'wb') as f:
for history in ft_historys:
pickle.dump(dict(history), f)
for metric in [
'dpearsonr', 'dspearmanr', 'drmse', 'cpearsonr',
'cspearmanr', 'crmse'
]:
ft_evaluation_metrics[metric].append(
ft_historys[-2][metric][ft_historys[-2]['best_index']])
test_ft_evaluation_metrics[metric].append(
ft_historys[-1][metric][ft_historys[-2]['best_index']])
fold_count += 1
else:
for train_labeled_dataloader, val_labeled_dataloader, test_labeled_dataloader in labeled_dataloader_generator:
encoder, historys = train_fn(
dataloader=data_provider.get_unlabeld_mut_dataloader(
match=True),
seed=fold_count,
**wrap_training_params(training_params, type='unlabeled'))
ft_encoder = deepcopy(encoder)
target_regressor, ft_historys = fine_tuning.fine_tune_encoder(
encoder=ft_encoder,
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=test_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
task_save_folder=task_save_folder,
**wrap_training_params(training_params, type='labeled'))
for metric in [
'dpearsonr', 'dspearmanr', 'drmse', 'cpearsonr',
'cspearmanr', 'crmse'
]:
ft_evaluation_metrics[metric].append(
ft_historys[-2][metric][ft_historys[-2]['best_index']])
test_ft_evaluation_metrics[metric].append(
ft_historys[-1][metric][ft_historys[-2]['best_index']])
fold_count += 1
with open(
os.path.join(training_params['model_save_folder'],
f'ft_train_history_{fold_count}.pickle'),
'wb') as f:
for history in ft_historys:
pickle.dump(dict(history), f)
with open(
os.path.join(task_save_folder,
f'{param_str}_test_ft_evaluation_results.json'),
'w') as f:
json.dump(test_ft_evaluation_metrics, f)
with open(
os.path.join(task_save_folder,
f'{param_str}_ft_evaluation_results.json'),
'w') as f:
json.dump(ft_evaluation_metrics, f)
for i in range(train_y_truths.shape[0])
]).item())
train_history['drmse'].append(
np.mean(
np.nanmean(np.square((train_y_truths - train_y_preds)),
axis=0)).item())
train_history['crmse'].append(
np.mean(
np.nanmean(np.square((train_y_truths - train_y_preds)),
axis=1)).item())
return (train_history, test_history)
if __name__ == '__main__':
data_provider = DataProvider()
labeled_samples, mut_only_labeled_samples = data_provider.get_labeled_samples(
)
labeled_target_df = data_provider.target_df.loc[labeled_samples]
labeled_mut_only_target_df = data_provider.target_df.loc[
mut_only_labeled_samples]
label_gex_df = data_provider.gex_dat.loc[labeled_samples]
label_mut_df = data_provider.mut_dat.loc[labeled_samples]
label_mut_only_df = data_provider.mut_dat.loc[mut_only_labeled_samples]
train_gex_data = (label_gex_df, labeled_target_df)
train_mut_data = (label_mut_df, labeled_target_df)
test_data = (label_mut_only_df, labeled_mut_only_target_df)
gex_train_history, _ = n_time_cv_regress(train_gex_data,
'gex_pred',
def main():
hidden_units = 15
outputs = 1
inputs = 5
examples = 100
sequence_length = 10
weight_norm_factor = 0.01
epochs = 1000
momentum = 0.9
learning_rate = 0.001
np.random.seed(
1) # Initialize with the seed so that results are reproducable.
# Input -> hidden connections
W_ih = np.random.randn(inputs, hidden_units) * weight_norm_factor
b_ih = np.zeros((hidden_units, ))
# Hidden -> hidden connections
W_hh = np.random.randn(hidden_units, hidden_units) * weight_norm_factor
# Hidden -> output connections
W_hk = np.random.randn(hidden_units, outputs) * weight_norm_factor
b_hk = np.zeros((outputs, ))
# Get training set.
d = DataProvider(examples, sequence_length, inputs, outputs)
update_W_ih = np.zeros_like(W_ih)
update_b_ih = np.zeros_like(b_ih)
update_W_hh = np.zeros_like(W_hh)
update_W_hk = np.zeros_like(W_hk)
update_b_hk = np.zeros_like(b_hk)
loss = dict()
for epoch in range(epochs):
loss[epoch] = 0
print(str.format("Epoch {0} / {1}", epoch, epochs))
for d_id in range(d.get_example_count()):
# x.shape = (sequence_length, inputs)
# z.shape = (sequence_length, 1)
x, z = d.get_example(d_id)
# Auxiliary variables.
a_h = {}
b_h = dict()
b_h[-1] = np.zeros_like(b_ih)
a_k = {}
y = {}
for t in range(sequence_length):
# TODO: forward pass and loss. You can just copy/pase solution from rnn_fwd.py
# P.S. don't forget biases.
a_h[t] = None # TODO: (3.30), don't forget bias parameter
b_h[t] = None # TODO: (3.31), hint: theta_h = tanh
a_k[t] = None # TODO: (3.32), don't forget bias parameter
y[t] = None # TODO: Binary classification
loss[epoch] += get_loss(y[t], z[t])
# plot_predictions(y)
# Back-propagation through time
# Calculate deltas
delta_k = {}
delta_h = dict()
delta_h[sequence_length] = np.zeros((hidden_units, ))
for t in reversed(range(sequence_length)):
# Backward pass, deltas
delta_k[t] = None # TODO: (3.19), (3.23)
delta_h[t] = None # TODO: (3.33)
# TODO: Calculate gradients, everything is derived from (3.35)
d_W_ih = np.zeros_like(W_ih)
d_b_ih = np.zeros_like(b_ih)
d_W_hh = np.zeros_like(W_hh)
d_W_hk = np.zeros_like(W_hk)
d_b_hk = np.zeros_like(b_hk)
for t in range(sequence_length):
d_W_ih += None # TODO: (3.35)
d_b_ih += None # TODO: (3.35), hint: b_i^t = 1
d_W_hh += None # TODO: (3.35)
d_W_hk += None # TODO: (3.35)
d_b_hk += None # TODO: (3.35), hint: b_i^t = 1
# Clip gradients to mitigate exploding gradients
clip_threshold = 3
for gradients in [d_W_ih, d_b_ih, d_W_hh, d_W_hk, d_b_hk]:
np.clip(gradients,
-clip_threshold,
clip_threshold,
out=gradients)
# Calculate updates using momentum and learning rate, apply (3.39)
update_W_ih = momentum * update_W_ih - learning_rate * d_W_ih
update_b_ih = momentum * update_b_ih - learning_rate * d_b_ih
update_W_hh = momentum * update_W_hh - learning_rate * d_W_hh
update_W_hk = momentum * update_W_hk - learning_rate * d_W_hk
update_b_hk = momentum * update_b_hk - learning_rate * d_b_hk
# Apply gradients
W_ih += update_W_ih
b_ih += update_b_ih
W_hh += update_W_hh
W_hk += update_W_hk
b_hk += update_b_hk
plot_predictions(loss)
filename = r"model/trained_net.wts.npz"
save_params(filename, W_ih, b_ih, W_hh, W_hk, b_hk)
W_ih, b_ih, W_hh, W_hk, b_hk = load_params(filename)
x, z = d.get_example(0)
a_h = {}
b_h = dict()
b_h[-1] = np.zeros_like(b_ih)
a_k = {}
y = {}
for t in range(sequence_length):
a_h[t] = np.dot(x[t], W_ih) + b_ih + np.dot(b_h[t - 1], W_hh) # (3.30)
b_h[t] = np.tanh(a_h[t]) # (3.31)
a_k[t] = np.dot(b_h[t], W_hk) + b_hk # (3.32)
y[t] = sigmoid(a_k[t]) # Binary classification
plot_predictions(y)
def train():
cfg = DefaultConfig()
args = {
'resnet18': RESNET18_SUNRGBD_CONFIG().args(),
}
# Setting random seed
if cfg.MANUAL_SEED is None:
cfg.MANUAL_SEED = random.randint(1, 10000)
random.seed(cfg.MANUAL_SEED)
torch.manual_seed(cfg.MANUAL_SEED)
# args for different backbones
cfg.parse(args['resnet18'])
os.environ["CUDA_VISIBLE_DEVICES"] = cfg.GPU_IDS
device_ids = torch.cuda.device_count()
print('device_ids:', device_ids)
project_name = reduce(lambda x, y: str(x) + '/' + str(y),
os.path.realpath(__file__).split(os.sep)[:-1])
util.mkdir('logs')
# data
train_dataset = dataset.AlignedConcDataset(
cfg,
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
dataset.ToTensor(),
dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
]))
val_dataset = dataset.AlignedConcDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.ToTensor(),
dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
]))
batch_size_val = cfg.BATCH_SIZE
unlabeled_loader = None
if cfg.UNLABELED:
unlabeled_dataset = dataset.AlignedConcDataset(
cfg,
data_dir=cfg.DATA_DIR_UNLABELED,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
dataset.ToTensor(),
dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
]),
labeled=False)
unlabeled_loader = DataProvider(cfg, dataset=unlabeled_dataset)
train_loader = DataProvider(cfg,
dataset=train_dataset,
batch_size=batch_size_val)
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=batch_size_val,
shuffle=False)
# class weights
num_classes_train = list(
Counter([i[1] for i in train_loader.dataset.imgs]).values())
cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train)
writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard
model = TRecgNet(cfg, writer=writer)
model.set_data_loader(train_loader, val_loader, unlabeled_loader)
if cfg.RESUME:
checkpoint_path = os.path.join(cfg.CHECKPOINTS_DIR, cfg.RESUME_PATH)
checkpoint = torch.load(checkpoint_path)
load_epoch = checkpoint['epoch']
model.load_checkpoint(model.net,
checkpoint_path,
checkpoint,
data_para=True)
cfg.START_EPOCH = load_epoch
if cfg.INIT_EPOCH:
# just load pretrained parameters
print('load checkpoint from another source')
cfg.START_EPOCH = 1
print('>>> task path is {0}'.format(project_name))
# train
model.train_parameters(cfg)
print('save model ...')
model_filename = '{0}_{1}_{2}.pth'.format(cfg.MODEL, cfg.WHICH_DIRECTION,
cfg.NITER_TOTAL)
model.save_checkpoint(cfg.NITER_TOTAL, model_filename)
if writer is not None:
writer.close()
learning_rate = 0.001
np.random.seed(
1) # Initialize with the seed so that results are reproducable.
# Input -> hidden connections
W_ih = np.random.randn(inputs, hidden_units) * weight_norm_factor
b_ih = np.zeros((hidden_units, ))
# Hidden -> hidden connections
W_hh = np.random.randn(hidden_units, hidden_units) * weight_norm_factor
# Hidden -> output connections
W_hk = np.random.randn(hidden_units, outputs) * weight_norm_factor
b_hk = np.zeros((outputs, ))
# Get training set.
d = DataProvider(examples, sequence_length, inputs, outputs)
update_W_ih = np.zeros_like(W_ih)
update_b_ih = np.zeros_like(b_ih)
update_W_hh = np.zeros_like(W_hh)
update_W_hk = np.zeros_like(W_hk)
update_b_hk = np.zeros_like(b_hk)
loss = dict()
for epoch in range(epochs):
loss[epoch] = 0
print(str.format("Epoch {0} / {1}", epoch, epochs))
for d_id in range(d.get_example_count()):
x, z = d.get_example(d_id)
# Auxiliary variables.
a_h = {}
unlabeled_loader = None
if cfg.UNLABELED:
unlabeled_dataset = dataset.AlignedConcDataset(
cfg,
data_dir=cfg.DATA_DIR_UNLABELED,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
dataset.ToTensor(),
dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
]),
labeled=False)
unlabeled_loader = DataProvider(cfg, dataset=unlabeled_dataset)
train_loader = DataProvider(cfg, dataset=train_dataset)
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=batch_size_val,
shuffle=False)
# class weights
num_classes_train = list(
Counter([i[1] for i in train_loader.dataset.imgs]).values())
cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train)
writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard
model = create_model(cfg, writer)
model.set_data_loader(train_loader, val_loader, unlabeled_loader)
def __init__(self):
self.metadata = Metadata(True, 'lda')
self.dataProvider = DataProvider()
self.topicFile = 'tmp/topics.npy'
self.kMeansFile = 'tmp/kmeans.pkl.npy'
def main():
global cfg, global_all_step
global_all_step = 0
cfg = DefaultConfig()
args = {
'resnet18': RESNET18_SUNRGBD_CONFIG().args(),
}
# Setting random seed
# if cfg.MANUAL_SEED is None:
# cfg.MANUAL_SEED = random.randint(1, 10000)
# random.seed(cfg.MANUAL_SEED)
# torch.manual_seed(cfg.MANUAL_SEED)
# args for different backbones
cfg.parse(args['resnet18'])
run_id = random.randint(1, 100000)
summary_dir = '/home/lzy/summary/generateDepth/' + 'resnet152_train_rgb_place365_2e-3_' + str(
run_id)
if not os.path.exists(summary_dir):
os.mkdir(summary_dir)
writer = SummaryWriter(summary_dir)
cfg.LR = 0.002
os.environ["CUDA_VISIBLE_DEVICES"] = '2'
device_ids = torch.cuda.device_count()
print('device_ids:', device_ids)
# project_name = reduce(lambda x, y: str(x) + '/' + str(y), os.path.realpath(__file__).split(os.sep)[:-1])
# util.mkdir('logs')
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
# normalize=transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# data
train_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
# dataset.RandomRotate(),
# dataset.RandomFlip(),
# dataset.PILBrightness(0.4),
# dataset.PILContrast(0.4),
# dataset.PILColorBalance(0.4),
# dataset.PILSharpness(0.4),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
val_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
# train_loader = torch.utils.data.DataLoader(
# train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True,
# num_workers=4, pin_memory=True, sampler=None)
# val_loader = torch.utils.data.DataLoader(
# val_dataset,batch_size=16, shuffle=False,
# num_workers=4, pin_memory=True)
train_loader = DataProvider(cfg,
dataset=train_dataset,
batch_size=30,
shuffle=True)
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=10,
shuffle=False)
# class weights
net_classification_1 = models.__dict__['resnet152'](num_classes=365)
load_path = "./bestmodel/resnet152_places365.pth"
checkpoint = torch.load(load_path,
map_location=lambda storage, loc: storage)
weight = []
for k, v in checkpoint.items():
weight.append(v)
i = 0
from collections import OrderedDict
new_state_dict = OrderedDict()
for k in net_classification_1.state_dict():
# print(k)
new_state_dict[k] = weight[i]
i += 1
# state_dict = {str.replace(k, 'module.', ''): v for k, v in checkpoint['state_dict'].items()}
# state_dict = {str.replace(k, 'norm.', 'norm'): v for k, v in state_dict.items()}
# state_dict = {str.replace(k, 'conv.', 'conv'): v for k, v in state_dict.items()}
# state_dict = {str.replace(k, 'normweight', 'norm.weight'): v for k, v in state_dict.items()}
# state_dict = {str.replace(k, 'normbias', 'norm.bias'): v for k, v in state_dict.items()}
# state_dict = {str.replace(k, 'normrunning_var', 'norm.running_var'): v for k, v in state_dict.items()}
# state_dict = {str.replace(k, 'convweight', 'conv.weight'): v for k, v in state_dict.items()}
# state_dict = {str.replace(k, 'normrunning_mean', 'norm.running_mean'): v for k, v in state_dict.items()}
# normweight
# state_dict = {str.replace(k, 'conv.', 'conv'): v for k, v in state_dict.items()}
# best_mean_depth = checkpoint['best_mean_2']
# print("load sunrgbd dataset:",best_mean_depth)
net_classification_1.load_state_dict(new_state_dict)
# net_classification_1=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl')
# net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048, 1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67))
# net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.2), nn.Linear(2048, 1024), nn.LeakyReLU(inplace=True), nn.Dropout(p=0.2),nn.Linear(1024, 67))
# net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(1024, 67))
# net_classification_1.classifier= nn.Linear(2208, 67)
net_classification_1.fc = nn.Linear(2048, 67)
# init_weights(net_classification_1.classifier, 'normal')
init_weights(net_classification_1.fc, 'normal')
# net_classification_1.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl"))
# for param in net_classification_1.parameters():
# param.requires_grad = False
# num_ftrs = net_classification_1.fc.in_features
print(net_classification_1)
net_classification_1.cuda()
# net_classification_2.cuda()
cudnn.benchmark = True
net_classification_1 = torch.nn.DataParallel(net_classification_1).cuda()
# net_classification_2 = torch.nn.DataParallel(net_classification_2).cuda()
criterion = nn.CrossEntropyLoss().cuda()
best_mean_1 = 0
# best_mean_2=0
# optimizer_1 = torch.optim.Adam(net_classification_1.parameters(), lr=cfg.LR, betas=(0.5, 0.999))
optimizer_1 = torch.optim.SGD(net_classification_1.parameters(),
lr=cfg.LR,
momentum=cfg.MOMENTUM,
weight_decay=cfg.WEIGHT_DECAY)
schedulers = get_scheduler(optimizer_1, cfg, cfg.LR_POLICY)
# optimizer_1 = torch.optim.SGD(net_classification_1.parameters(),lr=cfg.LR,momentum=cfg.MOMENTUM,weight_decay=cfg.WEIGHT_DECAY)
# optimizer_2 = torch.optim.SGD(net_classification_2.parameters(),lr=cfg.LR,momentum=cfg.MOMENTUM,weight_decay=cfg.WEIGHT_DECAY)
for epoch in range(0, 1000):
if global_all_step > cfg.NITER_TOTAL:
break
# meanacc_1,meanacc_2=validate(val_loader, net_classification_1,net_classification_2,generate_model,criterion,epoch)
printlr(optimizer_1, writer, epoch)
train(train_loader, schedulers, net_classification_1, criterion,
optimizer_1, epoch, writer)
meanacc_1 = validate(val_loader, net_classification_1, criterion,
epoch, writer)
# writer.add_image(depth_image[0])
# save best
if meanacc_1 > best_mean_1:
best_mean_1 = meanacc_1
print('best_mean_color:', str(best_mean_1))
save_checkpoint(
{
'epoch': epoch,
'arch': cfg.ARCH,
'state_dict': net_classification_1.state_dict(),
'best_mean_1': best_mean_1,
'optimizer': optimizer_1.state_dict(),
},
CorD=True)
print('best_mean_color:', str(best_mean_1))
writer.add_scalar('mean_acc_color', meanacc_1, global_step=epoch)
# writer.add_scalar('mean_acc_depth', meanacc_2, global_step=epoch)
writer.add_scalar('best_meanacc_color', best_mean_1, global_step=epoch)
# writer.add_scalar('best_meanacc_depth', best_mean_2, global_step=epoch)
writer.close()
def train(args):
height, width, channel = 28, 28, 1
batch_size = args.batch_size
z_size = args.nd # 噪声维数
real_img = tf.placeholder(tf.float32, [batch_size, height, width, channel],
name='img')
z = tf.placeholder(tf.float32, [batch_size, z_size], name='z')
label = tf.placeholder(tf.float32, [batch_size, 10], name='label') # 0~9
gan = model.GAN(height, width, channel)
gan.set_batch_size(batch_size)
fake_img = gan.generator(z, label)
real_result = gan.discriminator(real_img, label, reuse=False)
fake_result = gan.discriminator(fake_img, label, reuse=True)
real = tf.reduce_sum(label * real_result, 1)
fake = tf.reduce_sum(label * fake_result, 1)
d_loss = -tf.reduce_mean(tf.log(real) + tf.log(1. - fake))
g_loss = -tf.reduce_mean(tf.log(fake))
t_vars = tf.trainable_variables()
d_vars = [var for var in t_vars if 'dis' in var.name]
g_vars = [var for var in t_vars if 'gen' in var.name]
d_optimizer = tf.train.AdamOptimizer(learning_rate=0.0002, beta1=0.5) \
.minimize(d_loss, var_list=d_vars)
g_optimizer = tf.train.AdamOptimizer(learning_rate=0.0002, beta1=0.5) \
.minimize(g_loss, var_list=g_vars)
data = DataProvider()
train_num = data.get_train_num()
batch_num = int(train_num / args.batch_size)
saver = tf.train.Saver(max_to_keep=1)
model_dir = args.model_dir
if (not os.path.exists(model_dir)):
os.mkdir(model_dir)
accuracy_real = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(label, 1), tf.argmax(real_result, 1)),
'float'))
accuracy_fake = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(label, 1), tf.argmax(fake_result, 1)),
'float'))
with tf.Session() as sess:
counter = 0
sess.run(tf.global_variables_initializer())
for epoch in range(args.epoch):
for batch in range(batch_num):
counter += 1
train_data, label_data = data.next_batch(batch_size)
batch_z = np.random.normal(0, 1, [batch_size, z_size]).astype(
np.float_)
sess.run(d_optimizer,
feed_dict={
real_img: train_data,
z: batch_z,
label: label_data
})
sess.run(g_optimizer,
feed_dict={
z: batch_z,
label: label_data
})
if (counter % 20 == 0):
dloss, gloss, ac_real, ac_fake = sess.run(
[d_loss, g_loss, accuracy_real, accuracy_fake],
feed_dict={
real_img: train_data,
z: batch_z,
label: label_data
})
print('iter:', counter, 'd_loss:', dloss, 'g_loss:', gloss,
'ac_real:', ac_real, 'ac_fake:', ac_fake)
if (counter % 200 == 0):
saver.save(sess, os.path.join(model_dir, 'model'))
os.path.realpath(__file__).split(os.sep)[:-1])
util.mkdir('logs')
val_dataset = dataset.AlignedConcDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.ToTensor(),
dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
]))
batch_size_val = cfg.BATCH_SIZE
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=batch_size_val,
shuffle=False)
writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard
model = TRecgNet_Upsample_Resiual(cfg, writer)
model.set_data_loader(None, val_loader, None)
model.net = nn.DataParallel(model.net).to(model.device)
model.set_log_data(cfg)
def evaluate():
checkpoint_path = os.path.join(cfg.CHECKPOINTS_DIR, cfg.RESUME_PATH)
checkpoint = torch.load(checkpoint_path)
load_epoch = checkpoint['epoch']
model.load_checkpoint(model.net,
checkpoint_path,
# start a new Tensorflow session
with tf.Session() as session:
# get and set random seeds
random_seed = run.get_config_value("model", "random_seed")
op_random_seed = run.get_config_value("model", "op_random_seed")
tf.set_random_seed(random_seed)
# init model
model = get_model(run.get_config_value("model", "name"),
session,
op_seed=op_random_seed,
num_classes=dataset.num_classes + 1)
with tf.device(arguments.input_device):
# setup data provider
data_provider = DataProvider(arguments.dataset)
data_provider.init_dataset(
arguments.dataset_split,
batch_size=arguments.batch_size,
num_parallel_calls=arguments.num_parallel_calls,
prefetch_buffer_size=arguments.prefetch_buffer_size,
preprocessor=[
DefaultPreprocessor(),
ImagePreprocessor(model.hyperparams["image_shape"],
data_augmentation=False),
BBoxPreprocessor(model.get_default_anchor_boxes(),
model.hyperparams["prior_scaling"],
model.hyperparams["matching_threshold"])
],
features=[
"image", "image/object/bbox", "image/object/bbox/label",
def main():
global cfg
cfg = DefaultConfig()
args = {
'resnet18': RESNET18_SUNRGBD_CONFIG().args(),
}
# args for different backbones
cfg.parse(args['resnet18'])
cfg.LR = 1e-4
cfg.EPOCHS = 200
# print('cfg.EPOCHS:',cfg.EPOCHS)
os.environ["CUDA_VISIBLE_DEVICES"] = '0,1'
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
# dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# data
train_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
val_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
# train_loader = torch.utils.data.DataLoader(
# train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True,
# num_workers=4, pin_memory=True, sampler=None)
# val_loader = torch.utils.data.DataLoader(
# val_dataset,batch_size=cfg.BATCH_SIZE, shuffle=False,
# num_workers=4, pin_memory=True)
train_loader = DataProvider(cfg,
dataset=train_dataset,
batch_size=20,
shuffle=True)
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=5,
shuffle=False)
run_id = random.randint(1, 100000)
summary_dir = '/home/lzy/summary/generateDepth/' + 'finetuning_nofix_' + str(
run_id)
if not os.path.exists(summary_dir):
os.mkdir(summary_dir)
writer = SummaryWriter(summary_dir)
if cfg.GENERATE_Depth_DATA:
print('GENERATE_Depth_DATA model set')
cfg_generate = copy.deepcopy(cfg)
cfg_generate.CHECKPOINTS_DIR = '/home/lzy/generateDepth/checkpoints/best_AtoB/trecg_AtoB_best.pth'
cfg_generate.GENERATE_Depth_DATA = False
cfg_generate.NO_UPSAMPLE = False
checkpoint = torch.load(cfg_generate.CHECKPOINTS_DIR)
model = define_TrecgNet(cfg_generate, upsample=True, generate=True)
load_checkpoint_depth(model,
cfg_generate.CHECKPOINTS_DIR,
checkpoint,
data_para=True)
generate_model = torch.nn.DataParallel(model).cuda()
generate_model.eval()
model = ReD_Model(cfg)
policies = model.get_optim_policies()
model = torch.nn.DataParallel(model).cuda()
criterion = nn.CrossEntropyLoss().cuda()
best_mean = 0
# optimizer= torch.optim.Adam(policies, cfg.LR,
# weight_decay=cfg.WEIGHT_DECAY)
optimizer = torch.optim.SGD(policies,
cfg.LR,
momentum=cfg.MOMENTUM,
weight_decay=cfg.WEIGHT_DECAY)
for epoch in range(cfg.START_EPOCH, cfg.EPOCHS + 1):
adjust_learning_rate(optimizer, epoch)
# mean_acc=validate(val_loader,model,criterion,generate_model,epoch,writer)
train(train_loader, model, criterion, generate_model, optimizer, epoch,
writer)
mean_acc = validate(val_loader, model, criterion, generate_model,
epoch, writer)
if mean_acc > best_mean:
best_mean = mean_acc
print('best mean accuracy:', best_mean)
else:
print('best mean accuracy:', best_mean)
writer.add_scalar('mean_acc_color', mean_acc, global_step=epoch)
writer.add_scalar('best_meanacc_color', best_mean, global_step=epoch)
writer.close()
# Model
net = Net()
net.push(Conv2d(5, 5, 1, 6)) # 1x28x28 -> 6x24x24
net.push(Relu())
net.push(Maxpooling(2, 2)) # 6x24x24 -> 6x12x12
net.push(Conv2d(5, 5, 6, 16)) # 6x12x12 -> 16x8x8
net.push(Relu())
net.push(Maxpooling(2, 2)) # 16x8x8 -> 16x4x4
net.push(Reshape((256)))
net.push(Linear(256, 84))
net.push(Relu())
net.push(Softmax(84, 10))
# Data
data = DataProvider()
n = 10000
data.train_input(x[:n], y[:n])
data.test_input(xt, yt)
data.batch_size(16)
lr = 0.0009
gamma = 0.9
for epoch in xrange(50):
print 'Epoch: ', epoch
# Training (Mini-batch)
now = time.time()
for _ in xrange(data.batch_run()):
net.input(data.next_batch())
net.forward()
logger.info('read text')
train_text, test_text = get_text()
args = parse_args()
seq_length = args.seq_length
batch_size = args.batch_size
rnn_size = args.rnn_size
context_size = args.context_size
num_epochs = args.num_epoch
learning_rate = args.lr
alpha = args.alpha
logger.info('build vocabulary')
data_provider = DataProvider(train_text, seq_length, batch_size, logger)
X_train, y_train = data_provider.get_data()
logger.info('X.shape={}, y.shape={}'.format(X_train.shape, y_train.shape))
vocab_size = data_provider.vocab_size
input_data = tf.placeholder(tf.float32,
[batch_size, seq_length, vocab_size])
targets = tf.placeholder(tf.float32, [batch_size, vocab_size])
test_data_provider = DataProvider(test_text, seq_length, batch_size,
logger, data_provider.vocab)
if args.cell == 'lstm':
cell = LSTMCell(num_units=rnn_size)
def main(args, update_params_dict):
train_fn = train_ae.train_ae
device = 'cuda' if torch.cuda.is_available() else 'cpu'
with open(os.path.join('model_save', 'train_params.json'), 'r') as f:
training_params = json.load(f)
training_params['unlabeled'].update(update_params_dict)
param_str = dict_to_str(update_params_dict)
training_params.update({
'device': device,
'es_flag': False,
'retrain_flag': args.retrain_flag
})
if args.omics != 'both':
training_params.update({
'device':
device,
'model_save_folder':
os.path.join('model_save', 'ae', args.omics, param_str),
'es_flag':
False,
'retrain_flag':
args.retrain_flag
})
safe_make_dir(training_params['model_save_folder'])
task_save_folder = os.path.join('model_save', 'ae', args.omics, param_str)
safe_make_dir(task_save_folder)
random.seed(2020)
data_provider = DataProvider(
batch_size=training_params['unlabeled']['batch_size'],
target=args.measurement)
# if args.omics == 'both':
# training_params.update(
# {
# 'input_dim': sum([data_provider.shape_dict[k] for k in data_provider.shape_dict if k != 'target']),
# 'output_dim': data_provider.shape_dict['target']
# }
# )
# else:
training_params.update({'output_dim': data_provider.shape_dict['target']})
if args.omics != 'both':
training_params.update({
'input_dim':
data_provider.shape_dict[args.omics],
})
# start unlabeled training
if args.omics == 'gex':
encoder, historys = train_fn(
dataloader=data_provider.get_unlabeled_gex_dataloader(),
**wrap_training_params(training_params, type='unlabeled'))
with open(
os.path.join(training_params['model_save_folder'],
f'unlabel_train_history.pickle'), 'wb') as f:
for history in historys:
pickle.dump(dict(history), f)
elif args.omics == 'mut':
encoder, historys = train_fn(
dataloader=data_provider.get_unlabeld_mut_dataloader(match=False),
**wrap_training_params(training_params, type='unlabeled'))
with open(
os.path.join(training_params['model_save_folder'],
f'unlabel_train_history.pickle'), 'wb') as f:
for history in historys:
pickle.dump(dict(history), f)
else:
training_params.update({
'model_save_folder':
os.path.join('model_save', 'ae', 'gex', param_str),
'input_dim':
data_provider.shape_dict['gex'],
})
safe_make_dir(training_params['model_save_folder'])
gex_encoder, gex_historys = train_fn(
dataloader=data_provider.get_unlabeled_gex_dataloader(),
**wrap_training_params(training_params, type='unlabeled'))
training_params.update({
'model_save_folder':
os.path.join('model_save', 'ae', 'mut', param_str),
'input_dim':
data_provider.shape_dict['mut'],
})
safe_make_dir(training_params['model_save_folder'])
mut_encoder, mut_historys = train_fn(
dataloader=data_provider.get_unlabeld_mut_dataloader(match=False),
**wrap_training_params(training_params, type='unlabeled'))
ft_evaluation_metrics = defaultdict(list)
fold_count = 0
if args.omics == 'gex':
labeled_dataloader_generator = data_provider.get_labeled_data_generator(
omics='gex')
for train_labeled_dataloader, val_labeled_dataloader in labeled_dataloader_generator:
ft_encoder = deepcopy(encoder)
target_regressor, ft_historys = fine_tuning.fine_tune_encoder(
encoder=ft_encoder,
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=val_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
task_save_folder=task_save_folder,
**wrap_training_params(training_params, type='labeled'))
for metric in [
'dpearsonr', 'dspearmanr', 'drmse', 'cpearsonr',
'cspearmanr', 'crmse'
]:
ft_evaluation_metrics[metric].append(
ft_historys[-2][metric][ft_historys[-2]['best_index']])
fold_count += 1
elif args.omics == 'mut':
labeled_dataloader_generator = data_provider.get_labeled_data_generator(
omics='mut')
test_ft_evaluation_metrics = defaultdict(list)
for train_labeled_dataloader, val_labeled_dataloader, test_labeled_dataloader in labeled_dataloader_generator:
ft_encoder = deepcopy(encoder)
target_regressor, ft_historys = fine_tuning.fine_tune_encoder(
encoder=ft_encoder,
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=test_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
task_save_folder=task_save_folder,
**wrap_training_params(training_params, type='labeled'))
for metric in [
'dpearsonr', 'dspearmanr', 'drmse', 'cpearsonr',
'cspearmanr', 'crmse'
]:
ft_evaluation_metrics[metric].append(
ft_historys[-2][metric][ft_historys[-2]['best_index']])
test_ft_evaluation_metrics[metric].append(
ft_historys[-1][metric][ft_historys[-2]['best_index']])
fold_count += 1
with open(
os.path.join(task_save_folder,
f'{param_str}_test_ft_evaluation_results.json'),
'w') as f:
json.dump(test_ft_evaluation_metrics, f)
else:
labeled_dataloader_generator = data_provider.get_labeled_data_generator(
omics='both')
for train_labeled_dataloader, val_labeled_dataloader in labeled_dataloader_generator:
ft_gex_encoder = deepcopy(gex_encoder)
ft_mut_encoder = deepcopy(mut_encoder)
target_regressor, ft_historys = fine_tuning_mul.fine_tune_encoder(
encoders=[ft_gex_encoder, ft_mut_encoder],
train_dataloader=train_labeled_dataloader,
val_dataloader=val_labeled_dataloader,
test_dataloader=val_labeled_dataloader,
seed=fold_count,
metric_name=args.metric,
task_save_folder=task_save_folder,
**wrap_training_params(training_params, type='labeled'))
for metric in [
'dpearsonr', 'dspearmanr', 'drmse', 'cpearsonr',
'cspearmanr', 'crmse'
]:
ft_evaluation_metrics[metric].append(
ft_historys[-2][metric][ft_historys[-2]['best_index']])
fold_count += 1
with open(
os.path.join(task_save_folder,
f'{param_str}_ft_evaluation_results.json'), 'w') as f:
json.dump(ft_evaluation_metrics, f)
def main():
global cfg, global_all_step
global_all_step = 0
cfg = DefaultConfig()
args = {
'resnet18': RESNET18_SUNRGBD_CONFIG().args(),
}
# Setting random seed
# if cfg.MANUAL_SEED is None:
# cfg.MANUAL_SEED = random.randint(1, 10000)
# random.seed(cfg.MANUAL_SEED)
# torch.manual_seed(cfg.MANUAL_SEED)
# args for different backbones
cfg.parse(args['resnet18'])
run_id = random.randint(1, 100000)
summary_dir = '/home/lzy/summary/generateDepth/' + 'train_depth_1e-3_0909_' + str(
run_id)
if not os.path.exists(summary_dir):
os.mkdir(summary_dir)
writer = SummaryWriter(summary_dir)
cfg.LR = 0.001
os.environ["CUDA_VISIBLE_DEVICES"] = '0,1,2'
device_ids = torch.cuda.device_count()
print('device_ids:', device_ids)
# project_name = reduce(lambda x, y: str(x) + '/' + str(y), os.path.realpath(__file__).split(os.sep)[:-1])
# util.mkdir('logs')
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
# normalize=transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# data
train_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_TRAIN,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.RandomHorizontalFlip(),
# dataset.RandomRotate(),
# dataset.RandomFlip(),
# dataset.PILBrightness(0.4),
# dataset.PILContrast(0.4),
# dataset.PILColorBalance(0.4),
# dataset.PILSharpness(0.4),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
val_dataset = dataset.SingleDataset(
cfg,
data_dir=cfg.DATA_DIR_VAL,
transform=transforms.Compose([
dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)),
dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)),
dataset.ToTensor(),
dataset.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
# train_loader = torch.utils.data.DataLoader(
# train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True,
# num_workers=4, pin_memory=True, sampler=None)
# val_loader = torch.utils.data.DataLoader(
# val_dataset,batch_size=16, shuffle=False,
# num_workers=4, pin_memory=True)
train_loader = DataProvider(cfg,
dataset=train_dataset,
batch_size=150,
shuffle=True)
val_loader = DataProvider(cfg,
dataset=val_dataset,
batch_size=120,
shuffle=False)
# class weights
# num_classes_train = list(Counter([i[1] for i in train_loader.dataset.imgs]).values())
# cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train)
# writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard
# net_classification_1=resnet50(pretrained=True)
# net_classification_2=resnet50(pretrained=True)
net_classification_2 = models.__dict__['resnet50'](num_classes=365)
# net_classification_2=torchvision.models.resnext101_32x8d(pretrained=True, progress=True)
# net_classification_2 = models.__dict__['resnet18'](num_classes=365)
# net_classification_2=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl')
net_classification_2.fc = nn.Linear(2048, 19)
# net_classification_2=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl')
# for param in net_classification_1.parameters():
# param.requires_grad = False
# for param in net_classification_2.parameters():
# param.requires_grad = True
# net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048, 1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67))
# net_classification_2.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048,1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67))
# net_classification_1.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl"))、
# net_classification_2.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl"))
# net_classification_2
load_path = "resnet50_Depth_sunrgbd_best_0909_5e-4_.pth.tar"
checkpoint = torch.load(load_path,
map_location=lambda storage, loc: storage)
state_dict = {
str.replace(k, 'module.', ''): v
for k, v in checkpoint['state_dict'].items()
}
best_mean_depth = checkpoint['best_mean_2']
print("load sunrgbd dataset:", best_mean_depth)
net_classification_2.load_state_dict(state_dict)
# print(net_classification_1)
# num_ftrs = net_classification_1.fc.in_features
# net_classification_1.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES)
# num_ftrs = net_classification_2.fc.in_features
# net_classification_2.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES)
# net_classification_2.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048,1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67))
net_classification_2.fc = nn.Linear(2048, 67)
init_weights(net_classification_2.fc, 'normal')
print(net_classification_2)
# net_classification_1.cuda()
net_classification_2.cuda()
cudnn.benchmark = True
if cfg.GENERATE_Depth_DATA:
print('GENERATE_Depth_DATA model set')
cfg_generate = copy.deepcopy(cfg)
cfg_generate.CHECKPOINTS_DIR = '/home/lzy/generateDepth/bestmodel/before_best.pth'
cfg_generate.GENERATE_Depth_DATA = False
cfg_generate.NO_UPSAMPLE = False
checkpoint = torch.load(cfg_generate.CHECKPOINTS_DIR)
model = define_TrecgNet(cfg_generate, upsample=True, generate=True)
load_checkpoint_depth(model,
cfg_generate.CHECKPOINTS_DIR,
checkpoint,
data_para=True)
generate_model = torch.nn.DataParallel(model).cuda()
generate_model.eval()
# net_classification_1 = torch.nn.DataParallel(net_classification_1).cuda()
net_classification_2 = torch.nn.DataParallel(net_classification_2).cuda()
criterion = nn.CrossEntropyLoss().cuda()
# best_mean_1=0
best_mean_2 = 0
# optimizer_2 = torch.optim.Adam(net_classification_2.parameters(), lr=cfg.LR, betas=(0.5, 0.999))
optimizer_2 = torch.optim.SGD(net_classification_2.parameters(),
lr=cfg.LR,
momentum=cfg.MOMENTUM,
weight_decay=cfg.WEIGHT_DECAY)
schedulers = get_scheduler(optimizer_2, cfg, cfg.LR_POLICY)
for epoch in range(0, 1000):
if global_all_step > cfg.NITER_TOTAL:
break
# meanacc_1,meanacc_2=validate(val_loader, net_classification_1,net_classification_2,generate_model,criterion,epoch)
# for param_group in optimizer_2.param_groups:
# lr_t = param_group['lr']
# print('/////////learning rate = %.7f' % lr_t)
# writer.add_scalar('LR',lr_t,global_step=epoch)
printlr(optimizer_2, writer, epoch)
train(train_loader, schedulers, net_classification_2, generate_model,
criterion, optimizer_2, epoch, writer)
meanacc_2 = validate(val_loader, net_classification_2, generate_model,
criterion, epoch, writer)
# meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer)
# train(train_loader,net_classification_2,generate_model,criterion,optimizer_2,epoch,writer)
# meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer)
# writer.add_image(depth_image[0])
# save best
# if meanacc_1>best_mean_1:
# best_mean_1=meanacc_1
# print('best_mean_color:',str(best_mean_1))
# save_checkpoint({
# 'epoch': epoch,
# 'arch': cfg.ARCH,
# 'state_dict': net_classification_1.state_dict(),
# 'best_mean_1': best_mean_1,
# 'optimizer' : optimizer_1.state_dict(),
# },CorD=True)
if meanacc_2 > best_mean_2:
best_mean_2 = meanacc_2
print('best_mean_depth:', str(best_mean_2))
save_checkpoint(
{
'epoch': epoch,
'arch': cfg.ARCH,
'state_dict': net_classification_2.state_dict(),
'best_mean_2': best_mean_2,
'optimizer': optimizer_2.state_dict(),
},
CorD=False)
# print('best_mean_color:',str(best_mean_1))
# writer.add_scalar('mean_acc_color', meanacc_1, global_step=epoch)
writer.add_scalar('mean_acc_depth', meanacc_2, global_step=epoch)
# writer.add_scalar('best_meanacc_color', best_mean_1, global_step=epoch)
writer.add_scalar('best_meanacc_depth', best_mean_2, global_step=epoch)
writer.close()
def main(parser):
# retrieve options
(options, args) = parser.parse_args()
net = options.net
display = options.display
base_lr = options.learning_rate
lr_policy = options.lr_policy
gamma = options.gamma
stepsize = options.stepsize
max_iter = options.max_iter
momentum = options.momentum
iter_size = options.iter_size
weight_decay = options.weight_decay
iter_snapshot = options.iter_resume
snapshot = options.snapshot
snapshot_prefix = options.snapshot_prefix
test_interval = options.test_interval
command_for_test = options.command_for_test
weights = options.weights
do_test = options.do_test
dp_params = ast.literal_eval(options.dp_params)
preproc = ast.literal_eval(options.preproc)
# Data provider
dp = DataProvider(dp_params, preproc)
isize = dp.batch_size
iter_size = dp.iter_size
bsize = isize * iter_size
# Load the net
if weights is not None:
print "Loading weights from " + weights
N = caffe.Net(net, weights, caffe.TRAIN)
else:
if iter_snapshot==0:
N = caffe.Net(net, caffe.TRAIN)
else:
print "Resuming training from " + snapshot_prefix + '_iter_' + str(iter_snapshot) + '.caffemodel'
N = caffe.Net(net, snapshot_prefix + '_iter_' + str(iter_snapshot) + '.caffemodel', caffe.TRAIN)
# Save the net if training gets stopped
import signal
def sigint_handler(signal, frame):
print 'Training paused...'
print 'Snapshotting for iteration ' + str(iter)
N.save(snapshot_prefix + '_iter_' + str(iter) + '.caffemodel')
sys.exit(0)
signal.signal(signal.SIGINT, sigint_handler)
# save weights before training
if iter_snapshot == 0:
print 'Snapshotting for initial weights'
N.save(snapshot_prefix + '_iter_initial.caffemodel')
# Start training
loss = { key: 0 for key in N.outputs }
prevs = {}
for iter in range(iter_snapshot, max_iter):
# clear param diffs
for layer_name, lay in zip(N._layer_names, N.layers):
for blobind, blob in enumerate(lay.blobs):
blob.diff[:] = 0
# clear loss
for k in loss.keys():
loss[k] = 0
# update weights at every <iter_size> iterations
for i in range(iter_size):
# load data batch
t0 = time.time()
ind = iter * bsize + i * isize
_data, _labels = dp.get_batch(ind)
load_time = time.time() - t0
# set data as input
N.blobs['data'].data[...] = _data
for label_key in _labels.keys():
N.blobs[label_key].data[...] = _labels[label_key].reshape(N.blobs[label_key].data.shape)
# Forward
# t0 = time.time()
out = N.forward()
# forward_time = time.time()
# Backward
N.backward()
# backward_time = time.time() - forward_time
# forward_time -= t0
for k in out.keys():
loss[k] += np.copy(out[k])
# learning rate schedule
if lr_policy == "step":
learning_rate = base_lr * (gamma**(iter/stepsize))
# print output loss
print "Iteration", iter, "(lr: {0:.4f})".format( learning_rate )
for k in np.sort(out.keys()):
loss[k] /= iter_size
print "Iteration", iter, ", ", k, "=", loss[k]
sys.stdout.flush()
# update filter parameters
# t0 = time.time()
for layer_name, lay in zip(N._layer_names, N.layers):
for blobind, blob in enumerate(lay.blobs):
diff = blob.diff[:]
key = (layer_name, blobind)
if key in prevs:
previous_change = prevs[key]
else:
previous_change = 0.
lr = learning_rate
wd = weight_decay
# if ("SpatialCorr" in lay.type):
# wd = 1000. * wd
if (blobind == 1) and ("SpatialCorr" not in lay.type):
lr = 2. *lr
wd = 0.
if lay.type == "BatchNorm":
lr = 0.
wd = 0.
if ("SpatialCorr" in lay.type):
if "corronly" in net:
wd = 0.
else:
wd = 1. # for training pos
change = momentum * previous_change - lr * diff / iter_size - lr * wd * blob.data[:]
blob.data[:] += change
prevs[key] = change
# # for debugging
# if layer_name=='loss_scl':
# print "pos:", np.reshape(blob.data[:],-1)
# print "change:", np.reshape(change,-1)
# print "prev_change:", np.reshape(previous_change,-1)
# print "wd:", wd
# print "diff:", np.reshape(diff,-1)
# update_time = time.time() - t0
# print "loading: {0:.2f}, forward: {1:.2f}, backward: {2:.2f}, update: {3:.2f}".format(load_time, forward_time, backward_time, update_time)
# save weights
if iter % snapshot == 0:
print 'Snapshotting for iteration ' + str(iter)
N.save(snapshot_prefix + '_iter_' + str(iter) + '.caffemodel')
# test on validation set
if do_test and (iter % test_interval == 0):
print 'Test for iteration ' + str(iter)
weights_test = snapshot_prefix + '_iter_' + str(iter) + '.caffemodel'
if not os.path.exists(weights_test):
N.save(snapshot_prefix + '_iter_' + str(iter) + '.caffemodel')
command_for_test_iter = command_for_test + ' test.sh ' + net + ' ' + weights_test + ' "' + options.dp_params + '" "' + options.preproc + '"'
print command_for_test_iter
subprocess.call(command_for_test_iter, shell=True)
