def validate(epoch, model, test_loader):
test_acc = 0
test_loss = 0
test_num = 0
for it, (img_tensor, label, img_mask_tensor) in enumerate(test_loader):
image_ = Variable(img_tensor.cuda(), volatile=True)
label_ = Variable(img_mask_tensor.cuda(), volatile=True)
logits = model(image_)
probs = F.sigmoid(logits)
masks = (probs > 0.5).float()
loss = criterion(logits, label_)
acc = dice_loss(masks, label_)
batch_size = len(img_mask_tensor)
test_num += batch_size
test_loss += batch_size * loss.data[0]
test_acc += batch_size * acc.data[0]
valid_loss = test_loss / test_num
valid_acc = test_acc / test_num
if epoch % EPOCH_VALID == 0 or epoch == 0 or epoch == NUM_EPOCHES - 1:
logger.info("Validate=>\n"
"Epoch: {epoch}\t"
"Valid_loss: {valid_loss:.3f}\t"
"Valid_acc: {valid_acc:.3f}%".format(
epoch=epoch,
valid_loss=round(valid_loss, 4),
valid_acc=round(valid_acc, 4) * 100))
return valid_loss, valid_acc
print("Data from: {}".format(load_dir))
load_path = load_dir + '/{}/train/0'.format(group_size)
save_path = main_path + '/{}'.format(args.name)
if not os.path.exists(save_path):
os.makedirs(save_path)
######################
# initialization
if gpu_num > 1:
model = nn.DataParallel(
net.load_net(model_name, 1, out_channels, start_filts, depth, img_side,
num_cn, split, kernel_size,
num_global_control)).to(args.device)
criterion = nn.DataParallel(net.criterion(degree=degree)).to(args.device)
regularizer = nn.DataParallel(net.regularizer()).to(args.device)
print("Assigned {} GPUs".format(gpu_num))
else:
model = net.load_net(model_name, 1, out_channels, start_filts, depth,
img_side, num_cn, split, kernel_size,
num_global_control).to(args.device)
criterion = net.criterion(degree=degree).to(args.device)
regularizer = net.regularizer().to(args.device)
print("Assigned on {}".format(args.device))
print('network contains {} parameters'.format(
net.count_parameters(model))) # parameter number
time.sleep(2)
displayer = kv.displayer()
"kura_update_rate = {}\n".format(kura_update_rate),
"episodes = {}\n".format(episodes),
"learning_rate = {}\n".format(learning_rate),
"sparsity_weight = {}\n".format(sparsity_weight),
"shuffle = {}\n".format(shuffle), "network=net.simple_conv\n",
"num_cn={}\n".format(num_cn), "critic_dist={}\n".format(critic_dist),
"anneal={}\n".format(anneal), "loss:exinp_integrate_torch"
]
file.writelines(L)
file.close()
######################
# initialization
if tc.cuda.device_count() > 1:
model = nn.DataParallel(net.simple_conv()).to(args.device)
criterion = nn.DataParallel(net.criterion()).to(args.device)
else:
model = net.simple_conv().to(args.device)
criterion = net.criterion().to(args.device)
print('network contains {} parameters'.format(
net.count_parameters(model))) # parameter number
time.sleep(2)
initial_phase = np.random.rand(1, img_side**2) * 2 * np.pi
rand_phase = tc.tensor(initial_phase).to('cpu')
batch_initial_phase = rand_phase.repeat(train_batch_size, 1).to(args.device)
cv_initial_phase = rand_phase.repeat(cv_batch_size, 1).detach().to(args.device)
loss_history = []
loss_cv_history = []
coupling_history = []
def train(epoch, net, optimizer, train_data_loader):
"""
:param epoch:
:param net:
:param optimizer:
:param train_data_loader:
:return:
"""
smooth_loss = 0.0
smooth_acc = 0.0
sum_smooth_loss = 0
sum_smooth_acc = 0
sum_iter = 0
it_smooth = 100
for it, (img_tensor, label,
img_mask_tensor) in enumerate(train_data_loader):
image_ = Variable(img_tensor.cuda())
label_ = Variable(img_mask_tensor.cuda())
# compute output
logits = net(image_)
probs = F.sigmoid(logits)
masks = (probs > 0.5).float()
loss = criterion(logits, label_)
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc = dice_loss(masks, label_)
sum_smooth_loss += loss.data[0]
sum_smooth_acc += acc.data[0]
sum_iter += 1
if it % it_smooth == 0:
smooth_loss = sum_smooth_loss / sum_iter
smooth_acc = sum_smooth_acc / sum_iter
sum_smooth_loss = 0.0
sum_smooth_acc = 0.0
sum_iter = 0
if it % it_smooth == 0 or it == len(train_data_loader) - 1:
train_acc = acc.data[0]
train_loss = loss.data[0]
logger.info("Train=>\n"
"Epoch: {epoch}\t"
"Batch_num: {iter_num}\t"
"lr: {lr:.3f}\t"
"loss: {smooth_loss:.3f}\t"
"acc: {smooth_acc:.3f}%\t"
"train_loss: {train_loss}\t"
"train_acc: {train_acc}%".format(
epoch=epoch,
iter_num=it,
lr=0,
smooth_loss=round(smooth_loss, 4),
smooth_acc=round(smooth_acc, 4) * 100,
train_loss=round(train_loss, 4),
train_acc=round(train_acc, 4) * 100))
degree = int(experiment['degree'])
kura_update_rate = float(experiment['kura_update_rate'])
anneal = float(experiment['anneal'])
rp_field = experiment['rp_field']
main_path = experiment['main_path']
save_path = os.path.join(main_path, args.name)
checkpoint = tc.load(os.path.join(save_path, args.model),
map_location=tc.device('cuda'))
test_save_path = os.path.join(save_path, 'test-{}'.format(args.model))
if not os.path.exists(test_save_path):
os.makedirs(test_save_path)
model = net.load_net(model_name, 1, out_channels, start_filts, depth, img_side,
num_cn, split, kernel_size, num_global_control).to('cuda')
criterion = net.criterion(degree=degree)
regularizer = net.regularizer()
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()
rand_phase = checkpoint['initial_phase'].squeeze(
0) # Change this line to random initialization when test random walk
connectivity = checkpoint['connectivity'].squeeze(0)
global_connectivity = checkpoint['gconnectivity']
batch_connectivity = connectivity.repeat(batch_size, 1, 1).to('cuda')
batch_initial_phase = rand_phase.repeat(batch_size, 1).to('cuda')
displayer = kv.displayer()