[remove]

    redundant comments

main.py

@@ -53,10 +53,8 @@ def set_training(gan, training_method):
 def parse_cmd(argv):
     try:
         opts, args = getopt.getopt(argv, "hg:t:d:")
-        # print(argv)
-        # print(opts)
+
         opt_arg = dict(opts)
-        # print(opt_arg)
         if '-h' in opt_arg.keys():
             print('usage: python main.py -g <gan_type>')
             print('       python main.py -g <gan_type> -t <train_type>')

models/Gan.py

@@ -6,7 +6,6 @@
 class Gan:
     def __init__(self):
         self.oracle = None
-        # self.reward = None
         self.generator = None
         self.discriminator = None
         self.gen_data_loader = None
@@ -23,9 +22,6 @@ def __init__(self):
     def set_oracle(self, oracle):
         self.oracle = oracle
 
-    # def set_reward(self, reward):
-    #     self.reward = reward
-
     def set_generator(self, generator):
         self.generator = generator
 

models/gsgan/Gsgan.py

@@ -47,7 +47,6 @@ def init_oracle_trainng(self, oracle=None):
                                       num_filters=self.num_filters, non_static=True,
                                       l2_reg_lambda=self.l2_reg_lambda)
         self.set_discriminator(discriminator)
-        # discriminator = None
         generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, sess=self.sess,
                               hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, discriminator=discriminator,
                               start_token=self.start_token)
@@ -96,11 +95,7 @@ def real_len(batches):
             feed = {
                 self.discriminator.input_x: to_one_hot(x_batch),
                 self.discriminator.input_y: y_batch,
-                # self.discriminator.dropout_keep_prob: 0.8,
-                # self.discriminator.batch_size: len(x_batch),
-                # self.discriminator.real_len: real_len(x_batch),
             }
-            # _ = self.sess.run(self.discriminator.train_op, feed)
             _ = self.sess.run(
                 [self.discriminator.train_op], feed)
 
@@ -180,7 +175,6 @@ def init_cfg_training(self, grammar=None):
                                       num_filters=self.num_filters, non_static=True,
                                       l2_reg_lambda=self.l2_reg_lambda)
         self.set_discriminator(discriminator)
-        # discriminator = None
         generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, sess=self.sess,
                               hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, discriminator=discriminator,
                               start_token=self.start_token)
@@ -222,7 +216,6 @@ def get_cfg_test_file(dict=iw_dict):
         self.pre_epoch_num = 0
         self.adversarial_epoch_num = 100
         self.log = open('experiment-log-gsgan-cfg.csv', 'w')
-        # generate_samples(self.sess, self.oracle, self.batch_size, self.generate_num, self.oracle_file)
         generate_samples(self.sess, self.generator, self.batch_size, self.generate_num, self.generator_file)
         self.gen_data_loader.create_batches(self.oracle_file)
         self.oracle_data_loader.create_batches(self.generator_file)
@@ -274,7 +267,6 @@ def init_real_trainng(self, data_loc=None):
                                       num_filters=self.num_filters, non_static=True,
                                       l2_reg_lambda=self.l2_reg_lambda)
         self.set_discriminator(discriminator)
-        # discriminator = None
         generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, sess=self.sess,
                               hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, discriminator=discriminator,
                               start_token=self.start_token)

models/gsgan/GsganDataLoader.py

@@ -7,7 +7,6 @@ def __init__(self, batch_size, seq_length, end_token=0):
         self.token_stream = []
         self.seq_length = seq_length
         self.end_token = end_token
-        # self.num_batch = int(len(self.token_stream) / self.batch_size)
 
     def create_batches(self, data_file):
         self.token_stream = []

models/gsgan/GsganDiscriminator.py

@@ -12,15 +12,8 @@ def __init__(self, embedding_size, vocab_size, non_static, hidden_unit, sequence
         self.hidden_dim = hidden_unit
         self.num_classes = num_classes
         self.sequence_length = sequence_length
-        # self.dropout_keep_prob = tf.placeholder(tf.float32, name='dropout_keep_prob')
         self.batch_size = tf.constant(value=[batch_size])
         self.batch_size_scale = batch_size
-        # self.pad = tf.placeholder(tf.float32, [None, 1, embedding_size, 1], name='pad')
-
-        # self.real_len = tf.constant(value=sequence_length, shape=[batch_size])
-        # self.filter_sizes = filter_sizes
-        # self.embedding_size = embedding_size
-        # self.num_filters = num_filters
         self.hidden_unit = hidden_unit
         self.d_params = []
         l2_loss = tf.constant(0.0)
@@ -48,7 +41,6 @@ def __init__(self, embedding_size, vocab_size, non_static, hidden_unit, sequence
 
         self.params = [param for param in tf.trainable_variables() if 'discriminator' in param.name]
         d_optimizer = tf.train.AdamOptimizer(1e-4)
-        # grads_and_vars = d_optimizer.compute_gradients(self.loss, self.params, aggregation_method=2)
         self.grad_clip = 5.0
         self.pretrain_grad, _ = tf.clip_by_global_norm(tf.gradients(self.loss, self.params), self.grad_clip)
         self.train_op = d_optimizer.apply_gradients(zip(self.pretrain_grad, self.params))

models/gsgan/GsganGenerator.py

@@ -82,9 +82,6 @@ def _g_recurrence(i, x_t, h_tm1, gen_o, gen_x, gen_ot):
             dtype=tf.float32, size=self.sequence_length,
             dynamic_size=False, infer_shape=True)
 
-        # ta_emb_x = tensor_array_ops.TensorArray(
-        #     dtype=tf.float32, size=self.sequence_length)
-        # # ta_emb_x = ta_emb_x.unstack(self.processed_x)
 
         def _pretrain_recurrence(i, x_t, h_tm1, g_predictions):
             h_t = self.g_recurrent_unit(x_t, h_tm1)

models/leakgan/Leakgan.py

@@ -169,7 +169,6 @@ def train_oracle(self):
         for a in range(1):
             g = self.sess.run(self.generator.gen_x, feed_dict={self.generator.drop_out: 1, self.generator.train: 1})
 
-        # rollout = Reward(generator, update_rate)
         print('start pre-train generator:')
         for epoch in range(self.pre_epoch_num):
             start = time()
@@ -297,7 +296,6 @@ def get_cfg_test_file(dict=iw_dict):
         self.pre_epoch_num = 80
         self.adversarial_epoch_num = 100
         self.log = open('experiment-log-leakganbasic-cfg.csv', 'w')
-        # generate_samples(self.sess, self.oracle, self.batch_size, self.generate_num, self.oracle_file)
         generate_samples_gen(self.sess, self.generator, self.batch_size, self.generate_num, self.generator_file)
         self.gen_data_loader.create_batches(self.oracle_file)
         self.oracle_data_loader.create_batches(self.generator_file)
@@ -366,7 +364,6 @@ def get_cfg_test_file(dict=iw_dict):
     def init_real_trainng(self, data_loc=None):
         from utils.text_process import text_precess, text_to_code
         from utils.text_process import get_tokenlized, get_word_list, get_dict
-        # from utils.text_process import get_dict
         if data_loc is None:
             data_loc = 'data/image_coco.txt'
         self.sequence_length, self.vocab_size = text_precess(data_loc)
@@ -484,7 +481,6 @@ def get_real_test_file(dict=iw_dict):
                 loss = pre_train_epoch_gen(self.sess, self.generator, self.gen_data_loader)
                 end = time()
                 print('epoch:' + str(epoch) + '--' + str(epoch_) + '\t time:' + str(end - start))
-                # self.add_epoch()
                 if epoch % 5 == 0:
                     generate_samples_gen(self.sess, self.generator, self.batch_size, self.generate_num,
                                          self.generator_file)

models/leakgan/LeakganDataLoader.py

@@ -7,7 +7,6 @@ def __init__(self, batch_size, seq_length, end_token=0):
         self.token_stream = []
         self.seq_length = seq_length
         self.end_token = end_token
-        # self.num_batch = int(len(self.token_stream) / self.batch_size)
 
     def create_batches(self, data_file):
         self.token_stream = []

models/leakgan/LeakganDiscriminator.py

@@ -78,7 +78,6 @@ def __init__(self, sequence_length, num_classes, vocab_size,dis_emb_dim,filter_s
 
         self.D_input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y")
         self.D_input_x = tf.placeholder(tf.int32, [None, sequence_length], name="input_x")
-        # self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")
 
         with tf.name_scope('D_update'):
             self.D_l2_loss = tf.constant(0.0)
@@ -88,7 +87,6 @@ def __init__(self, sequence_length, num_classes, vocab_size,dis_emb_dim,filter_s
             with tf.variable_scope("feature") as self.feature_scope:
                 D_feature = self.FeatureExtractor_unit(self.D_input_x,self.dropout_keep_prob)#,self.dropout_keep_prob)
                 self.feature_scope.reuse_variables()
-            # tf.get_variable_scope().reuse_variables()
 
             D_scores, D_predictions,self.ypred_for_auc = self.classification(D_feature)
             losses = tf.nn.softmax_cross_entropy_with_logits(logits=D_scores, labels=self.D_input_y)

models/leakgan/LeakganGenerator.py

@@ -399,9 +399,6 @@ def _g_recurrence_2(i, x_t, gen_x, h_tm1, h_tm1_manager, last_goal, real_goal):
             o_t_Worker = self.g_worker_output_unit(h_t_Worker)  # batch x vocab , logits not prob
 
             o_t_Worker = tf.reshape(o_t_Worker, [self.batch_size, self.num_vocabulary, self.goal_size])
-            # o_t_Worker = tf.nn.softmax(o_t_Worker)
-            # o_t_Worker = tf.expand_dims(o_t_Worker,2)   # batch x vocab x 1
-            # o_t_Worker = tf.multiply(o_t_Worker,tf.nn.softmax(self.W_workerOut_change) ) #batch x vocab x goal_size
 
             h_t_manager = self.g_manager_recurrent_unit(feature, h_tm1_manager)
             sub_goal = self.g_manager_output_unit(h_t_manager)

models/maligan_basic/MailganDiscriminator.py

@@ -62,7 +62,6 @@ def __init__(
         self.input_x = tf.placeholder(tf.int32, [None, sequence_length], name="input_x")
         self.input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y")
         self.dropout_keep_prob = dropout_keep_prob
-        # self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")
 
         # Keeping track of l2 regularization loss (optional)
         l2_loss = tf.constant(0.0)

models/maligan_basic/Maligan.py

@@ -108,7 +108,6 @@ def train_oracle(self):
         self.gen_data_loader.create_batches(self.oracle_file)
         self.oracle_data_loader.create_batches(self.generator_file)
 
-        # rollout = Reward(generator, update_rate)
         print('start pre-train generator:')
         for epoch in range(self.pre_epoch_num):
             start = time()

models/maligan_basic/MaliganDataLoader.py

@@ -7,7 +7,6 @@ def __init__(self, batch_size, seq_length, end_token=0):
         self.token_stream = []
         self.seq_length = seq_length
         self.end_token = end_token
-        # self.num_batch = int(len(self.token_stream) / self.batch_size)
 
     def create_batches(self, data_file):
         self.token_stream = []

models/pg_bleu/Pgbleu.py

@@ -101,7 +101,6 @@ def train_oracle(self):
         self.oracle_data_loader.create_batches(self.generator_file)
         self.init_metric()
 
-        # rollout = Reward(generator, update_rate)
         print('start pre-train generator:')
         for epoch in range(self.pre_epoch_num):
             start = time()

models/pg_bleu/PgbleuDataLoader.py

@@ -7,7 +7,6 @@ def __init__(self, batch_size, seq_length, end_token=0):
         self.token_stream = []
         self.seq_length = seq_length
         self.end_token = end_token
-        # self.num_batch = int(len(self.token_stream) / self.batch_size)
 
     def create_batches(self, data_file):
         self.token_stream = []

models/rankgan/Rankgan.py

@@ -109,7 +109,7 @@ def train_oracle(self):
         self.gen_data_loader.create_batches(self.oracle_file)
         self.oracle_data_loader.create_batches(self.generator_file)
 
-        # rollout = Reward(generator, update_rate)
+        rollout = Reward(generator, update_rate)
         print('start pre-train generator:')
         for epoch in range(self.pre_epoch_num):
             start = time()
@@ -260,7 +260,7 @@ def get_cfg_test_file(dict=iw_dict):
     def init_real_trainng(self, data_loc=None):
         from utils.text_process import text_precess, text_to_code
         from utils.text_process import get_tokenlized, get_word_list, get_dict
-        # from utils.text_process import get_dict
+        from utils.text_process import get_dict
         if data_loc is None:
             data_loc = 'data/image_coco.txt'
         self.sequence_length, self.vocab_size = text_precess(data_loc)

models/rankgan/RankganDiscriminator.py

@@ -164,11 +164,6 @@ def __init__(
 
             # Final (unnormalized) scores and predictions
             with tf.name_scope("output"):
-                # W = tf.Variable(tf.truncated_normal([num_filters_total, num_classes], stddev=0.1), name="W")
-                # b = tf.Variable(tf.constant(0.1, shape=[num_classes]), name="b")
-                # l2_loss += tf.nn.l2_loss(W)
-                # l2_loss += tf.nn.l2_loss(b)
-                # self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name="scores")
                 """
                 scores = tf.TensorArray(dtype=tf.float32, size=batch_size, dynamic_size=False, infer_shape=True)
                 def rank_recurrence(i, scores):
@@ -192,7 +187,6 @@ def rank_recurrence(i, scores):
                 self.scores = tf.reshape(self.scores, [-1])
                 self.ypred_for_auc = tf.reshape(tf.nn.softmax(self.scores), [-1])
                 self.log_score = tf.log(self.ypred_for_auc)
-                # self.predictions = tf.argmax(self.scores, 1, name="predictions")
 
             # CalculateMean cross-entropy loss
             with tf.name_scope("loss"):
@@ -207,4 +201,3 @@ def rank_recurrence(i, scores):
         d_optimizer = tf.train.AdamOptimizer(1e-4)
         grads_and_vars = d_optimizer.compute_gradients(self.loss, self.params, aggregation_method=2)
         self.train_op = d_optimizer.apply_gradients(grads_and_vars)
-        # self.train_op = d_optimizer.minimize(self.loss)

models/seqgan/Seqgan.py

@@ -58,7 +58,7 @@ def train_discriminator(self):
                 self.discriminator.input_y: y_batch,
             }
             loss,_ = self.sess.run([self.discriminator.d_loss, self.discriminator.train_op], feed)
-            # print(loss)
+            print(loss)
 
     def evaluate(self):
         generate_samples(self.sess, self.generator, self.batch_size, self.generate_num, self.generator_file)
@@ -113,7 +113,6 @@ def train_oracle(self):
         self.gen_data_loader.create_batches(self.oracle_file)
         self.oracle_data_loader.create_batches(self.generator_file)
 
-        # rollout = Reward(generator, update_rate)
         print('start pre-train generator:')
         for epoch in range(self.pre_epoch_num):
             start = time()
@@ -208,7 +207,6 @@ def get_cfg_test_file(dict=iw_dict):
         self.pre_epoch_num = 80
         self.adversarial_epoch_num = 100
         self.log = open('experiment-log-seqgan-cfg.csv', 'w')
-        # generate_samples(self.sess, self.oracle, self.batch_size, self.generate_num, self.oracle_file)
         generate_samples(self.sess, self.generator, self.batch_size, self.generate_num, self.generator_file)
         self.gen_data_loader.create_batches(self.oracle_file)
         self.oracle_data_loader.create_batches(self.generator_file)

models/seqgan/SeqganDataLoader.py

@@ -7,7 +7,6 @@ def __init__(self, batch_size, seq_length, end_token=0):
         self.token_stream = []
         self.seq_length = seq_length
         self.end_token = end_token
-        # self.num_batch = int(len(self.token_stream) / self.batch_size)
 
     def create_batches(self, data_file):
         self.token_stream = []

models/textGan_MMD/Textgan.py

@@ -93,11 +93,7 @@ def init_metric(self):
         self.add_metric(docsim)
 
     def train_discriminator(self):
-        # generate_samples(self.sess, self.generator, self.batch_size, self.generate_num, self.generator_file)
-        # self.dis_data_loader.load_train_data(self.oracle_file, self.generator_file)
         for _ in range(3):
-            # self.dis_data_loader.next_batch()
-            # x_batch, y_batch = self.dis_data_loader.next_batch()
             x_batch, z_h = self.generator.generate(self.sess, True)
             y_batch = self.gen_data_loader.next_batch()
             feed = {
@@ -289,7 +285,6 @@ def get_cfg_test_file(dict=iw_dict):
     def init_real_trainng(self, data_loc=None):
         from utils.text_process import text_precess, text_to_code
         from utils.text_process import get_tokenlized, get_word_list, get_dict
-        # from utils.text_process import get_dict
         if data_loc is None:
             data_loc = 'data/image_coco.txt'
         self.sequence_length, self.vocab_size = text_precess(data_loc)

models/textGan_MMD/TextganDataLoader.py

@@ -7,7 +7,6 @@ def __init__(self, batch_size, seq_length, end_token=0):
         self.token_stream = []
         self.seq_length = seq_length
         self.end_token = end_token
-        # self.num_batch = int(len(self.token_stream) / self.batch_size)
 
     def create_batches(self, data_file):
         self.token_stream = []

models/textGan_MMD/TextganDiscriminator.py

@@ -22,15 +22,12 @@ def __init__(
         self.input_y_lable = tf.placeholder(tf.float32, [None, num_classes], name="input_y")
 
         self.zh = tf.placeholder(tf.float32, [None, emd_dim], name="zh")
-        # self.zc = tf.placeholder(tf.float32, [None], name="zc")
 
         self.dropout_keep_prob = dropout_keep_prob
         self.filter_sizes = filter_sizes
         self.num_filters = num_filters
         self.sequence_length = sequence_length
         self.num_classes = num_classes
-        # self.embbeding_mat = None
-        # self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")
 
         # Keeping track of l2 regularization loss (optional)
         l2_loss = tf.constant(0.0)

models/textGan_MMD/TextganGenerator.py

@@ -58,9 +58,7 @@ def __init__(self, num_vocabulary, batch_size, emb_dim, hidden_dim,
         def _g_recurrence(i, x_t, h_tm1, gen_o, gen_x, gen_ot):
             h_t = self.g_recurrent_unit(x_t, h_tm1)  # hidden_memory_tuple
             o_t = self.g_output_unit(h_t)  # batch x vocab , logits not prob
-            # hv = o_t
             next_token = tf.cast(tf.argmax(o_t, axis=1), tf.int32)
-            # next_token = tf.cast(tf.argmax(tf.nn.softmax(tf.multiply(hv, 1e4)), axis=1), tf.int32)
             x_tp1 = tf.matmul(tf.nn.softmax(tf.multiply(o_t, 1e3)), self.g_embeddings)
             gen_o = gen_o.write(i, tf.reduce_sum(tf.multiply(tf.one_hot(next_token, self.num_vocabulary, 1.0, 0.0),
                                                              tf.nn.softmax(o_t)), 1))  # [batch_size] , prob
@@ -202,7 +200,6 @@ def calc_mmd(x, y):
 
     def generate(self, sess, get_z = False):
         z_h0 = np.random.uniform(low=-.01, high=1, size=[self.batch_size, self.emb_dim])
-        # z_h0 = np.zeros(shape=[self.batch_size, self.emb_dim])
         z_c0 = np.zeros(shape=[self.batch_size, self.emb_dim])
         feed = {
             self.h_0: z_h0,

utils/metrics/Cfg.py

@@ -31,8 +31,6 @@ def get_score(self):
                     continue
                 else:
                     total_num += 1
-                    # s = "".join(s.split())
-                    # s = ['a','a']
                     s = nltk.word_tokenize(s)
                     for _ in self.parser.parse(s):
                         valid_num += 1

utils/metrics/DocEmbSim.py

@@ -137,8 +137,6 @@ def get_wordvec(self, file):
             average_loss = 0
             generate_num = len(data)
             for step in range(num_steps):
-                # batch_data = list()
-                # batch_labels = list()
                 for index in range(generate_num):
                     cur_batch_data, cur_batch_labels = self.generate_batch(
                         batch_size, num_skips, skip_window, data[index])

utils/metrics/Nll.py

@@ -25,7 +25,6 @@ def nll_loss(self):
         self.data_loader.reset_pointer()
         for it in range(self.data_loader.num_batch):
             batch = self.data_loader.next_batch()
-            # g_loss = self.sess.run(self.rnn.pretrain_loss, {self.rnn.x: batch})
             # fixme bad taste
             try:
                 g_loss = self.rnn.get_nll(self.sess, batch)

utils/metrics/SelfBleu.py

@@ -12,7 +12,6 @@ def __init__(self, test_text='', gram=3):
         super().__init__()
         self.name = 'Self-Bleu'
         self.test_data = test_text
-        # self.real_data = real_text
         self.gram = gram
         self.sample_size = 500
         self.reference = None