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