def main():
new_model = DeepestNetwork((25, 3, 120, 214))
N = 4
cwd = Path(os.getcwd())
par = cwd.parent
data_path = str(par / "data/DAVIS//JPEGImages/480p/")
mask_path = str(par / "data/DAVIS/Annotations/480p/")
tvt_split = (0.5, 0.7)
X_train_t, X_val_t, X_test_t, y_train_t, y_val_t, y_test_t = generate_dataset_temporal(
data_path, mask_path, tvt_split, N)
X_train_t = np.array(X_train_t).swapaxes(-1, -3).swapaxes(-2, -1)
X_val_t = np.array(X_val_t).swapaxes(-1, -3).swapaxes(-2, -1)
X_test_t = np.array(X_test_t).swapaxes(-1, -3).swapaxes(-2, -1)
print(X_train_t.shape)
print(X_val_t.shape)
print(X_test_t.shape)
y_train_t = np.array(y_train_t)
y_val_t = np.array(y_val_t)
y_test_t = np.array(y_test_t)
print(y_train_t.shape)
print(y_val_t.shape)
print(y_test_t.shape)
batch_size = 25
train_data_t = data_providers.DataProvider(X_train_t,
y_train_t,
batch_size,
shuffle_order=True)
val_data_t = data_providers.DataProvider(X_val_t,
y_val_t,
batch_size,
shuffle_order=True)
test_data_t = data_providers.DataProvider(X_test_t,
y_test_t,
batch_size,
shuffle_order=True)
eb = ExperimentBuilder(new_model, "get_bear", 1, train_data_t, val_data_t,
test_data_t, True)
model_path = Path(os.getcwd())
model_path = model_path / "static_run_deepest" / "saved_models"
bear_path = Path(
os.getcwd()).parent / "data" / "DAVIS" / "JPEGImages" / "480p" / "bear"
bear = np.asarray(
Image.open(str(bear_path / "00001.jpg")).convert(mode="RGB"))
inp = torch.Tensor(
down_sample(np.asarray(bear),
4).swapaxes(0, 2).swapaxes(1, 2)).unsqueeze(0)
out = eb.get_bear(model_path, inp)
out = out.squeeze()
predicted = F.sigmoid(out) > 0.5
mask = predicted.cpu().numpy().astype('uint8')
mask = 255 * mask
mask_img = Image.fromarray(mask, mode='L')
bear = down_sample(bear, 4)
bear = Image.fromarray(bear)
overlay = overlay_segment(bear, mask_img)
overlay.save("cnnbear.png")
scheduler_params = {
'lr_max': args.learn_rate_max,
'lr_min': args.learn_rate_min,
'erf_alpha': args.erf_sched_alpha,
'erf_beta': args.erf_sched_beta
}
if not args.use_mix_match and not args.use_fix_match:
print('No Mix Match')
bhc_experiment = ExperimentBuilder(
network_model=model,
use_gpu=args.use_gpu,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
continue_from_epoch=args.continue_from_epoch,
train_data=train_loader,
val_data=val_loader,
test_data=test_loader,
optimiser=args.optim_type,
optim_params=optimizer_params,
scheduler=args.sched_type,
sched_params=scheduler_params)
elif args.use_mix_match:
print('Mix Match')
bhc_experiment = ExperimentBuilderMixMatch(
network_model=model,
use_gpu=args.use_gpu,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
continue_from_epoch=args.continue_from_epoch,
train_data=train_loader,
num_output_classes=num_output_classes,
hidden_size=args.lstm_hidden_dim,
attention_kernel_size=args.encoder_output_size,
use_bias=True,
num_att_layers=2,
embedding_matrix=embedding_matrix)
model_2 = StackedAttentionNetwork(desc_input_shape=(args.batch_size, 102),
img_input_shape=(args.batch_size, 512, 14, 14),
num_output_classes=2,
hidden_size=args.lstm_hidden_dim,
attention_kernel_size=args.encoder_output_size,
use_bias=True,
num_att_layers=2,
embedding_matrix=embedding_matrix)
siamese_model = SiameseNetwork(item_1_model=model_1, item_2_model=model_2, encoder_output_size=args.encoder_output_size,
fc1_size=args.fc1_size, fc2_size=args.fc2_size, use_bias=True)
experiment = ExperimentBuilder(network_model=siamese_model,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
learning_rate=args.lr,
weight_decay_coefficient=args.weight_decay_coefficient,
continue_from_epoch=args.continue_from_epoch,
device=device,
train_data=training_data_loader,
val_data=valid_data_loader,
test_data=test_data_loader) # build an experiment object
experiment_metrics, test_metrics = experiment.run_experiment() # run experiment and return experiment metrics
import data as dataset
from experiment_builder import ExperimentBuilder
parser = argparse.ArgumentParser(description='Welcome to GAN-Shot-Learning script')
parser.add_argument('--batch_size', nargs="?", type=int, default=32, help='batch_size for experiment')
parser.add_argument('--discriminator_inner_layers', nargs="?", type=int, default=1,
help='Number of inner layers per multi layer in the discriminator')
parser.add_argument('--generator_inner_layers', nargs="?", type=int, default=1,
help='Number of inner layers per multi layer in the generator')
parser.add_argument('--experiment_title', nargs="?", type=str, default="omniglot_dagan_experiment",
help='Experiment name')
parser.add_argument('--continue_from_epoch', nargs="?", type=int, default=-1, help='continue from checkpoint of epoch')
parser.add_argument('--num_of_gpus', nargs="?", type=int, default=1, help='Number of GPUs to use for training')
parser.add_argument('--z_dim', nargs="?", type=int, default=100, help='The dimensionality of the z input')
parser.add_argument('--dropout_rate_value', type=float, default=0.5,
help='A dropout rate placeholder or a scalar to use throughout the network')
parser.add_argument('--num_generations', nargs="?", type=int, default=64,
help='The number of samples generated for use in the spherical interpolations at the end of each epoch')
args = parser.parse_args()
batch_size = args.batch_size
num_gpus = args.num_of_gpus
# set the data provider to use for the experiment
data = dataset.PlantDAGANDataset(batch_size=batch_size, last_training_class_index=900,
reverse_channels=True,
num_of_gpus=num_gpus, gen_batches=10)
# init experiment
experiment = ExperimentBuilder(parser, data=data)
# run experiment
experiment.run_experiment()
from data import MetaLearningSystemDataLoader
from experiment_builder import ExperimentBuilder
from few_shot_learning_system import MAMLFewShotClassifier
from utils.parser_utils import get_args
args, device = get_args()
model = MAMLFewShotClassifier(args=args, device=device)
data = MetaLearningSystemDataLoader
maml_system = ExperimentBuilder(model=model,
data=data,
args=args,
device=device)
test_loss_mean, test_loss_std, val_c_index = maml_system.test_experiment(
args.test_model)
with open("TEST_RESULTS_11_02_2021.txt", "a+") as f:
f.write("{},{},{},{}\n".format(args.test_path, test_loss_mean,
test_loss_std, val_c_index))
batch_size=args.batch_size,
shuffle=False,
num_workers=4)
test_data = torch.utils.data.DataLoader(voc_test,
batch_size=args.batch_size,
shuffle=False,
num_workers=4)
custom_net = DeepLab(args.output_stride, args.num_class)
ss_experiment = ExperimentBuilder(network_model=custom_net,
num_class=args.num_class,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
train_data=train_data,
val_data=val_data,
test_data=test_data,
learn_rate=args.learn_rate,
mementum=args.mementum,
weight_decay=args.weight_decay,
use_gpu=args.use_gpu,
continue_from_epoch=args.continue_from_epoch)
plt.switch_backend('agg')
dirName = './image/' + args.experiment_name
if not os.path.exists(dirName):
os.mkdir(dirName)
evaluator = Evaluator(args.num_class)
for idx, (img, tag) in enumerate(val_data):
predicts = ss_experiment.run_predicted_iter(img, tag)
for i in range(args.batch_size):
image = img[i]
from data import MetaLearningSystemDataLoader
from experiment_builder import ExperimentBuilder
from few_shot_learning_system import MAMLFewShotClassifier
from utils.parser_utils import get_args
from utils.dataset_tools import maybe_unzip_dataset
# Combines the arguments, model, data and experiment builders to run an experiment
args, device = get_args()
model = MAMLFewShotClassifier(args=args, device=device,
im_shape=(2, args.image_channels,
args.image_height, args.image_width))
maybe_unzip_dataset(args=args)
data = MetaLearningSystemDataLoader
maml_system = ExperimentBuilder(model=model, data=data, args=args, device=device)
maml_system.run_experiment()
seed=args.seed,
sets_are_pre_split=args.sets_are_pre_split,
load_into_memory=args.load_into_memory, set_name='test',
num_tasks_per_epoch=600,
num_channels=args.image_channels,
num_support_sets=args.num_support_sets,
overwrite_classes_in_each_task=args.overwrite_classes_in_each_task,
class_change_interval=args.class_change_interval)
train_data = FewShotLearningDatasetParallel(**train_setup_dict)
val_data = FewShotLearningDatasetParallel(**val_setup_dict)
test_data = FewShotLearningDatasetParallel(**test_setup_dict)
data_dict = {'train': DataLoader(train_data, batch_size=args.batch_size,
num_workers=args.num_dataprovider_workers),
'val': DataLoader(val_data, batch_size=args.batch_size,
num_workers=args.num_dataprovider_workers),
'test': DataLoader(test_data, batch_size=args.batch_size,
num_workers=args.num_dataprovider_workers)}
maml_system = ExperimentBuilder(model=model, data_dict=data_dict, experiment_name=args.experiment_name,
continue_from_epoch=args.continue_from_epoch,
total_iter_per_epoch=args.total_iter_per_epoch,
num_evaluation_tasks=args.num_evaluation_tasks, total_epochs=args.total_epochs,
batch_size=args.batch_size, max_models_to_save=args.max_models_to_save,
evaluate_on_test_set_only=args.evaluate_on_test_set_only,
args=args)
maml_system.run_experiment()
test_data = data.DataLoader(test_dataset, **params)
num_output_classes = 2
custom_net = TwoStreamNetwork(input_shape=(batch_size, num_flow_channels,
image_height, image_width),
dropout_rate=args.dropout_rate)
experiment = ExperimentBuilder(
network_model=custom_net,
experiment_name=experiment_name,
num_epochs=num_epochs,
weight_decay_coefficient=weight_decay_coefficient,
lr=args.lr,
gpu_id=gpu_id,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
num_batches=num_batches,
train_data=train_data,
valid_data=val_data,
test_data=test_data,
pretrained=args.pretrained,
schedule=args.schedule) # build an experiment object
if not args.only_output_results:
total_losses, test_losses = experiment.run_experiment(
) # run experiment and return experiment metrics
print(total_losses, test_losses)
else:
# valid_losses = experiment.output_summary(type='valid', epoch_idx=continue_from_epoch)
test_losses = experiment.output_summary(type='test',
from data import MetaLearningSystemDataLoader
from experiment_builder import ExperimentBuilder
from few_shot_learning_system import *
from utils.parser_utils import get_args
from utils.dataset_tools import check_download_dataset
# Combines the arguments, model, data and experiment builders to run an experiment
args, device = get_args()
model = EmbeddingMAMLFewShotClassifier(args=args,
device=device,
im_shape=(2, args.image_channels,
args.image_height,
args.image_width))
check_download_dataset(args=args)
data = MetaLearningSystemDataLoader
maml_system = ExperimentBuilder(use_features_instead_of_images=False,
model=model,
data=data,
args=args,
device=device)
maml_system.run_experiment()
num_output_classes=enn_output_dim,
num_filters=enn_hidden_dim,
num_layers=enn_layers)
else:
enn = None
pnn = PNN(input_shape=(batch_size, pnn_input_dim),
num_output_classes=pnn_output_dim,
num_filters=pnn_hidden_dim,
num_layers=pnn_layers)
bridge_experiment = ExperimentBuilder(
estimation_model=enn,
policy_model=pnn,
num_epochs=num_epochs,
weight_decay_coefficient=weight_decay_coefficient,
use_gpu=use_gpu,
train_data=train_data_loader,
val_data=val_data_loader,
test_data=test_data_loader,
lr=lr) # build an experiment object
if use_enn:
enn_stats, pnn_stats = bridge_experiment.run_experiment()
plot_result_graphs('baseline', enn_stats, pnn_stats)
enn_accs, pnn_accs = bridge_experiment.eval_bid_length()
plot_length_graphs('bidding_length', enn_accs, pnn_accs)
else:
pnn_stats = bridge_experiment.run_experiment()
plot_pnn_graphs('only_pnn', pnn_stats)
from data_providers.windowed_data_provider import WindowedDataProvider
from data_providers.data_reader import FullDataReader, MiniDataReader
import numpy as np
from arg_extractor import get_args
args = get_args()
rng = np.random.RandomState(args.seed)
experiment_builder = ExperimentBuilder(
args=args,
model=MeanPredictor(mean=0),
experiment_name="mean_predictor",
num_epochs=1,
train_data=WindowedDataProvider(data_reader=FullDataReader(
args.data_path, 'train'),
window_size=11,
segment_size=12,
batch_size=args.batch_size,
shuffle_order=True,
rng=rng),
val_data=WindowedDataProvider(data_reader=FullDataReader(
args.data_path, 'valid'),
window_size=11,
segment_size=12,
batch_size=args.batch_size,
shuffle_order=True,
rng=rng),
continue_from_epoch=-1)
experiment_builder.run_experiment()
if args.load_pretrained == None:
from_scratch_conv_net = ConvolutionalNetwork( # initialize our network object, in this case a ConvNet
input_shape=(args.batch_size, args.image_num_channels,
args.image_height, args.image_height),
dim_reduction_type=args.dim_reduction_type,
num_filters=args.num_filters,
num_layers=args.num_layers,
use_bias=False,
num_output_classes=num_output_classes)
source_task_training = ExperimentBuilder(
network_model=from_scratch_conv_net,
use_gpu=args.use_gpu,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
weight_decay_coefficient=args.weight_decay_coefficient,
continue_from_epoch=args.continue_from_epoch,
train_data=train_data,
val_data=val_data,
test_data=test_data) # build an experiment object
fine_tuning_on_target_conv_net = from_scratch_conv_net
else:
fine_tuning_on_target_conv_net = torch.load(args.load_pretrained)
target_task_training = ExperimentBuilder(
network_model=fine_tuning_on_target_conv_net,
use_gpu=args.use_gpu,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
weight_decay_coefficient=args.weight_decay_coefficient,
continue_from_epoch=args.continue_from_epoch,
augment = False
data = dataset.CIFAR_100(batch_size=batch_size,
samples_per_class=samples_per_class,
queries_per_class=queries_per_class)
elif data_name == "omniglot":
channels = 1
image_size = 28
augment = True
data = dataset.OmniglotNShotDataset(batch_size=batch_size,\
classes_per_set=classes_per_set, samples_per_class=samples_per_class, queries_per_class = queries_per_class)
else:
print("Unsupported dataset.")
assert False
experiment = ExperimentBuilder(data)
one_shot, losses, c_error_opt_op, init = experiment.build_experiment(batch_size,\
classes_train, classes_test, samples_per_class, queries_per_class, channels, image_size, fce, network_name)
#
total_epochs = 300
total_train_batches = 1000
total_val_batches = 100
total_test_batches = 250
save_statistics(experiment_name, [
"epoch", "train_c_loss", "train_c_accuracy", "val_loss", "val_accuracy",
"test_c_loss", "test_c_accuracy"
])
# Experiment initialization and running
logs_path = "one_shot_outputs_ADNI/"
experiment_name = "one_shot_ADNI_{}fold_{}_{}".format(k, samples_per_class,
classes_per_set)
# Experiment builder
# data = dataset.OmniglotNShotDataset(batch_size=batch_size, classes_per_set=classes_per_set,
# samples_per_class=samples_per_class)
data = dataset.ADNIDataset(k=k,
batch_size=batch_size,
classes_per_set=classes_per_set,
samples_per_class=samples_per_class)
experiment = ExperimentBuilder(data)
one_shot_omniglot, losses, c_error_opt_op, init = experiment.build_experiment(
batch_size, classes_per_set, samples_per_class, fce)
total_epochs = 100
total_train_batches = 5
total_val_batches = 2
total_test_batches = 2
save_statistics(experiment_name, [
"epoch", "train_c_loss", "train_c_accuracy", "val_loss", "val_accuracy",
"test_c_loss", "test_c_accuracy"
])
# summary_path = "/summary/%d" % (int(time.time()))
# Experiment initialization and running
shuffle=True,
num_workers=0)
#
custom_blstm = LSTMBlock(input_dim=args.input_dim,
dropout=args.drop_out,
batch_size=args.batch_size,
hidden_dim=args.hidden_dim,
output_dim=args.num_classes,
num_layers=args.num_layers)
conv_experiment = ExperimentBuilder(
network_model=custom_blstm,
beta=args.beta,
layer_no=args.layer_no,
SER=args.SER,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
gender_MTL=args.genderMTL,
experiment_no=args.experiment_no,
weight_decay_coefficient=args.weight_decay_coefficient,
use_gpu=args.use_gpu,
continue_from_epoch=args.continue_from_epoch,
train_data=train_data_loader,
val_data=val_data_loader,
test_data=test_data_loader,
lr=args.learning_rate,
batch_size=args.batch_size) # build an experiment object
experiment_metrics, test_metrics = conv_experiment.run_experiment(
) # run experiment and return experiment metrics
transform=transform_test)
test_data = torch.utils.data.DataLoader(testset,
batch_size=100,
shuffle=False,
num_workers=2)
num_output_classes = 100
custom_conv_net = ConvolutionalNetwork( # initialize our network object, in this case a ConvNet
input_shape=(args.batch_size, args.image_num_channels, args.image_height,
args.image_height),
dim_reduction_type=args.dim_reduction_type,
num_filters=args.num_filters,
num_layers=args.num_layers,
use_bias=False,
num_output_classes=num_output_classes)
conv_experiment = ExperimentBuilder(
network_model=custom_conv_net,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
weight_decay_coefficient=args.weight_decay_coefficient,
gpu_id=args.gpu_id,
use_gpu=args.use_gpu,
continue_from_epoch=args.continue_from_epoch,
train_data=train_data,
val_data=val_data,
test_data=test_data) # build an experiment object
experiment_metrics, test_metrics = conv_experiment.run_experiment(
) # run experiment and return experiment metrics
import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
import sys
from os import path
parent_folder = path.dirname(path.dirname(path.abspath(__file__)))
sys.path.append(parent_folder)
import numpy as np
from experiment_builder import ExperimentBuilder
from models.cnn_convlstm import CnnConvLSTM
from data_providers.full_grid_data_provider import FullGridDataProvider
from data_providers import data_provider_factory
from arg_extractor import get_args
import model_factory
args = get_args()
rng = np.random.RandomState(args.seed)
model = model_factory.get_model(args)
train_data, val_data = data_provider_factory.get_data_providers(args, rng)
experiment_builder = ExperimentBuilder(
args=args,
model=model,
train_data=train_data,
val_data=val_data,
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
continue_from_epoch=args.continue_from_epoch)
experiment_builder.run_experiment()
optimizer = BertAdam(optimizer_grouped_parameters,
lr=args.learning_rate,
warmup=args.warmup_proportion,
t_total=num_train_optimization_steps)
scheduler = None
# get experiment
experiment = ExperimentBuilder(
network_model=model,
experiment_name=args.experiment_name,
num_epochs=1, # hard code 1 epoch to ensure runtime limit
gpu_id=args.gpu_id,
use_gpu=args.use_gpu,
device=device,
continue_from_epoch=args.continue_from_epoch,
criterion=criterion,
optimizer=optimizer,
fp16=args.fp16,
scheduler=scheduler,
learning_rate=args.learning_rate,
val_metrics='loss',
# save_optimizer=True,
train_data=train_data,
val_data=val_data,
test_data=None) # build an experiment object
experiment.run_experiment()
import json
with open("args_dict.json", 'w') as file:
json.dump(args_dict, file, indent=True)
session_holder = SessionHolder()
experiment_builder = ExperimentBuilder(
args=args,
model=LSTM(gpus=args.gpus,
batch_size=args.batch_size,
segment_size=args.segment_size,
num_features=args.window_size**2,
num_layers=args.num_layers,
hidden_size=args.hidden_size,
session_holder=session_holder,
learning_rate=args.learning_rate),
experiment_name=args.experiment_name,
num_epochs=args.num_epochs,
train_data=WindowedDataProvider(data_reader=data_reader(
data_folder=args.data_path, which_set='train'),
window_size=args.window_size,
segment_size=args.segment_size,
batch_size=args.batch_size,
shuffle_order=True,
rng=rng,
fraction_of_data=args.fraction_of_data),
val_data=WindowedDataProvider(data_reader=data_reader(
data_folder=args.data_path, which_set='valid'),
window_size=args.window_size,
segment_size=args.segment_size,
batch_size=args.batch_size,
shuffle_order=True,
rng=rng),
continue_from_epoch=args.continue_from_epoch)
with tf.Session() as sess:
batch_size=args.batch_size,
image_height=28,
image_width=28,
image_channels=1,
train_val_test_split=(1200 / 1622, 211 / 1622, 211 / 1622),
samples_per_iter=1,
num_workers=4,
data_path="datasets/omniglot_data",
name="omniglot_data",
index_of_folder_indicating_class=-2,
reset_stored_filepaths=False,
num_samples_per_class=args.samples_per_class,
num_classes_per_set=args.classes_per_set,
label_as_int=True)
experiment = ExperimentBuilder(data)
one_shot_omniglot, losses, c_error_opt_op, init = experiment.build_experiment(
args.batch_size,
args.classes_per_set,
args.samples_per_class,
args.use_full_context_embeddings,
full_context_unroll_k=args.full_context_unroll_k,
args=args)
total_train_batches = args.total_iter_per_epoch
total_val_batches = args.total_iter_per_epoch
total_test_batches = args.total_iter_per_epoch
saved_models_filepath, logs_filepath = build_experiment_folder(
args.experiment_title)
save_statistics(logs_filepath, [
def main():
# down_sample factor
N = 4
# define paths to image and mask files
cwd = Path(os.getcwd())
par = cwd.parent
data_path = str(par / "data/DAVIS//JPEGImages/480p/")
mask_path = str(par / "data/DAVIS/Annotations/480p/")
# training, validation and test split
tvt_split = (0.5, 0.7)
# get datasets
X_train, X_val, X_test, y_train, y_val, y_test = generate_dataset_static(
data_path, mask_path, tvt_split, N)
X_train_t, X_val_t, X_test_t, y_train_t, y_val_t, y_test_t = generate_dataset_temporal(
data_path, mask_path, tvt_split, N)
# reshape datasets to match CNN shapes
X_train = np.array(X_train).swapaxes(1, 3).swapaxes(2, 3)
X_val = np.array(X_val).swapaxes(1, 3).swapaxes(2, 3)
X_test = np.array(X_test).swapaxes(1, 3).swapaxes(2, 3)
print(X_train.shape)
print(X_val.shape)
print(X_test.shape)
y_train = np.array(y_train)
y_val = np.array(y_val)
y_test = np.array(y_test)
print(y_train.shape)
print(y_val.shape)
print(y_test.shape)
X_train_t = np.array(X_train_t).swapaxes(-1, -3).swapaxes(-2, -1)
X_val_t = np.array(X_val_t).swapaxes(-1, -3).swapaxes(-2, -1)
X_test_t = np.array(X_test_t).swapaxes(-1, -3).swapaxes(-2, -1)
print(X_train_t.shape)
print(X_val_t.shape)
print(X_test_t.shape)
y_train_t = np.array(y_train_t)
y_val_t = np.array(y_val_t)
y_test_t = np.array(y_test_t)
print(y_train_t.shape)
print(y_val_t.shape)
print(y_test_t.shape)
#put data into data provider objects
batch_size = 25
train_data = data_providers.DataProvider(X_train,
y_train,
batch_size,
shuffle_order=True)
val_data = data_providers.DataProvider(X_val,
y_val,
batch_size,
shuffle_order=True)
test_data = data_providers.DataProvider(X_test,
y_test,
batch_size,
shuffle_order=True)
batch_size = 25
train_data_t = data_providers.DataProvider(X_train_t,
y_train_t,
batch_size,
shuffle_order=True)
val_data_t = data_providers.DataProvider(X_val_t,
y_val_t,
batch_size,
shuffle_order=True)
test_data_t = data_providers.DataProvider(X_test_t,
y_test_t,
batch_size,
shuffle_order=True)
inputs_shape = X_train[:batch_size].shape
inputs_shape
inputs_shape_t = X_train_t[:batch_size].shape
inputs_shape_t
print("Time to make networks!")
# generates networks of different depths and datasets
static_net_shallow = ShallowNetwork(input_shape=inputs_shape)
static_net_deeper = DeeperNetwork(input_shape=inputs_shape)
temporal_net_shallow = ShallowNetwork(input_shape=inputs_shape_t)
temporal_net_deeper = DeeperNetwork(input_shape=inputs_shape_t)
static_net_deepest = DeepestNetwork(input_shape=inputs_shape)
temporal_net_deepest = DeepestNetwork(input_shape=inputs_shape_t)
# declare variables for experiments
experiment_name = "static_run_shallow"
num_epochs = 30
use_gpu = False
continue_from_epoch = -1
# build experiment and run
experiment_1 = ExperimentBuilder(
network_model=static_net_shallow,
experiment_name=experiment_name,
num_epochs=num_epochs,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
train_data=train_data,
val_data=val_data,
test_data=test_data) # build an experiment object
experiment_metrics, test_metrics = experiment_1.run_experiment(
) # run experiment and return experiment metrics
experiment_name = "static_run_deeper"
num_epochs = 30
use_gpu = True
continue_from_epoch = -1
experiment_2 = ExperimentBuilder(
network_model=static_net_shallow,
experiment_name=experiment_name,
num_epochs=num_epochs,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
train_data=train_data,
val_data=val_data,
test_data=test_data) # build an experiment object
experiment_metrics, test_metrics = experiment_1.run_experiment(
) # run experiment and return experiment metrics
experiment_name = "temporal_run_shallow"
num_epochs = 30
use_gpu = True
continue_from_epoch = -1
experiment_3 = ExperimentBuilder(
network_model=temporal_net_shallow,
experiment_name=experiment_name,
num_epochs=num_epochs,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
train_data=train_data_t,
val_data=val_data_t,
test_data=test_data_t) # build an experiment object
experiment_metrics, test_metrics = experiment_3.run_experiment(
) # run experiment and return experiment metrics
experiment_name = "temporal_run_deeper"
num_epochs = 30
use_gpu = True
continue_from_epoch = -1
experiment_4 = ExperimentBuilder(
network_model=temporal_net_deeper,
experiment_name=experiment_name,
num_epochs=num_epochs,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
train_data=train_data_t,
val_data=val_data_t,
test_data=test_data_t) # build an experiment object
experiment_metrics, test_metrics = experiment_4.run_experiment(
) # run experiment and return experiment metrics
experiment_name = "static_run_deepest"
num_epochs = 30
use_gpu = True
continue_from_epoch = -1
experiment_5 = ExperimentBuilder(
network_model=static_net_deepest,
experiment_name=experiment_name,
num_epochs=num_epochs,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
train_data=train_data,
val_data=val_data,
test_data=test_data) # build an experiment object
experiment_metrics, test_metrics = experiment_5.run_experiment(
) # run experiment and return experiment metrics
experiment_name = "temporal_run_deepest"
num_epochs = 30
use_gpu = True
continue_from_epoch = -1
experiment_6 = ExperimentBuilder(
network_model=temporal_net_deepest,
experiment_name=experiment_name,
num_epochs=num_epochs,
use_gpu=use_gpu,
continue_from_epoch=continue_from_epoch,
train_data=train_data_t,
val_data=val_data_t,
test_data=test_data_t) # build an experiment object
experiment_metrics, test_metrics = experiment_6.run_experiment(
) # run experiment and return experiment metrics"""
import data as dataset
from experiment_builder import ExperimentBuilder
from utils.parser_util import get_args
batch_size, num_gpus, args = get_args()
#set the data provider to use for the experiment
data = dataset.VGGFaceDAGANDataset(batch_size=batch_size,
last_training_class_index=1600,
reverse_channels=True,
num_of_gpus=num_gpus,
gen_batches=10)
#init experiment
experiment = ExperimentBuilder(args, data=data)
#run experiment
experiment.run_experiment()
from data import MetaLearningSystemDataLoader from experiment_builder import ExperimentBuilder from meta_learning_system import SceneAdaptiveInterpolation from config import get_args args, _ = get_args() print(args) model = SceneAdaptiveInterpolation(args) data = MetaLearningSystemDataLoader savfi_system = ExperimentBuilder(model=model, data=data, args=args) savfi_system.run_experiment()
