def train_model(self,epochs,batch_size=None,directory='imgs',images_per_epoch=4): if batch_size is None: batch_size = self.batch_size sum_writer_loss = self.define_loss_tensorboard() avg_vae_loss = tf.keras.metrics.Mean() start_time = time.time() batch_per_epoch = int(self.train_dataset.shape[0] / batch_size) # calculate the number of training iterations n_steps = batch_per_epoch * epochs try: epoch = int(open('current_epoch.txt').read()) except: epoch = 0 for step_i in range(n_steps): train_x = self.generate_real_samples(batch_size) loss = self.compute_apply_gradients(train_x) avg_vae_loss(loss) if((step_i % (n_steps / epochs)) == 0): epoch += 1 gen_images = self.sample(self.generative_net.seed,False) data_access.store_images_seed(directory,gen_images[:images_per_epoch],epoch) data_access.write_current_epoch('current_epoch',epoch=epoch) data_access.print_training_output_simple_loss(step_i,n_steps,loss) with sum_writer_loss.as_default(): tf.summary.scalar('loss_vae', avg_vae_loss.result(),step=self.optimizer.iterations) end_time = time.time() data_access.print_training_time(start_time,end_time,None)
def generate_images(self,number_of_samples,directory): seed = tf.random.normal([number_of_samples, self.random_noise_size]) images = self.generator(seed) if self.classifier is not None: predictions = self.classifier(data_access.normalize(data_access.de_standardize(images))) data_access.produce_generate_figure(directory,images,predictions,class_names) else: data_access.store_images_seed(directory,images,'gen_images','gan')
def train_model(self,epoches,n_critic=5,class_type=0,directory = 'imgs'): """ Train model for an amount of epochs :param epoches: - cycles of training over all dataset :param n_critic: - number of times critic trains more than generator :param class_type: - class number: converge generated data to this class :param directory: - directory where images will be placed during training """ class_type = [0 for i in range(10)] class_type[0] = 0.5 class_type[1] = 0.5 batch_per_epoch = int(self.train_dataset.shape[0] / self.batch_size) # calculate the number of training iterations n_steps = batch_per_epoch * epoches # calculate the size of half a batch of samples half_batch = int(self.batch_size / 2) sum_writer_loss = self.define_loss_tensorboard() #self.classifier_m.load_local_model() avg_loss_critic = tf.keras.metrics.Mean() avg_loss_gen = tf.keras.metrics.Mean() try: epoch = int(open('current_epoch.txt').read()) except: epoch = 0 n_dif_images = 4 start_time = time.time() for i in range(n_steps): for _ in range(n_critic): # get randomly selected 'real' samples X_real, y_real = self.generate_real_samples(half_batch) # generate 'fake' examples X_fake, y_fake = self.generate_fake_samples(self.random_noise_size, half_batch) # update critic model weights c_loss = self.training_step_critic(X_real,X_fake, y_real,y_fake,half_batch) avg_loss_critic(c_loss) gen_loss, matched_images, gen_images = self.training_step_generator(self.random_noise_size,class_type) avg_loss_gen(gen_loss) data_access.print_training_output(i,n_steps, avg_loss_critic.result(),avg_loss_gen.result()) if((i % (n_steps / epoches)) == 0): data_access.store_images_seed(directory,gen_images[:n_dif_images],epoch) with sum_writer_loss.as_default(): tf.summary.scalar('loss_gen', avg_loss_gen.result(),step=self.generator.optimizer.iterations) tf.summary.scalar('avg_loss_critic', avg_loss_critic.result(),step=self.critic.optimizer.iterations) epoch += 1 if((epoch % 10) == 0): self.generator.save_weights('/content/weights/g_weights/g_weights',save_format='tf') self.critic.save_weights('/content/weights/c_weights/c_weights',save_format='tf') with open('current_epoch.txt','w') as ofil: ofil.write(f'{epoch}') print('Saved epoch ',epoch) data_access.create_collection(epoches,n_dif_images,directory) data_access.print_training_time(start_time,time.time(),None)
def train_model(self,epoches,n_critic=5,class_type=0,directory = 'imgs',n_img_per_epoch=4): """ Train model for an amount of epochs :param epoches: - cycles of training over all dataset :param n_critic: - number of times critic trains more than generator :param class_type: - it can be a number if class convergence is wanted or a probability distribution (array) discribing the probabilities for each class Example: class convergence(when there are 5 classes): 0 class divergence(when there are 5 classes): [0.25, 0.25, 0.25, 0.25, 0.0] :param directory: - directory where images will be placed during training :n_img_per_epoch: - number of images stored per epoch, while training """ batch_per_epoch = int(self.train_dataset.shape[0] / self.batch_size) # calculate the number of training iterations n_steps = batch_per_epoch * epoches # calculate the size of half a batch of samples half_batch = int(self.batch_size / 2) sum_writer_loss = self.define_loss_tensorboard() avg_loss_critic = tf.keras.metrics.Mean() avg_loss_gen = tf.keras.metrics.Mean() try: epoch = int(open('current_epoch.txt').read()) except: epoch = 0 start_time = time.time() print(self.model_parameters) for i in range(n_steps): for _ in range(n_critic): # get randomly selected 'real' samples X_real, y_real = self.generate_real_samples(half_batch) # generate 'fake' examples X_fake, y_fake = self.generate_fake_samples(self.random_noise_size, half_batch) # update critic model weights c_loss = self.training_step_critic(X_real,X_fake, y_real,y_fake,half_batch) avg_loss_critic(c_loss) gen_loss, matched_images, gen_images = self.training_step_generator(self.random_noise_size,class_type) avg_loss_gen(gen_loss) data_access.print_training_output(i,n_steps, avg_loss_critic.result(),avg_loss_gen.result()) if((i % (n_steps / epoches)) == 0): data_access.store_images_seed(directory,gen_images[:n_img_per_epoch],epoch) with sum_writer_loss.as_default(): tf.summary.scalar('loss_gen', avg_loss_gen.result(),step=self.generator.optimizer.iterations) tf.summary.scalar('avg_loss_critic', avg_loss_critic.result(),step=self.critic.optimizer.iterations) epoch += 1 if((epoch % 1) == 0): self.generator.save_weights('weights/g_weights/g_weights',save_format='tf') self.critic.save_weights('weights/c_weights/c_weights',save_format='tf') data_access.write_current_epoch(filename='current_epoch',epoch=epoch) data_access.create_collection(epoches,n_img_per_epoch,directory) data_access.print_training_time(start_time,time.time(),self.model_parameters)
def train_model(self, epoches, n_critic=5, noise_size=100, class_type=5): batch_per_epoch = int(self.train_dataset.shape[0] / self.batch_size) # calculate the number of training iterations n_steps = batch_per_epoch * epoches # calculate the size of half a batch of samples half_batch = int(self.batch_size / 2) sum_writer_loss = self.define_loss_tensorboard() self.classifier_m.load_local_model() avg_loss_critic = tf.keras.metrics.Mean() avg_loss_gen = tf.keras.metrics.Mean() epoch = 0 n_dif_images = 4 directory = 'imgs' start_time = time.time() for i in range(n_steps): for _ in range(n_critic): # get randomly selected 'real' samples X_real, y_real = self.generate_real_samples(half_batch) # generate 'fake' examples X_fake, y_fake = self.generate_fake_samples( noise_size, half_batch) # update critic model weights c_loss = self.training_step_critic(X_real, X_fake, y_real, y_fake, half_batch) avg_loss_critic(c_loss) gen_loss, matched_images, gen_images = self.training_step_generator( noise_size, class_type) avg_loss_gen(gen_loss) data_access.print_training_output(i, n_steps, avg_loss_critic.result(), avg_loss_gen.result()) if ((i % (n_steps / epoches)) == 0): data_access.store_images_seed(directory, gen_images[:n_dif_images], epoch) with sum_writer_loss.as_default(): tf.summary.scalar('loss_gen', avg_loss_gen.result(), step=self.generator.optimizer.iterations) tf.summary.scalar('avg_loss_critic', avg_loss_critic.result(), step=self.critic.optimizer.iterations) epoch += 1 data_access.create_collection(epoches, n_dif_images, directory) print('Time elapse {}'.format(time.time() - start_time))
def train_model(self, epochs=None, batch_size=None, images_per_epoch=4, directory='imgs'): if epochs is None: epochs = self.params['epochs'] if batch_size is None: batch_size = self.params['batchsz'] batch_per_epoch = int(self.train_dataset.shape[0] / batch_size) # calculate the number of training iterations n_steps = batch_per_epoch * epochs start_time = time.time() try: epoch = int(open('current_epoch.txt').read()) except: epoch = 0 for step_i in range(n_steps): train_x = self.generate_real_samples(batch_size) inf_loss, gen_loss = self.compute_apply_gradients(train_x) data_access.print_training_output_vae(step_i, n_steps, inf_loss, gen_loss) if ((step_i % (n_steps / epochs)) == 0): epoch += 1 gen_images = self.sample(self.generative_net.seed) data_access.store_images_seed(directory, gen_images[:images_per_epoch], epoch) self.generative_net.save_weights('weights/g_weights/g_weights', save_format='tf') self.inference_net.save_weights('weights/i_weights/i_weights', save_format='tf') data_access.write_current_epoch(filename='current_epoch', epoch=epoch) end_time = time.time() data_access.print_training_time(start_time, end_time, self.params)
def generate_images(self, number_of_samples=5, directory="imgs"): random_vector_for_generation = tf.random.normal( shape=[number_of_samples, self.latent_dim]) images = self.sample(random_vector_for_generation, False) data_access.store_images_seed(directory, images, 'None', 'vae')
def train_model(self, epoches, b_size, n_critic=5, class_type=0, directory='imgs', n_img_per_epoch=4): """ Train model for an amount of epochs :param epoches: - cycles of training over all dataset :param n_critic: - number of times critic trains more than generator :param class_type: - class number: converge generated data to this class :param directory: - directory where images will be placed during training """ batch_per_epoch = int(self.train_dataset.shape[0] / self.batch_size) # calculate the number of training iterations n_steps = batch_per_epoch * epoches # calculate the size of half a batch of samples half_batch = int(self.batch_size / 2) sum_writer_loss = self.define_loss_tensorboard() #self.classifier_m.load_local_model() avg_loss_critic = tf.keras.metrics.Mean() avg_loss_gen = tf.keras.metrics.Mean() try: epoch = int(open('current_epoch.txt').read()) except: epoch = 0 start_time = time.time() for i in range(n_steps): self.update_fadein([self.generator, self.critic], i, n_steps) for _ in range(n_critic): # get randomly selected 'real' samples X_real, y_real = self.generate_real_samples(half_batch) # generate 'fake' examples X_fake, y_fake = self.generate_fake_samples( self.random_noise_size, half_batch) # update critic model weights tf.config.experimental_run_functions_eagerly(True) c_loss = self.training_step_critic(X_real, X_fake, y_real, y_fake, half_batch) avg_loss_critic(c_loss) gen_loss, matched_images, gen_images = self.training_step_generator( self.random_noise_size, class_type) avg_loss_gen(gen_loss) data_access.print_training_output(i, n_steps, avg_loss_critic.result(), avg_loss_gen.result()) if ((i % (n_steps / epoches)) == 0): data_access.store_images_seed(directory, gen_images[:n_img_per_epoch], epoch) with sum_writer_loss.as_default(): tf.summary.scalar('loss_gen', avg_loss_gen.result(), step=self.generator.optimizer.iterations) tf.summary.scalar('avg_loss_critic', avg_loss_critic.result(), step=self.critic.optimizer.iterations) epoch += 1 if ((epoch % 1) == 0): self.generator.save_weights('weights/g_weights/g_weights', save_format='tf') self.critic.save_weights('weights/c_weights/c_weights', save_format='tf') data_access.write_current_epoch(filename='current_epoch', epoch=epoch) print('Time elapse {}'.format(time.time() - start_time))