def pretrain_gen(self): """ pretrain the generator """ util.generate_samples(self.target_lstm, self.batch_size, self.sequence_len, self.generate_sum, self.real_file) gen_data = GenData(self.real_file) gen_data_loader = DataLoader(gen_data, batch_size=self.batch_size, shuffle=True, num_workers=8) gen_criterion = util.to_cuda( nn.CrossEntropyLoss(size_average=False, reduce=True)) gen_optim = torch.optim.Adam(self.generator.parameters(), self.lr) print('\nPretrain generator......') for epoch in range(self.pre_gen_epochs): train_loss = self.train_epoch(self.generator, gen_data_loader, gen_criterion, gen_optim) util.generate_samples(self.generator, self.batch_size, self.sequence_len, self.generate_sum, self.eval_file) eval_data = GenData(self.eval_file) eval_data_loader = DataLoader(eval_data, batch_size=self.batch_size, shuffle=True, num_workers=8) eval_loss = self.eval_epoch(self.target_lstm, eval_data_loader, gen_criterion) print( 'epoch: {:4d}, train_loss: {:6.4f}, eval_loss: {:6.4f}'.format( epoch, train_loss, eval_loss))
def run_test(n_samples=1000, grad=False, show_plot=True, save_plot=False, data_seed=0, model_seed=1): torch.set_grad_enabled(grad) torch.manual_seed(data_seed) train_input, train_target = util.generate_samples(n_samples) test_input, test_target = util.generate_samples(n_samples) train_results = dict() test_results = dict() for name, (model, criterion, optimizer, learning_rate) in tests.items(): torch.manual_seed(model_seed) model = model() criterion = criterion() optimizer = optimizer(model.parameters, learning_rate=learning_rate) print(name) print('Train ' + ('-' * (42 - len('Train ')))) train_results[name] = batch_train(model, criterion, optimizer, train_input, train_target, verbose=True, nb_errors=True) model.eval() print('Test ' + ('-' * (42 - len('Test ')))) test_results[name] = batch_test(model, criterion, test_input, test_target, verbose=True, nb_errors=True) print('=' * 42) print('') if show_plot: import matplotlib.pyplot as plt train_errors = { name: [ 100 * compute_nb_errors(predictions.argmax(1), train_target) / len(train_target) for _, predictions in values ] for name, values in train_results.items() } [ plt.plot(range(len(values)), values, label=name) for name, values in train_errors.items() ] plt.legend() plt.xlim((0, 100)) plt.xlabel('Epoch') plt.ylabel('Error Percentage') if save_plot: plt.savefig('train_error.png') plt.show()
def pretrain_dis(self): dis_criterion = util.to_cuda(nn.BCEWithLogitsLoss(size_average=False)) dis_optim = torch.optim.Adam(self.discriminator.parameters(), self.lr) print '\nPretrain discriminator......' for epoch in range(self.pre_dis_epochs): util.generate_samples(self.generator, self.batch_size, self.sequence_len, self.generate_sum, self.fake_file) dis_data = DisData(self.real_file, self.fake_file) dis_data_loader = DataLoader(dis_data, batch_size=self.batch_size, shuffle=True, num_workers=8) loss = self.train_epoch(self.discriminator, dis_data_loader, dis_criterion, dis_optim) print 'epoch: [{0:d}], loss: [{1:.4f}]'.format(epoch, loss)
def pretrain_gen(self): util.generate_samples(self.target_lstm, self.batch_size, self.sequence_len, self.generate_sum, self.real_file) gen_data = GenData(self.real_file) gen_data_loader = DataLoader(gen_data, batch_size=self.batch_size, shuffle=True, num_workers=8) gen_criterion = util.to_cuda(nn.CrossEntropyLoss(size_average=False, reduce=True)) gen_optim = torch.optim.Adam(self.generator.parameters(), self.lr) print '\nPretrain generator......' for epoch in range(self.pre_gen_epochs): loss = self.train_epoch(self.generator, gen_data_loader, gen_criterion, gen_optim) print 'epoch: [{0:d}], model loss: [{1:.4f}]'.format(epoch, loss) util.generate_samples(self.generator, self.batch_size, self.sequence_len, self.generate_sum, self.eval_file) eval_data = GenData(self.eval_file) eval_data_loader = DataLoader(eval_data, batch_size=self.batch_size, shuffle=True, num_workers=8) loss = self.eval_epoch(self.target_lstm, eval_data_loader, gen_criterion) print 'epoch: [{0:d}], true loss: [{1:.4f}]'.format(epoch, loss)
def train_gan(self, backend): rollout = Rollout(self.generator, self.discriminator, self.update_rate) print('\nStart Adeversatial Training......') gen_optim, dis_optim = torch.optim.Adam(self.generator.parameters(), self.lr), torch.optim.Adam(self.discriminator.parameters(), self.lr) dis_criterion = util.to_cuda(nn.BCEWithLogitsLoss(size_average=False)) gen_criterion = util.to_cuda(nn.CrossEntropyLoss(size_average=False, reduce=True)) for epoch in range(self.gan_epochs): start = time.time() for _ in range(1): samples = self.generator.sample(self.batch_size, self.sequence_len) # (batch_size, sequence_len) zeros = util.to_var(torch.zeros(self.batch_size, 1).long()) # (batch_size, 1) inputs = torch.cat([samples, zeros], dim=1)[:, :-1] # (batch_size, sequence_len) rewards = rollout.reward(samples, 16) # (batch_size, sequence_len) rewards = util.to_var(torch.from_numpy(rewards)) logits = self.generator(inputs) # (None, vocab_size, sequence_len) pg_loss = self.pg_loss(logits, samples, rewards) gen_optim.zero_grad() pg_loss.backward() gen_optim.step() print 'generator updated via policy gradient......' if epoch % 10 == 0: util.generate_samples(self.generator, self.batch_size, self.sequence_len, self.generate_sum, self.eval_file) eval_data = GenData(self.eval_file) eval_data_loader = DataLoader(eval_data, batch_size=self.batch_size, shuffle=True, num_workers=8) loss = self.eval_epoch(self.target_lstm, eval_data_loader, gen_criterion) print 'epoch: [{0:d}], true loss: [{1:.4f}]'.format(epoch, loss) for _ in range(1): util.generate_samples(self.generator, self.batch_size, self.sequence_len, self.generate_sum, self.fake_file) dis_data = DisData(self.real_file, self.fake_file) dis_data_loader = DataLoader(dis_data, batch_size=self.batch_size, shuffle=True, num_workers=8) for _ in range(1): loss = self.train_epoch(self.discriminator, dis_data_loader, dis_criterion, dis_optim) print 'discriminator updated via gan loss......' rollout.update_params() end = time.time() print 'time: [{:.3f}s/epoch] in {}'.format(end-start, backend)
def evaluate(self, ggen: GeometricVideoGenerator, cgen: ColorVideoGenerator): """ Evaluate generated samples using evaluation metrics for GANs. Currently supporing InceptionScore, Frechet Inception Distance. Parameters ---------- ggen : nn.Module The geometric information video generator. cgen : nn.Module The color video generator. """ verbose = True # generate fake samples _, xc = util.generate_samples( ggen, cgen, self.eval_num_samples, self.eval_batchsize, with_geo=False, desc=f"sampling {self.eval_num_samples} videos for evalaution", verbose=verbose, ) ggen, cgen = ggen.to("cpu"), cgen.to("cpu") # save them in a temporary directory temp = tempfile.TemporaryDirectory() temp_dir = Path(temp.name) save_paths = [temp_dir / f"{i}.mp4" for i in range(self.eval_num_samples)] dataio.write_videos_pararell(xc, save_paths) # dataset directory dataset_dir = Path(self.dataloader.dataset.root_path) / "color" batchsize = 100 for m in self.eval_metrics: if m == "is": score = evan.score.compute_inception_score( temp_dir, batchsize=batchsize, verbose=verbose ) elif m == "fid": score = evan.score.compute_frechet_distance( temp_dir, dataset_dir, batchsize=batchsize, verbose=verbose ) elif m == "prd": score = evan.score.compute_precision_recall( temp_dir, dataset_dir, batchsize=batchsize, verbose=verbose ) self.logger.update(m, score) temp.cleanup() ggen, cgen = ggen.to(self.device), cgen.to(self.device)
def main(): parser = argparse.ArgumentParser() parser.add_argument("result_dir", type=Path) parser.add_argument("iteration", type=int) parser.add_argument("save_dir", type=Path) parser.add_argument("--n_samples", "-n", type=int, default=10000) parser.add_argument("--batchsize", "-b", type=int, default=10) args = parser.parse_args() # read config file with open(args.result_dir / "config.yml") as f: configs = yaml.load(f, Loader=yaml.FullLoader) # load model with weights ggen = load_model( args.result_dir / "models" / "ggen_model.pth", args.result_dir / "models" / f"ggen_params_{args.iteration:05d}.pth", ) cgen = load_model( args.result_dir / "models" / "cgen_model.pth", args.result_dir / "models" / f"cgen_params_{args.iteration:05d}.pth", ) # make directories color_dir = args.save_dir / "color" color_dir.mkdir(parents=True, exist_ok=True) geo_dir = args.save_dir / configs["geometric_info"]["name"] geo_dir.mkdir(parents=True, exist_ok=True) # generate samples for offset in tqdm(range(0, args.n_samples, args.batchsize)): xg, xc = util.generate_samples( ggen, cgen, args.batchsize, args.batchsize, verbose=False ) # (B, C, T, H, W) -> (B, T, H, W, C) xg, xc = xg.transpose(0, 2, 3, 4, 1), xc.transpose(0, 2, 3, 4, 1) dataio.write_videos_pararell( xg, [geo_dir / "{:06d}.mp4".format(offset + i) for i in range(len(xg))] ) dataio.write_videos_pararell( xc, [color_dir / "{:06d}.mp4".format(offset + i) for i in range(len(xc))] )
def test_generate_samples(self): IMAGE_SIZE = 64 VIDEO_LENGTH = 16 for geometric_info, ch in zip(["depth", "optical-flow"], [1, 2]): # init ggen inputs = { "dim_z_content": 30, "dim_z_motion": 10, "channel": ch, "geometric_info": geometric_info, "video_length": VIDEO_LENGTH, } ggen = GeometricVideoGenerator(**inputs) # init cgen inputs = { "in_ch": ch, "dim_z": 10, "geometric_info": geometric_info } cgen = ColorVideoGenerator(**inputs) # generate cases = [(3, 1), (3, 2), (3, 4)] for num, batchsize in cases: xg, xc = generate_samples(ggen, cgen, num, batchsize) # xg self.assertTrue(isinstance(xg, np.ndarray)) self.assertEqual(xg.dtype, np.uint8) self.assertEqual(len(xg), num) s = (num, 3, VIDEO_LENGTH, IMAGE_SIZE, IMAGE_SIZE) self.assertEqual(xg.shape, s) # xc self.assertTrue(isinstance(xc, np.ndarray)) self.assertEqual(xc.dtype, np.uint8) self.assertEqual(len(xc), num) s = (num, 3, VIDEO_LENGTH, IMAGE_SIZE, IMAGE_SIZE) self.assertEqual(xc.shape, s)
def main(): assert sys.argv[1].endswith(".json"), \ "Need to specify the config.json file." parser = HfArgumentParser(TrainingConfig) args = parser.parse_json_file(os.path.abspath(sys.argv[1]))[0] if args.server: config = AutoConfig.from_pretrained(args.model_name_or_path) tokenizer = BertTokenizer.from_pretrained(args.model_name_or_path) else: config = AutoConfig.from_pretrained(args.model_name_or_path, cache_dir=args.cached_dir) tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, cache_dir=args.cached_dir) # specify configuration config.num_labels = tokenizer.vocab_size config.type_vocab_size = args.type_vocab_size config.eos_token_id = 102 config.return_dict = True model = MODEL_CLASSES[args.model_name_or_path](config) state_dict = torch.load(os.path.join(args.model_name_or_path, 'pytorch_model.bin')) \ if args.server else load_cached_hf_parameters(args.model_name_or_path, args.cached_dir) # if 'roberta' in args.model_name_or_path: # state_dict.pop('roberta.embeddings.token_type_embeddings.weight') model.load_state_dict(state_dict, strict=False) model.tie_weights() if args.do_test: from util import generate_samples, PROMPT_TEXT generate_samples( model, tokenizer, PROMPT_TEXT, ) if args.task == 'thuc': from bert_seq2seq.THUCNews import collate_fn import datasets if args.thuc_cache_dir and os.path.exists( args.thuc_cache_dir[0]) and os.path.exists( args.thuc_cache_dir[1]): tokenized_train = datasets.load_from_disk(args.thuc_cache_dir[0]) tokenized_test = datasets.load_from_disk(args.thuc_cache_dir[1]) else: dataset = datasets.load_dataset('thuc_datasets.py', data_path=args.thuc_data_path, split='train') dataset = dataset.train_test_split(test_size=0.05, seed=42) train_dataset = dataset['train'] test_dataset = dataset['test'] def tokenize(examples): return tokenizer(examples['content'], examples['title']) tokenized_train = train_dataset.map( tokenize, remove_columns=train_dataset.column_names, batched=True, num_proc=args.dataloader_num_workers, ) tokenized_test = test_dataset.map( tokenize, remove_columns=test_dataset.column_names, batched=True, num_proc=args.dataloader_num_workers, ) tokenized_train.save_to_disk('thuc.train.cache') tokenized_test.save_to_disk('thuc.test.cache') trainer = TextGenTrainer( model=model, args=args, train_dataset=tokenized_train, data_collator=collate_fn, tokenizer=tokenizer, ) elif args.task == 'debatepedia': qsumm_dataset = QsummDataSet(args.qsumm_data_path, tokenizer) args.evaluation_strategy = 'epoch' trainer = Trainer( model=model, args=args, train_dataset=qsumm_dataset.train, eval_dataset=qsumm_dataset.valid, tokenizer=tokenizer, ) if args.do_train: trainer.train() trainer.save_model()
def log_samples( self, ggen: GeometricVideoGenerator, cgen: ColorVideoGenerator, iteration: int ): """ Log generator samples into TensorBoard. Parameters ---------- ggen : GeometricVideoGenerator The geometric information video generator. cgen : ColorVideoGenerator The color video generator. iteration : int Iteration count. """ ggen.eval() cgen.eval() # fake samples # generate sampels (dtype: int, axis: (B, C, T, H, W)) xg_fake, xc_fake = util.generate_samples(ggen, cgen, self.num_log, self.num_log) # log histgram of fake samples self.logger.tf_log_histgram(xg_fake[:, 0], "geospace_fake", iteration) self.logger.tf_log_histgram(xc_fake[:, 0], "colorspace_fake", iteration) # make a grid video xg_fake = util.make_video_grid(xg_fake, self.rows_log, self.cols_log) xc_fake = util.make_video_grid(xc_fake, self.rows_log, self.cols_log) x_fake = np.concatenate([xg_fake, xc_fake], axis=-1) # concat # log fake samples (dtype: int, axis: (B, T, C, H, W)) x_fake = x_fake.transpose(0, 2, 1, 3, 4) self.logger.tf_log_video(x_fake, "fake_samples", iteration) # real samples # take next batch: (dtype: float, axis: (B, C, T, H, W)) batch = next(iter(self.dataloader_log)) xg_real, xc_real = batch[self.geometric_info], batch["color"] # convert xc to np.ndarray: (dtype: int, axis: (B, C, T, H, W)) xc_real = util.videos_to_numpy(xc_real) # convert xg to np.ndarray: (dtype: int, axis: (B, C, T, H, W)) xg_real = xg_real.data.cpu().numpy() xg_real = util.geometric_info_in_color_format(xg_real, ggen.geometric_info) # log histgram of real samples self.logger.tf_log_histgram(xg_real[:, 0], "geospace_real", iteration) self.logger.tf_log_histgram(xc_real[:, 0], "colorspace_real", iteration) # make a grid video xc_real = util.make_video_grid(xc_real, self.rows_log, self.cols_log) xg_real = util.make_video_grid(xg_real, self.rows_log, self.cols_log) x_real = np.concatenate([xg_real, xc_real], axis=-1) # log fake samples (dtype: int, axis: (B, T, C, H, W)) x_real = x_real.transpose(0, 2, 1, 3, 4) self.logger.tf_log_video(x_real, "real_samples", iteration)
def train(pretrain=True, b_test=False): # Generate test sample inlier_sample, outlier_sample = util.generate_samples(150, 100000, 100) # Pretraining Stacked Auto Encoder if pretrain: stacked_auto_encoder_weights, stacked_auto_encoder_biases = g_encoder_pretrain(inlier_sample) else: stacked_auto_encoder_weights = None stacked_auto_encoder_biases = None bn_train = tf.placeholder(tf.bool) lstm_input = tf.placeholder(dtype=tf.float32, shape=[None, lstm_sequence_length, input_feature_dim]) #lstm_linear_transform_weight = tf.Variable( # tf.truncated_normal([lstm_linear_transform_input_dim, lstm_z_sequence_dim], stddev=0.1, dtype=tf.float32)) #lstm_linear_transform_bias = tf.Variable(tf.zeros([lstm_z_sequence_dim], dtype=tf.float32)) g_encoder_input = tf.placeholder(dtype=tf.float32, shape=[None, input_feature_dim]) d_input = tf.placeholder(dtype=tf.float32, shape=[None, input_feature_dim]) # Z local: Encoder latent output z_local = g_encoder_network(g_encoder_input, pretrained=pretrain, weights=stacked_auto_encoder_weights, biases=stacked_auto_encoder_biases, activation='swish', scope='G_Encoder', bn_phaze=bn_train) # Z seq: LSTM sequence latent output z_seq = lstm_network(lstm_input, scope='LSTM') z_enc = tf.concat([z_seq, z_local], 1) # Reconstructed output decoder_output = g_decoder_network(z_enc, activation='swish', scope='G_Decoder', bn_phaze=bn_train) # Reencoding reconstucted output z_renc = r_encoder_network(decoder_output, activation='swish', scope='R_Encoder', bn_phaze=bn_train) # Discriminator output # - feature real/fake: Feature matching approach. Returns last feature layer feature_real, d_real, d_real_output = discriminator(d_input, activation='relu', scope='Discriminator', bn_phaze=bn_train) feature_fake, d_fake, d_fake_output = discriminator(decoder_output, activation='relu', scope='Discriminator', reuse=True, bn_phaze=bn_train) d_real_output = tf.squeeze(d_real_output) d_fake_output = tf.squeeze(d_fake_output) # Trainable variable lists d_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator') r_encoder_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='R_Encoder') g_encoder_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='G_Encoder') # print('encoder vars:', g_encoder_var) g_decoder_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='G_Decoder') lstm_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='LSTM') generator_vars = lstm_var + g_encoder_var + g_decoder_var conceptual_vars = g_decoder_var + r_encoder_var # Joint loss term residual_loss = get_residual_loss(decoder_output, g_encoder_input, type='l1', gamma=1.0) feature_matching_loss = get_feature_matching_loss(feature_fake, feature_real, type='l2', gamma=1.0) alpha = 0.5 generator_loss = alpha * residual_loss + (1-alpha) * feature_matching_loss conceptual_loss = get_conceptual_loss(z_renc, z_enc, type='l2', gamma=1.0) discriminator_loss = get_discriminator_loss(d_real, d_fake, type='ce', gamma=1.0) # discriminator_loss = get_discriminator_loss(d_real, d_fake, type='wgan', gamma=1.0) # For wgan loss. d_weight_clip = [p.assign(tf.clip_by_value(p, -0.01, 0.01)) for p in d_var] # training operation d_optimizer = tf.train.RMSPropOptimizer(learning_rate=1e-4).minimize(discriminator_loss, var_list=d_var) # d_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(discriminator_loss, var_list=d_var) # g_res_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(residual_loss, var_list=generator_vars) # g_feature_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(feature_matching_loss, # var_list=generator_vars) g_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(generator_loss, var_list=generator_vars) r_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(conceptual_loss, var_list=[conceptual_vars, generator_vars]) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) try: saver = tf.train.Saver() saver.restore(sess, './model/SE_ADNet_L.ckpt') except: print('Restore failed') if b_test == False: num_itr = int(len(inlier_sample)/batch_size) num_epoch = 4 early_stop = False f_loss_list = [] for epoch in range(num_epoch): for itr in range(num_itr): batch_x, batch_seq = util.get_sequence_batch(inlier_sample, lstm_sequence_length, batch_size) # wgan #_, _, d_loss = sess.run([d_optimizer, d_weight_clip, discriminator_loss], # feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: True}) # gan cross entropy. 2(discriminator):1(generator) training. sess.run([d_optimizer, discriminator_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: True}) batch_x, batch_seq = util.get_sequence_batch(inlier_sample, lstm_sequence_length, batch_size) _, d_loss = sess.run([d_optimizer, discriminator_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train:True}) _, r_loss, f_loss = sess.run([g_optimizer, residual_loss, feature_matching_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: True}) # Test. #_, r_loss = sess.run([g_optimizer, residual_loss], # feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq}) _, c_loss = sess.run([r_optimizer, conceptual_loss], feed_dict={g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: True}) if itr % 200 == 0: print('epoch: {0}, itr: {1}, d_loss: {2}, r_loss: {3}, c_loss: {4}, f_loss: {5}'.format(epoch, itr, d_loss, r_loss, c_loss, f_loss)) f_loss_list.append(f_loss) if len(f_loss_list) > 10: if sum(f_loss_list[-5:])/5 < 0.002: early_stop = False if early_stop: break if early_stop: break for i in range(10): batch_x, batch_seq = util.get_sequence_batch(outlier_sample, lstm_sequence_length, 1) d_loss, r_loss, f_loss, c_loss = sess.run([d_fake_output, residual_loss, feature_matching_loss, conceptual_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: False}) alpha = 1.0 beta = 100 score = (1.0 - d_loss) * 100 + alpha * r_loss + beta * c_loss print('outlier Anomaly Score:', score, ', d loss:', d_loss, ', r loss:', r_loss, ', c loss:', c_loss) batch_x, batch_seq = util.get_sequence_batch(inlier_sample, lstm_sequence_length, 1) d_loss, r_loss, f_loss, c_loss = sess.run([d_fake_output, residual_loss, feature_matching_loss, conceptual_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: False}) score = (1.0 - d_loss) * 10 + alpha * r_loss + beta * c_loss print('inlier Anomaly Score:', score, ', d loss:', d_loss, ', r loss:', r_loss, ', c loss:', c_loss) try: saver.save(sess, './model/SE_ADNet_L.ckpt') except: print('Save failed') else: for i in range(100): batch_x, batch_seq = util.get_sequence_batch(outlier_sample, lstm_sequence_length, 1) # batch_x = np.ones_like(batch_x) d_loss, r_loss, f_loss, c_loss = sess.run([d_fake_output, residual_loss, feature_matching_loss, conceptual_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: False}) alpha = 1.0 beta = 100 score = (1.0 - d_loss) * 10 + alpha * r_loss + beta * c_loss print('outlier Anomaly Score:', score, ', d loss:', d_loss, ', r loss:', r_loss, ', c loss:', c_loss) batch_x, batch_seq = util.get_sequence_batch(inlier_sample, lstm_sequence_length, 1) d_loss, r_loss, f_loss, c_loss = sess.run([d_fake_output, residual_loss, feature_matching_loss, conceptual_loss], feed_dict={d_input: batch_x, g_encoder_input: batch_x, lstm_input: batch_seq, bn_train: False}) score = (1.0 - d_loss) * 10 + alpha * r_loss + beta * c_loss print('inlier Anomaly Score:', score, ', d loss:', d_loss , ', r loss:', r_loss, ', c loss:', c_loss)