def test_2d_registration_train(self):
import icon_registration.data as data
import icon_registration.networks as networks
import icon_registration.network_wrappers as network_wrappers
import icon_registration.train as train
import icon_registration.inverseConsistentNet as inverseConsistentNet
import numpy as np
import torch
import random
import os
random.seed(1)
torch.manual_seed(1)
torch.cuda.manual_seed(1)
np.random.seed(1)
batch_size = 128
d1, d2 = data.get_dataset_triangles("train",
data_size=50,
hollow=False,
batch_size=batch_size)
d1_t, d2_t = data.get_dataset_triangles("test",
data_size=50,
hollow=False,
batch_size=batch_size)
lmbda = 2048
print("=" * 50)
net = inverseConsistentNet.InverseConsistentNet(
network_wrappers.FunctionFromVectorField(
networks.tallUNet2(dimension=2)),
# Our image similarity metric. The last channel of x and y is whether the value is interpolated or extrapolated,
# which is used by some metrics but not this one
lambda x, y: torch.mean((x[:, :1] - y[:, :1])**2),
lmbda,
)
input_shape = next(iter(d1))[0].size()
network_wrappers.assignIdentityMap(net, input_shape)
net.cuda()
optimizer = torch.optim.Adam(net.parameters(), lr=0.001)
net.train()
y = np.array(train.train2d(net, optimizer, d1, d2, epochs=50))
# Test that image similarity is good enough
self.assertLess(np.mean(y[-5:, 1]), 0.1)
# Test that folds are rare enough
self.assertLess(np.mean(np.exp(y[-5:, 3] - 0.1)), 2)
print(y)
import random
import icon_registration.inverseConsistentNet as inverseConsistentNet
import icon_registration.networks as networks
import icon_registration.network_wrappers as network_wrappers
import icon_registration.data as data
import footsteps
BATCH_SIZE = 32
SCALE = 1 # 1 IS QUARTER RES, 2 IS HALF RES, 4 IS FULL RES
input_shape = [BATCH_SIZE, 1, 40 * SCALE, 96 * SCALE, 96 * SCALE]
GPUS = 4
phi = network_wrappers.FunctionFromVectorField(
networks.tallUNet(unet=networks.UNet2ChunkyMiddle, dimension=3)
)
psi = network_wrappers.FunctionFromVectorField(networks.tallUNet2(dimension=3))
pretrained_lowres_net = inverseConsistentNet.InverseConsistentNet(
network_wrappers.DoubleNet(phi, psi),
lambda x, y: torch.mean((x - y) ** 2),
100,
)
network_wrappers.assignIdentityMap(pretrained_lowres_net, input_shape)
network_wrappers.adjust_batch_size(pretrained_lowres_net, 12)
trained_weights = torch.load(
"results/dd_l400_continue_rescalegrad2/knee_aligner_resi_net25500"
batch_size = 128
data_size = 50
d1, d2 = data.get_dataset_triangles("train",
data_size=data_size,
hollow=True,
batch_size=batch_size)
d1_t, d2_t = data.get_dataset_triangles("test",
data_size=data_size,
hollow=True,
batch_size=batch_size)
image_A, image_B = (x[0].cuda() for x in next(zip(d1, d2)))
net = inverseConsistentNet.InverseConsistentNet(
network_wrappers.DoubleNet(
network_wrappers.FunctionFromVectorField(
networks.tallUNet2(dimension=2)),
network_wrappers.FunctionFromVectorField(
networks.tallUNet2(dimension=2)),
),
lambda x, y: torch.mean((x - y)**2),
700,
)
input_shape = next(iter(d1))[0].size()
network_wrappers.assignIdentityMap(net, input_shape)
net.cuda()
import icon_registration.train as train
optim = torch.optim.Adam(net.parameters(), lr=0.0001)
net.train().cuda()
import icon_registration.inverseConsistentNet as inverseConsistentNet
import icon_registration.networks as networks
import icon_registration.network_wrappers as network_wrappers
import icon_registration.data as data
import footsteps
BATCH_SIZE = 32
SCALE = 1 # 1 IS QUARTER RES, 2 IS HALF RES, 4 IS FULL RES
input_shape = [BATCH_SIZE, 1, 40 * SCALE, 96 * SCALE, 96 * SCALE]
GPUS = 1
scale_down = [BATCH_SIZE, 1, 20 * SCALE, 48 * SCALE, 48 * SCALE]
net = inverseConsistentNet.InverseConsistentNet(
network_wrappers.DownsampleNet(
network_wrappers.FunctionFromVectorField(networks.FCNet3D(scale_down, bottleneck=512)),
dimension=3,
),
lambda x, y: torch.mean((x - y) ** 2),
70,
)
network_wrappers.assignIdentityMap(net, input_shape)
knees = torch.load("/playpen/tgreer/knees_big_train_set")
trained_weights = torch.load("results/fc_smol_knee/knee_aligner_resi_net30000")
network_wrappers.adjust_batch_size(net, 16)
net.load_state_dict(trained_weights)
network_wrappers.adjust_batch_size(net, BATCH_SIZE)
d1, d2 = data.get_dataset_triangles(
"train", data_size=28, hollow=False, batch_size=batch_size
)
d1_t, d2_t = data.get_dataset_triangles(
"test", data_size=28, hollow=False, batch_size=batch_size
)
lmbda = 150
random.seed(1)
torch.manual_seed(1)
torch.cuda.manual_seed(1)
np.random.seed(1)
print("=" * 50)
net = inverseConsistentNet.InverseConsistentNet(
network_wrappers.FunctionFromVectorField(RegistrationTransformer(28)),
lambda x, y: torch.mean((x[:1] - y[:1]) ** 2),
lmbda,
)
input_shape = next(iter(d1))[0].size()
network_wrappers.assignIdentityMap(net, input_shape)
net.cuda()
optimizer = torch.optim.Adam(net.parameters(), lr=0.001)
net.train()
xs = []
for _ in range(0,130):
