def cluster_all_sets():
"""
Cluster the train, test and real_test set and save the output labels to
a file. These labels will then be used for the three networks
"""
#version of the autoencoder to use
version = 2
#make a folder where the labels are saved
labelsave_loc = './clustering_labels'
checkFolders([labelsave_loc])
encoder_loc = f'autoencoder_{version}'
#load and compile the encoder model
encoder = saveLoadModel(f'{encoder_loc}/encoder.h5', save=False, load=True)
encoder.compile(optimizer=keras.optimizers.Adam(lr=0.001), loss='mse')
#extract the filenames
fnames = []
for setname in ['train', 'test', 'real', 'real_test']:
tqdm.write(f'Loading {setname}')
with open(os.path.join(dataset_dir, f'{setname}.json'),
'r') as jsonfile:
labs = json.load(jsonfile)
#extract the filenames
names = []
for lab in labs:
names.append(f'{dataset_dir}/images/{setname}/{lab["filename"]}')
fnames.extend(names)
fnames = np.array(fnames)
print('Number of fnames:', fnames.shape)
#shuffle fnames
np.random.shuffle(fnames)
#load the images
all_imgs = load_images(fnames)
#do dim reduction with encoder
encoder_output = encoder.predict(all_imgs)
#do clustering
cluster_encoder_output(encoder_output,
all_imgs,
labelsave_loc,
labelsave_loc,
labelsave_loc,
fnames,
algorithm='hierarch',
use_tSNE=False)
def develop_autoencoder():
"""
This code is used to develop the autoencoder and the clustering
"""
#### Tweakable parameters
version = 2
#number of images for training (10% will be split off for the test set)
n_images = 0
#number of images for validation
n_val_set = 12000
imageset = 'test'
loadmodel = True
#True: load all validation images. False: load only the encoder output
load_val_imgs = True
output_loc = f'autoencoder_{version}'
#check if the output folder is present and if not, make one
checkFolders([output_loc])
#make folders in the output loc
autoencoder_imgs_output_loc = f'{output_loc}/Autoencoder_imgs'
encoder_clustering_output_loc = f'{output_loc}/Encoder_clustering'
checkFolders([autoencoder_imgs_output_loc, encoder_clustering_output_loc])
#### Train the network
encoder, autoencoder, val_images, fnames = train_or_load_model(
n_images, n_val_set, loadmodel=loadmodel, load_val_imgs=load_val_imgs)
#### now make some predictions
run_predictions(encoder,
autoencoder,
val_images,
fnames,
output_loc,
encoder_clustering_output_loc,
autoencoder_imgs_output_loc,
load_val_imgs=load_val_imgs)
def __init__(self, batch_size, epochs, version, load_model, reps = 4):
#### tweakable parameters
self.batch_size = batch_size
self.epochs = epochs
self.version = version
self.load_model = load_model
self.clip_range=(0,255)
self.cluster = 2
self.dim = (160, 256,1)
#size of the test set as a fraction of the total amount of data
self.test_size = 0.02
self.latent_dim = 100
self.hidden_dim = 100
#dropout percentage
self.dropout = 0.3
self.learning_rate_g = 0.0002
self.learning_rate_d = 0.0002
self.learning_rate_decay = 0.0001
self.reps = reps
self.epochs = epochs
#### constant parameters
# self.dataset_loc = '../../speed'
self.dataset_loc = '/data/s1530194/speed'
self.image_root = os.path.join(self.dataset_loc, 'images', 'train')
# self.loss_g=keras.losses.mean_squared_error
# self.loss_g=keras.losses.logcosh
# self.loss_g=generator_loss
self.loss_g=keras.losses.binary_crossentropy
# self.loss_d=keras.losses.logcosh
self.loss_d=keras.losses.binary_crossentropy
#this folder should already exist
self.autoencoder_labelloc = 'autoencoder_2/Encoder_clustering'
self.output_loc = f'./Version_CGAN_{self.version}/'
self.model_summary_name = f'model_summlisary_v{self.version}.txt'
self.cgan_imgoutput = './cgantest'
#### initialize some stuff
#check if folders are present and make them if necessary
checkFolders([self.output_loc, self.cgan_imgoutput])
self.gen_output = OutputResults(self)
# self.sess = sess
self.params = {'dim': self.dim,
'batch_size': self.batch_size,
'latent_dim': self.latent_dim,
'shuffle': True,
'seed': 1,
'clip_range': self.clip_range}
self.dataloader()
if self.load_model < 0:
self.generator = model_generator(
latent_dim = self.latent_dim,
input_shape = self.dim,
hidden_dim = self.hidden_dim)
self.generator.compile(
loss = self.loss_g,
optimizer = Adam(
lr = self.learning_rate_g,
decay = self.learning_rate_decay,
beta_1=0,
beta_2=0.9),
metrics = ['accuracy'])
self.discriminator = model_discriminator(
input_shape = self.dim,
hidden_dim = self.hidden_dim)
self.discriminator.compile(
loss = self.loss_d,
optimizer = Adam(
lr = self.learning_rate_d,
decay = self.learning_rate_decay,
beta_1=0,
beta_2=0.9),
metrics = ['accuracy'])
self.total = self.model_total()
self.total.compile(
loss = self.loss_g,
optimizer = Adam(
lr = self.learning_rate_g,
decay = self.learning_rate_decay,
beta_1=0,
beta_2=0.9),
metrics = ['accuracy'])
else:
print(self.load_model)
self.generator = self.gen_output.saveLoadModel(f'Version_CGAN_{self.load_model}/generator_v{self.load_model}.h5', load=True,loss=self.loss_d)
self.discriminator = self.gen_output.saveLoadModel(f'Version_CGAN_{self.load_model}/discriminator_v{self.load_model}.h5', load=True,loss=self.loss_g)
self.total = self.model_total()
self.total.compile(
loss = self.loss_g,
optimizer = Adam(
lr = self.learning_rate_g,
decay = self.learning_rate_decay,
beta_1=0.5),
metrics = ['accuracy'])
plot_model(self.generator, to_file = f'{self.output_loc}generator_arch_v{self.version}.png', show_shapes = True, show_layer_names = True)
plot_model(self.discriminator, to_file = f'{self.output_loc}discriminator_arch_v{self.version}.png', show_shapes = True, show_layer_names = True)
plot_model(self.total, to_file = f'{self.output_loc}total_arch_v{self.version}.png', show_shapes = True, show_layer_names = True)
def __init__(self, batch_size, epochs, version, load_model, reps = 4):
#### tweakable parameters
self.batch_size = batch_size
self.epochs = epochs
self.version = version
self.load_model = load_model
self.dim = (128, 256,1)
#size of the test set as a fraction of the total amount of data
self.test_size = 0.02
self.latent_dim = 100
self.hidden_dim = 100
#dropout percentage
self.dropout = 0.3
self.learning_rate_g = 0.02
self.learning_rate_d = 0.0002
self.learning_rate_decay = 0.0
self.reps = reps
self.epochs = epochs
#### constant parameters
# self.dataset_loc = '../../speed'
self.dataset_loc = 'speed/speed/'
self.loss_g=keras.losses.mean_squared_error
# self.loss_g=keras.losses.logcosh
self.loss_d=keras.losses.logcosh
# self.loss=keras.losses.binary_crossentropy
self.output_loc = f'./Version_CGAN_{self.version}/'
self.model_summary_name = f'model_summlisary_v{self.version}.txt'
#### initialize some stuff
#check if folders are present and make them if necessary
checkFolders([self.output_loc])
self.gen_output = OutputResults(self)
# self.sess = sess
self.params = {'dim': self.dim,
'batch_size': self.batch_size,
'latent_dim': self.latent_dim,
'shuffle': True,
'seed': 1}
self.dataloader()
if self.load_model < 0:
self.generator = model_generator(
latent_dim = self.latent_dim,
input_shape = self.dim,
hidden_dim = self.hidden_dim)
self.generator.compile(
loss = lambda x,y: -self.loss_g(x,y),
optimizer = Adam(
lr = self.learning_rate_g,
decay = self.learning_rate_decay,
beta_1=0.5),
metrics = ['accuracy'])
self.discriminator = model_discriminator(
input_shape = self.dim,
hidden_dim = self.hidden_dim)
self.discriminator.compile(
loss = self.loss_d,
optimizer = Adam(
lr = self.learning_rate_d,
decay = self.learning_rate_decay,
beta_1=0.5),
metrics = ['accuracy'])
self.total = self.model_total()
self.total.compile(
loss = lambda x,y: -self.loss_g(x,y),
optimizer = Adam(
lr = self.learning_rate_g,
decay = self.learning_rate_decay,
beta_1=0.5),
metrics = ['accuracy'])
else:
print(self.load_model)
self.generator = self.gen_output.saveLoadModel(f'Version_CGAN_{self.load_model}/generator_v{self.load_model}.h5', load=True)
self.discriminator = self.gen_output.saveLoadModel(f'Version_CGAN_{self.load_model}/discriminator_v{self.load_model}.h5', load=True)
self.total = self.model_total()
self.total.compile(
loss = self.loss,
optimizer = Adam(
lr = self.learning_rate_g,
decay = self.learning_rate_decay,
beta_1=0.5),
metrics = ['accuracy'])
plot_model(self.generator, to_file = f'{self.output_loc}generator_arch_v{self.version}.png', show_shapes = True, show_layer_names = True)
plot_model(self.discriminator, to_file = f'{self.output_loc}discriminator_arch_v{self.version}.png', show_shapes = True, show_layer_names = True)
plot_model(self.total, to_file = f'{self.output_loc}total_arch_v{self.version}.png', show_shapes = True, show_layer_names = True)
def __init__(self, batch_size, epochs, version, load_model, reps=4):
#### tweakable parameters
self.batch_size = batch_size
self.epochs = epochs
self.version = version
self.load_model = load_model
self.dim = (200, 320, 1)
#size of the test set as a fraction of the total amount of data
self.test_size = 0.1
self.latent_dim = 64
self.hidden_dim = 64
#dropout percentage
self.dropout = 0.3
self.learning_rate = 0.001
self.learning_rate_decay = 0
self.reps = reps
self.epochs = epochs
#### constant parameters
# self.dataset_loc = '../../speed'
self.dataset_loc = 'speed/speed/'
self.output_loc = f'./Version_CGAN_{self.version}/'
self.model_summary_name = f'model_summlisary_v{self.version}.txt'
#### initialize some stuff
#check if folders are present and make them if necessary
checkFolders([self.output_loc])
self.gen_output = OutputResults(self)
# self.sess = sess
self.params = {
'dim': self.dim,
'batch_size': self.batch_size,
'latent_dim': self.latent_dim,
'shuffle': True,
'seed': 1
}
self.dataloader()
if self.load_model < 0:
print(self.learning_rate)
self.generator = model_generator(latent_dim=self.latent_dim,
input_shape=self.dim,
hidden_dim=self.hidden_dim)
self.discriminator = model_discriminator(
input_shape=self.dim, hidden_dim=self.hidden_dim)
self.total = model_total(latent_dim=self.latent_dim,
input_shape=self.dim,
hidden_dim=self.hidden_dim)
else:
print(self.load_model)
self.generator = self.gen_output.saveLoadModel(
f'Version_CGAN_{self.load_model}/generator_v{self.load_model}.h5',
load=True)
self.discriminator = self.gen_output.saveLoadModel(
f'Version_CGAN_{self.load_model}/discriminator_v{self.load_model}.h5',
load=True)
self.total = self.gen_output.saveLoadModel(
f'Version_CGAN_{self.load_model}/total_v{self.load_model}.h5',
load=True)
imgsize = (256, 160) #(512, 320)
#version of the network
version = int(args.version)
#fraction of available images to use for training. We cannot define a
#number of images as this depends on the cluster label
use_frac = 1
#### Fixed parameters
#location of the dataset
dataset_dir = '/data/s1530194/speed'
# Creates a new JSON file with bbox training label even if one already exists
recreate_json = False
#where to output the results
output_loc = f'cropping_network_development/bbox_jw_{version}'
#check if the output folder is present and if not, make one
checkFolders([output_loc])
#location where the cluster labels are saved
clusterlabels_loc = 'clustering_labels/hierarch_cluster_labels.npy'
#name for the model
modelname = f'croppermodel{version}_c{target_label}.h5'
#init
create_bbox_json()
settype = 'train'
train_dir = os.path.join(dataset_dir, f'images/{settype}')
#### Make and compile a model, load data and train
bb_model = make_model(loadmodel=False) #can also instead load a model
bb_model.compile(optimizer=keras.optimizers.Adam(lr=0.001),
loss='mean_absolute_error') #mse