def run_mini_imagenet():
mini_imagenet_database = MiniImagenetDatabase()
maml = ModelAgnosticMetaLearningModel(
database=mini_imagenet_database,
test_database=MiniImagenetDatabase(),
network_cls=MiniImagenetModel,
n=5,
k_ml=1,
k_val_ml=5,
k_val=1,
k_val_val=15,
k_test=50,
k_val_test=15,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=15000,
meta_learning_rate=0.001,
report_validation_frequency=1000,
log_train_images_after_iteration=1000,
num_tasks_val=100,
clip_gradients=True,
experiment_name='mini_imagenet_test_res',
val_seed=42,
val_test_batch_norm_momentum=0.0,
)
# maml.train(iterations=60000)
maml.evaluate(50, num_tasks=1000, seed=42, use_val_batch_statistics=True)
maml.evaluate(50, num_tasks=1000, seed=42, use_val_batch_statistics=False)
def run_transfer_meta_learning():
mini_imagenet_database = MiniImagenetDatabase()
euro_sat_database = EuroSatDatabase()
tml = TransferMetaLearningVGG16(
database=mini_imagenet_database,
val_database=euro_sat_database,
target_database=euro_sat_database,
network_cls=None,
n=5,
k=1,
k_val_ml=5,
k_val_val=15,
k_val_test=15,
k_test=1,
meta_batch_size=4,
num_steps_ml=1,
lr_inner_ml=0.001,
num_steps_validation=5,
save_after_iterations=1500,
meta_learning_rate=0.0001,
report_validation_frequency=250,
log_train_images_after_iteration=1000,
number_of_tasks_val=100,
number_of_tasks_test=100,
clip_gradients=True,
experiment_name='transfer_meta_learning_mini_imagenet_euro_sat',
val_seed=42,
val_test_batch_norm_momentum=0.0,
random_layer_initialization_seed=42,
num_trainable_layers=3,
)
tml.train(iterations=6000)
tml.evaluate(50, seed=42, use_val_batch_statistics=True)
tml.evaluate(50, seed=42, use_val_batch_statistics=False)
def run_mini_imagenet():
mini_imagenet_database = MiniImagenetDatabase()
gan_sampling = GANSampling(
database=mini_imagenet_database,
network_cls=MiniImagenetModel,
n=5,
k=1,
k_val_ml=5,
k_val_train=1,
k_val_val=15,
k_val_test=15,
k_test=1,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=1000,
meta_learning_rate=0.001,
report_validation_frequency=50,
log_train_images_after_iteration=250,
number_of_tasks_val=100,
number_of_tasks_test=1000,
clip_gradients=True,
experiment_name='mini_imagenet_interpolation_std_1.2_shift_5',
val_seed=42,
val_test_batch_norm_momentum=0.0)
gan_sampling.train(iterations=60000)
gan_sampling.evaluate(iterations=50,
use_val_batch_statistics=True,
seed=42,
iterations_to_load_from=16000)
def run_mini_imagenet():
mini_imagenet_database = MiniImagenetDatabase()
anil = ANILUnsupervised(
database=mini_imagenet_database,
network_cls=MiniImagenetModel,
n=5,
k_ml=1,
k_val_ml=1,
k_val=1,
k_val_val=15,
k_test=1,
k_val_test=15,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=15000,
meta_learning_rate=0.001,
report_validation_frequency=1000,
log_train_images_after_iteration=1000,
num_tasks_val=100,
clip_gradients=True,
experiment_name='mini_imagenet_unsupervised_permutation',
val_seed=42,
val_test_batch_norm_momentum=0.0,
# set_of_frozen_layers={'conv1', 'conv2', 'conv3', 'conv4', 'bn1', 'bn2', 'bn3', 'bn4', 'dense'}
set_of_frozen_layers={
'conv1', 'conv2', 'conv3', 'conv4', 'bn1', 'bn2', 'bn3', 'bn4'
}
# set_of_frozen_layers={}
)
anil.train(iterations=60000)
anil.evaluate(50, num_tasks=1000, seed=42, use_val_batch_statistics=True)
def run_transfer_learning():
miniimagenet_database = MiniImagenetDatabase()
transfer_learning = TransferLearning(
database=miniimagenet_database,
network_cls=get_network,
n=5,
k_ml=1,
k_val_ml=5,
k_val_val=15,
k_val=1,
k_test=50,
k_val_test=15,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=15000,
meta_learning_rate=0.001,
report_validation_frequency=250,
log_train_images_after_iteration=1000,
num_tasks_val=100,
clip_gradients=True,
experiment_name='fixed_vgg_19',
val_seed=42,
val_test_batch_norm_momentum=0.0,
)
print(f'k: {transfer_learning.k_test}')
transfer_learning.evaluate(50,
num_tasks=1000,
seed=42,
use_val_batch_statistics=True)
def get_train_dataset(self):
database = MiniImagenetDatabase()
dataset = self.get_supervised_meta_learning_dataset(
database.train_folders,
n=self.n,
k=self.k,
k_validation=self.k_val_ml,
meta_batch_size=self.meta_batch_size
)
return dataset
def get_train_dataset(self):
trn_database = MiniImagenetDatabase()
val_database = PlantDiseaseDatabase()
dataset = self.get_separated_supervised_meta_learning_dataset(
trn_database.train_folders,
val_database.train_folders,
n=self.n,
k=self.k_ml,
k_validation=self.k_val_ml,
meta_batch_size=self.meta_batch_size)
return dataset
def run_domain_attention():
train_domain_databases = [
MiniImagenetDatabase(),
OmniglotDatabase(random_seed=47,
num_train_classes=1200,
num_val_classes=100),
DTDDatabase(),
VGGFlowerDatabase()
]
meta_train_domain_databases = [
# AirplaneDatabase(),
FungiDatabase(),
# CUBDatabase(),
]
test_database = FungiDatabase()
da = DomainAttentionUnsupervised(
train_databases=train_domain_databases,
meta_train_databases=meta_train_domain_databases,
database=test_database,
test_database=test_database,
network_cls=None,
image_shape=(84, 84, 3),
n=5,
k_ml=1,
k_val_ml=5,
k_val=1,
k_val_val=15,
k_test=5,
k_val_test=15,
meta_batch_size=4,
num_steps_ml=1,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=5000,
meta_learning_rate=0.001,
report_validation_frequency=1000,
log_train_images_after_iteration=1000,
num_tasks_val=100,
clip_gradients=True,
experiment_name=
'domain_attention_all_frozen_layers_unsupervised_fungi2',
val_seed=42,
val_test_batch_norm_momentum=0.0,
)
print(da.experiment_name)
# da.train(iterations=5000)
da.evaluate(iterations=50, num_tasks=1000, seed=42)
def setUp(self):
def parse_function(example_address):
return example_address
self.parse_function = parse_function
self.omniglot_database = OmniglotDatabase(random_seed=-1,
num_train_classes=1200,
num_val_classes=100)
self.mini_imagenet_database = MiniImagenetDatabase()
self.celeba_database = CelebADatabase()
self.lfw_database = LFWDatabase()
self.euro_sat_database = EuroSatDatabase()
self.isic_database = ISICDatabase()
self.chest_x_ray_database = ChestXRay8Database()
def __init__(self, meta_train_databases=None, *args, **kwargs):
super(CombinedCrossDomainMetaLearning, self).__init__(*args, **kwargs)
if meta_train_databases is None:
self.meta_train_databases = [
MiniImagenetDatabase(),
AirplaneDatabase(),
CUBDatabase(),
OmniglotDatabase(random_seed=47,
num_train_classes=1200,
num_val_classes=100),
DTDDatabase(),
FungiDatabase(),
VGGFlowerDatabase()
]
else:
self.meta_train_databases = meta_train_databases
def run_domain_attention():
train_domain_databases = [
MiniImagenetDatabase(),
OmniglotDatabase(random_seed=47,
num_train_classes=1200,
num_val_classes=100),
DTDDatabase(),
VGGFlowerDatabase()
]
meta_train_domain_databases = [
AirplaneDatabase(),
FungiDatabase(),
CUBDatabase(),
]
test_database = EuroSatDatabase()
ewda = ElementWiseDomainAttention(
train_databases=train_domain_databases,
meta_train_databases=meta_train_domain_databases,
database=test_database,
test_database=test_database,
network_cls=None,
image_shape=(84, 84, 3),
n=5,
k_ml=1,
k_val_ml=5,
k_val=1,
k_val_val=15,
k_test=5,
k_val_test=15,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=15000,
meta_learning_rate=0.001,
report_validation_frequency=1000,
log_train_images_after_iteration=1000,
num_tasks_val=100,
clip_gradients=True,
experiment_name='element_wise_domain_attention',
val_seed=42,
val_test_batch_norm_momentum=0.0,
)
ewda.train(iterations=60000)
ewda.evaluate(iterations=50, num_tasks=1000, seed=14)
def get_train_dataset(self):
databases = [
MiniImagenetDatabase(),
AirplaneDatabase(),
CUBDatabase(),
OmniglotDatabase(random_seed=47, num_train_classes=1200, num_val_classes=100),
DTDDatabase(),
FungiDatabase(),
VGGFlowerDatabase()
]
dataset = self.get_cross_domain_meta_learning_dataset(
databases=databases,
n=self.n,
k_ml=self.k_ml,
k_validation=self.k_val_ml,
meta_batch_size=self.meta_batch_size
)
return dataset
def run_mini_imagenet():
mini_imagenet_database = MiniImagenetDatabase(random_seed=-1)
maml = MAMLAbstractLearner(database=mini_imagenet_database,
network_cls=MiniImagenetModel,
n=5,
k=4,
meta_batch_size=1,
num_steps_ml=5,
lr_inner_ml=0.01,
num_steps_validation=5,
save_after_epochs=500,
meta_learning_rate=0.001,
report_validation_frequency=50,
log_train_images_after_iteration=1000,
least_number_of_tasks_val_test=50,
clip_gradients=True)
maml.train(epochs=30000)
maml.evaluate(50)
def run_omniglot():
omniglot_database = Omniglot84x84Database(
random_seed=47,
num_train_classes=1200,
num_val_classes=100,
)
maml = ModelAgnosticMetaLearningModel(
database=omniglot_database,
test_database=MiniImagenetDatabase(),
network_cls=MiniImagenetModel,
n=5,
k_ml=1,
k_val_ml=5,
k_val=1,
k_val_val=15,
k_test=5,
k_val_test=15,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=15000,
meta_learning_rate=0.001,
report_validation_frequency=1000,
log_train_images_after_iteration=1000,
num_tasks_val=100,
clip_gradients=True,
experiment_name='omniglot_84x84',
val_seed=42,
val_test_batch_norm_momentum=0.0)
maml.train(iterations=60000)
maml.evaluate(iterations=50,
num_tasks=1000,
use_val_batch_statistics=True,
seed=42)
maml.evaluate(iterations=50,
num_tasks=1000,
use_val_batch_statistics=False,
seed=42)
def run_airplane():
test_database = MiniImagenetDatabase()
cdae = CrossDomainAE2(
database=test_database,
batch_size=512,
# domains=('fungi', ),
# domains=('airplane', 'fungi', 'cub', 'dtd', 'miniimagenet', 'omniglot', 'vggflowers'),
domains=('airplane', 'fungi', 'cub', 'dtd', 'omniglot', 'vggflowers'),
# domains=('cub', 'miniimagenet', 'vggflowers'),
# domains=('fungi', 'cub', 'dtd', 'miniimagenet', 'omniglot', 'vggflowers'),
)
experiment_name = 'all_domains_288'
cdae.train(epochs=20, experiment_name=experiment_name)
cdae.evaluate(10,
num_tasks=1000,
k_test=1,
k_val_test=15,
inner_learning_rate=0.001,
experiment_name=experiment_name,
seed=42)
def run_mini_imagenet():
mini_imagenet_database = MiniImagenetDatabase()
n_data_points = 38400
data_points, classes, non_labeled_data_points = sample_data_points(
mini_imagenet_database.train_folders, n_data_points)
features_dataset, n_classes = make_features_dataset_mini_imagenet(
data_points,
classes,
non_labeled_data_points,
# shuffle_buffer_size=n_data_points,
# batch_size=32,
batch_size=16,
shuffle_buffer_size=1000,
)
feature_model = tf.keras.applications.VGG19(weights=None,
classes=n_classes)
feature_model.compile(
loss=tf.keras.losses.CategoricalCrossentropy(),
metrics=['accuracy'],
optimizer=tf.keras.optimizers.Adam(learning_rate=1e-6),
)
def save_call_back(epoch, logs):
if epoch % 100 == 0:
feature_model.save_weights(
filepath=f'./feature_models/feature_model_{epoch}')
# saver_callback = tf.keras.callbacks.LambdaCallback(on_epoch_end=save_call_back)
# feature_model.fit(features_dataset, epochs=101, callbacks=[saver_callback])
feature_model.load_weights(filepath=f'./feature_models/feature_model_100')
# feature_model.evaluate(features_dataset)
# exit()
feature_model = tf.keras.models.Model(
inputs=feature_model.input, outputs=feature_model.layers[24].output)
# print(n_classes)
# feature_model = VariationalAutoEncoderFeature(input_shape=(84, 84, 3), latent_dim=32, n_classes=n_classes)
# feature_model = train_the_feature_model_with_classification(
# feature_model,
# features_dataset,
# n_classes,
# mini_imagenet_database.input_shape
# )
# feature_model = None
# use imagenet
# base_model = tf.keras.applications.VGG19(weights='imagenet')
# feature_model = tf.keras.models.Model(inputs=base_model.input, outputs=base_model.layers[24].output)
sml = SML(
database=mini_imagenet_database,
network_cls=MiniImagenetModel,
n=5,
k=1,
k_val_ml=5,
k_val_val=15,
k_val_test=15,
k_test=1,
meta_batch_size=4,
num_steps_ml=5,
lr_inner_ml=0.05,
num_steps_validation=5,
save_after_iterations=15000,
meta_learning_rate=0.001,
n_clusters=500,
feature_model=feature_model,
# feature_size=288,
feature_size=4096,
input_shape=(224, 224, 3),
preprocess_function=tf.keras.applications.vgg19.preprocess_input,
log_train_images_after_iteration=1000,
least_number_of_tasks_val_test=100,
report_validation_frequency=250,
experiment_name='mini_imagenet_learn_miniimagent_features')
sml.train(iterations=60000)
else:
new_z = tf.stack([
z[0, ...] + (z[(i + 1) % self.n, ...] - z[0, ...]) * 0.3,
z[1, ...] + (z[(i + 2) % self.n, ...] - z[1, ...]) * 0.3,
z[2, ...] + (z[(i + 3) % self.n, ...] - z[2, ...]) * 0.3,
z[3, ...] + (z[(i + 4) % self.n, ...] - z[3, ...]) * 0.3,
z[4, ...] + (z[(i + 0) % self.n, ...] - z[4, ...]) * 0.3,
],
axis=0)
vectors.append(new_z)
return vectors
if __name__ == '__main__':
mini_imagenet_database = MiniImagenetDatabase(input_shape=(224, 224, 3))
shape = (224, 224, 3)
latent_dim = 120
import os
os.environ['TFHUB_CACHE_DIR'] = os.path.expanduser('~/tf_hub')
gan = hub.load("https://tfhub.dev/deepmind/bigbigan-resnet50/1",
tags=[]).signatures['generate']
setattr(gan, 'parser', MiniImagenetParser(shape=shape))
maml_gan = MiniImageNetMAMLBigGan(
gan=gan,
latent_dim=latent_dim,
generated_image_shape=shape,
database=mini_imagenet_database,
network_cls=FiveLayerResNet,
print("Error: Too many arguments")
sys.exit(0)
# CONFIGS
ITERATIONS = 15000
GAN_EPOCHS = 100
N_TASK_EVAL = 100
K = 5
N_WAY = 5
META_BATCH_SIZE = 1
LASIUM_TYPE = "p1"
print("K=",K)
print("N_WAY=",N_WAY)
mini_imagenet_database = MiniImagenetDatabase()
shape = (84, 84, 3)
latent_dim = 512
mini_imagenet_generator = get_generator(latent_dim)
mini_imagenet_discriminator = get_discriminator()
mini_imagenet_parser = MiniImagenetParser(shape=shape)
experiment_name = prefix+str(labeled_percentage)
# for the SSGAN we need to feed the labels, L, when initializing
gan = GAN(
'mini_imagenet',
image_shape=shape,
latent_dim=latent_dim,
database=mini_imagenet_database,
parser=mini_imagenet_parser,
axes[0, i].xaxis.set_label_position('top')
axes[0, i].set_xlabel(title_name)
# fig.suptitle('', fontsize=12, y=1)
plt.savefig(fname=os.path.join(root_folder_to_save, 'all_domains2.pdf'))
plt.show()
if __name__ == '__main__':
tf.config.set_visible_devices([], 'GPU')
root_folder_to_save = os.path.expanduser('~/datasets_visualization/')
if not os.path.exists(root_folder_to_save):
os.mkdir(root_folder_to_save)
databases = (
MiniImagenetDatabase(),
OmniglotDatabase(random_seed=42,
num_train_classes=1200,
num_val_classes=100),
AirplaneDatabase(),
CUBDatabase(),
DTDDatabase(),
FungiDatabase(),
VGGFlowerDatabase(),
# TrafficSignDatabase(),
# MSCOCODatabase(),
# PlantDiseaseDatabase(),
# EuroSatDatabase(),
# ISICDatabase(),
# ChestXRay8Database(),
)
for style_layer_name in style_layers
]
model = tf.keras.models.Model(inputs=vgg19.inputs, outputs=outputs)
def convert_to_activaitons(imgs):
imgs_activations = []
for image in imgs:
image = convert_str_to_img(image)[np.newaxis, ...]
activations = model.predict(image)
imgs_activations.append(activations)
return imgs_activations
DTDDatabase()
d1_imgs = get_all_instances(MiniImagenetDatabase())
d2_imgs = get_all_instances(ISICDatabase())
d3_imgs = get_all_instances(ChestXRay8Database())
d4_imgs = get_all_instances(PlantDiseaseDatabase())
d1_imgs = np.random.choice(d1_imgs, 10, replace=False)
d2_imgs = np.random.choice(d2_imgs, 10, replace=False)
d3_imgs = np.random.choice(d3_imgs, 10, replace=False)
d4_imgs = np.random.choice(d4_imgs, 10, replace=False)
print(d1_imgs)
print(d2_imgs)
print(d3_imgs)
print(d4_imgs)
d1_imgs_activations = convert_to_activaitons(d1_imgs)
