# params for optimizing models
lr = 2e-4
params = Config()
currentDir = os.path.dirname(os.path.realpath(__file__))
logFile = os.path.join(currentDir+'/../', 'dann-{}-{}.log'.format(params.src_dataset, params.tgt_dataset))
loggi = setLogger(logFile)
# init random seed
init_random_seed(params.manual_seed)
# init device
device = torch.device("cuda:" + params.gpu_id if torch.cuda.is_available() else "cpu")
# load dataset
src_data_loader = get_data_loader(params.src_dataset, params.dataset_root, params.batch_size)
tgt_data_loader = get_data_loader(params.tgt_dataset, params.dataset_root, params.batch_size)
# load dann model
# dann = init_model(net=AlexModel(), restore=None)
dann = init_model(net=ResNet50(), restore=None)
# train dann model
print("Start training dann model.")
# if not (dann.restored and params.dann_restore):
dann = train_dann(dann, params, src_data_loader, tgt_data_loader, tgt_data_loader, device, loggi)
print('done')
manual_seed = 8888
alpha = 0
# params for optimizing models
lr = 2e-4
params = Config()
# init random seed
init_random_seed(params.manual_seed)
# load dataset
src_data_loader = get_data_loader(params.src_dataset, params.dataset_root,
params.batch_size)
tgt_data_loader = get_data_loader(params.tgt_dataset, params.dataset_root,
params.batch_size)
# load dann model
dann = init_model(net=AlexModel(), restore=None)
# train dann model
print("Start training dann model.")
if not (dann.restored and params.dann_restore):
dann = train_dann(dann, params, src_data_loader, tgt_data_loader,
tgt_data_loader)
print('done')
name_best_model = 'weights/camvid/best'
dataset_path = 'Datasets/camvid'
preprocess_mode = 'imagenet' #possible values 'imagenet', 'normalize',None
loader = Loader.Loader(dataFolderPath=dataset_path, n_classes=n_classes, problemType='segmentation',
width=width, height=height, channels=channels, median_frequency=0.0)
# build model and optimizer
model = Segception.Efficient(num_classes=n_classes, weights='imagenet', input_shape=(None, None, channels))
# optimizer
learning_rate = tfe.Variable(lr)
optimizer = tf.train.AdamOptimizer(learning_rate)
# Init models (optional, just for get_params function)
init_model(model, input_shape=(batch_size, width, height, channels))
variables_to_restore = model.variables
variables_to_save = model.variables
variables_to_optimize = model.variables
# Init saver. can use also ckpt = tfe.Checkpoint((model=model, optimizer=optimizer,learning_rate=learning_rate, global_step=global_step)
saver_model = tfe.Saver(var_list=variables_to_save)
restore_model = tfe.Saver(var_list=variables_to_restore)
# restore if model saved and show number of params
restore_state(restore_model, name_best_model)
get_params(model)
train(loader=loader, optimizer=optimizer, model=model, epochs=epochs, batch_size=batch_size, augmenter='segmentation', lr=learning_rate,
init_lr=lr, saver=saver_model, variables_to_optimize=variables_to_optimize, name_best_model=name_best_model,
src_data_loader = get_data_loader(params.src_dataset,
params.dataset_root,
params.batch_size,
train=True)
src_data_loader_eval = get_data_loader(params.src_dataset,
params.dataset_root,
params.batch_size,
train=False)
tgt_data_loader = get_data_loader(params.tgt_dataset,
params.dataset_root,
params.batch_size,
train=True)
tgt_data_loader_eval = get_data_loader(params.tgt_dataset,
params.dataset_root,
params.batch_size,
train=False)
# load dann model
dann = init_model(net=SVHNmodel(), restore=None)
# train dann model
print("Training dann model")
if not (dann.restored and params.dann_restore):
dann = train_dann(dann, params, src_data_loader, tgt_data_loader,
tgt_data_loader_eval)
# eval dann model
print("Evaluating dann for source domain {}".format(params.src_dataset))
eval(dann, src_data_loader_eval)
print("Evaluating dann for target domain {}".format(params.tgt_dataset))
eval(dann, tgt_data_loader_eval)
# init random seed
init_random_seed(params.manual_seed)
# load dataset
src_data_loader = get_data_loader(params.src_dataset,
params.src_image_root,
params.batch_size,
train=True)
src_data_loader_eval = get_data_loader(params.src_dataset,
params.src_image_root,
params.batch_size,
train=False)
tgt_data_loader = get_data_loader(params.tgt_dataset,
params.tgt_image_root,
params.batch_size,
train=True)
tgt_data_loader_eval = get_data_loader(params.tgt_dataset,
params.tgt_image_root,
params.batch_size,
train=False)
# load dann model
dann = init_model(net=GTSRBmodel(), restore=None)
# train dann model
print("Training dann model")
if not (dann.restored and params.dann_restore):
dann = train_dann(dann, params, src_data_loader, tgt_data_loader,
tgt_data_loader_eval, device, logger)
transforms.Compose([
transforms.Resize(112),
transforms.CenterCrop(112),
transforms.ToTensor()
]), stage='Test')
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=params.test_batch_size,
num_workers=0,
pin_memory=True)
test_dataset = FinalImgLoader(params.root_folder, os.path.join(params.root_folder, params.src_test_list),
transforms.Compose([
transforms.Resize(112),
transforms.CenterCrop(112),
transforms.ToTensor()
]), stage='Test')
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=params.test_batch_size,
num_workers=0,
pin_memory=True)
model = init_model(net=resnet18_cbam(),
restore=params.fusion_encoder_restore)
model = train_feature_fusion(model, train_loader, val_loader)
eval_fusionmodal(model, test_loader)
# some parameters
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.n_gpu)
n_classes = int(args.n_classes)
width = int(args.width)
height = int(args.height)
channels = 1
name_best_model = os.path.join(args.model_path, 'best')
# build model and optimizer
model = Segception.Segception_v4(num_classes=n_classes,
weights=None,
input_shape=(None, None, channels))
# Init models (optional, just for get_params function)
init_model(model, input_shape=(1, width, height, channels))
variables_to_restore = model.variables
variables_to_save = model.variables
variables_to_optimize = model.variables
# Init saver. can use also ckpt = tfe.Checkpoint((model=model, optimizer=optimizer,learning_rate=learning_rate, global_step=global_step)
saver_model = tfe.Saver(var_list=variables_to_save)
restore_model = tfe.Saver(var_list=variables_to_restore)
# restore if model saved and show number of params
restore_state(restore_model, name_best_model)
get_params(model)
img = cv2.imread(args.image_path, 0)
img = cv2.resize(img, (width, height),
manual_seed = 8888
alpha = 0
# params for optimizing models
lr = 2e-4
params = Config()
# init random seed
init_random_seed(params.manual_seed)
# load dataset
src_data_loader = get_data_loader(params.src_dataset, params.dataset_root, params.batch_size, train=True)
src_data_loader_eval = get_data_loader(params.src_dataset, params.dataset_root, params.batch_size, train=False)
tgt_data_loader = get_data_loader(params.tgt_dataset, params.dataset_root, params.batch_size, train=True)
tgt_data_loader_eval = get_data_loader(params.tgt_dataset, params.dataset_root, params.batch_size, train=False)
# load dann model
dann = init_model(net=MNISTmodel(), restore=None)
# train dann model
print("Training dann model")
if not (dann.restored and params.dann_restore):
dann = train_dann(dann, params, src_data_loader, tgt_data_loader, tgt_data_loader_eval)
# eval dann model
print("Evaluating dann for source domain {}".format(params.src_dataset))
eval(dann, src_data_loader_eval)
print("Evaluating dann for target domain {}".format(params.tgt_dataset))
eval(dann, tgt_data_loader_eval)
def train(n_classes=11,
batch_size=16,
epochs=100,
width=960,
height=720,
crop_factor_x=2,
crop_factor_y=1.25,
init_lr=1e-4,
median_frequency=.15,
zoom_augmentation=.2,
dataset_path='datasets/endoscopy',
weights_path='weights/endoscopy/model',
preprocess='imagenet'):
CONFIG = {}
CONFIG['n_classes'] = n_classes
CONFIG['batch_size'] = batch_size
CONFIG['epochs'] = epochs
CONFIG['width'] = width
CONFIG['height'] = height
CONFIG['crop_factor_x'] = crop_factor_x
CONFIG['crop_factor_y'] = crop_factor_y
CONFIG['width_train'] = int(
CONFIG['width'] /
CONFIG['crop_factor_x']) # will be cropped from width_test size
CONFIG['height_train'] = int(
CONFIG['height'] /
CONFIG['crop_factor_y']) # will be cropped from height_test size
CONFIG['init_lr'] = init_lr
CONFIG['median_frequency'] = median_frequency
CONFIG['zoom_augmentation'] = zoom_augmentation
CONFIG['dataset_path'] = dataset_path
CONFIG['weights_path'] = weights_path
CONFIG['preprocess'] = preprocess
assert CONFIG['width'] * (
1 - CONFIG['zoom_augmentation']) >= CONFIG['width_train']
assert CONFIG['height'] * (
1 - CONFIG['zoom_augmentation']) >= CONFIG['height_train']
# GPU to use
n_gpu = 0
os.environ["CUDA_VISIBLE_DEVICES"] = str(n_gpu)
# Loader
loader = Loader.Loader(dataFolderPath=CONFIG['dataset_path'],
n_classes=CONFIG['n_classes'],
width=CONFIG['width'],
height=CONFIG['height'],
median_frequency=CONFIG['median_frequency'])
print('Dataset loaded...')
# build model
#model = MiniNetv2.MiniNetv2p(num_classes=CONFIG['n_classes'])
model = ResNet50.ResNet50Seg(CONFIG['n_classes'],
input_shape=(None, None, 3),
weights='imagenet')
# optimizer
learning_rate = tf.Variable(CONFIG['init_lr'])
optimizer = tf.keras.optimizers.Adam(learning_rate)
loss_function = tf.keras.losses.CategoricalCrossentropy()
# restore if model saved and show number of params
restore_state(model, CONFIG['weights_path'])
init_model(model, (1, CONFIG['width'], CONFIG['height'], 3))
get_params(model)
# Train
print('Training...')
_train(loader=loader,
optimizer=optimizer,
loss_function=loss_function,
model=model,
config=CONFIG,
lr=learning_rate,
name_best_model=CONFIG['weights_path'],
evaluation=True,
preprocess_mode=CONFIG['preprocess'])
print('Testing model')
test_acc, test_miou = get_metrics(loader,
model,
loader.n_classes,
train=False,
flip_inference=True,
scales=[1, 2, 1.5, 0.5, 0.75],
write_images=True,
preprocess_mode=CONFIG['preprocess'],
time_exect=True)
print('Test accuracy: ' + str(test_acc.numpy()))
print('Test miou: ' + str(test_miou.numpy()))
print('Dataset loaded...')
# build model
#model = MiniNetv2.MiniNetv2p(num_classes=CONFIG['n_classes'])
model = ResNet50.ResNet50Seg(CONFIG['n_classes'],
input_shape=(None, None, 3),
weights='imagenet')
# optimizer
learning_rate = tf.Variable(CONFIG['init_lr'])
optimizer = tf.keras.optimizers.Adam(learning_rate)
loss_function = tf.keras.losses.CategoricalCrossentropy()
# restore if model saved and show number of params
restore_state(model, args.weights_path)
init_model(model, (1, CONFIG['width'], CONFIG['height'], 3))
get_params(model)
# Train
print('Training...')
_train(loader=loader,
optimizer=optimizer,
loss_function=loss_function,
model=model,
config=CONFIG,
lr=learning_rate,
name_best_model=args.weights_path,
evaluation=True,
preprocess_mode=args.preprocess)
print('Testing model')
src_train_loader = torch.utils.data.DataLoader(src_dataset,
batch_size=params.batch_size,
num_workers=2,
shuffle=True,
pin_memory=True)
src_val_dataset = TestImgLoader(params.root_folder, os.path.join(params.root_folder, params.src_val_list),
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(248),
transforms.ToTensor()
]), stage='Test')
src_val_loader = torch.utils.data.DataLoader(src_val_dataset,
batch_size=params.test_batch_size,
num_workers=2,
pin_memory=True)
model = init_model(net=resnet18(),
restore=params.src_encoder_restore)
# model = train_src(model, src_train_loader, src_val_loader)
eval_src(model, src_val_loader)
#eval_src_score(model, src_val_loader)
