def _build_train_op(self): global_step = tf.train.get_global_step() self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.MomentumOptimizer(Config.train.initial_lr, 0.9), learning_rate=Config.train.initial_lr)
def _build_optimizer(self): global_step = tf.train.get_global_step() self.train_op = slim.optimize_loss( self.loss, global_step, optimizer='Adam', learning_rate=Config.train.learning_rate, summaries=['loss'], variables=tf.trainable_variables('generation'), name="train_op")
def _build_train_op(self): global_step = tf.train.get_global_step() learning_rate = Config.train.initial_lr / (Config.train.decay_rate * Config.train.epoch + 1) self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.AdagradOptimizer(learning_rate), learning_rate=learning_rate, clip_gradients=Config.train.max_gradient_norm)
def _build_train_op(self): global_step = tf.train.get_global_step() learning_rate = Config.train.learning_rate * ( Config.train.learning_decay_rate**Config.train.epoch) self.train_op = slim.optimize_loss( self.loss, global_step, optimizer='Adam', learning_rate=learning_rate, clip_gradients=Config.train.max_gradient_norm)
def _build_train_op(self): global_step = tf.train.get_global_step() learning_rate = Config.train.initial_lr / ( 1 + Config.train.lr_decay * Config.train.epoch) self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.MomentumOptimizer(learning_rate, 0.9), learning_rate=learning_rate, clip_gradients=Config.train.max_gradient_norm)
def _build_train_op(self): def clip_gradient(grads_and_vars): clipped = [(tf.clip_by_norm(grad, Config.train.clip_gradients), var) for grad, var in grads_and_vars] return clipped global_step = tf.train.get_global_step() self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.AdadeltaOptimizer(1.0, epsilon=1e-6), learning_rate=1.0, clip_gradients=clip_gradient)
def _build_train_op(self): global_step = tf.train.get_global_step() learning_rate = Config.train.initial_lr * tf.pow( 0.75, tf.cast(global_step // 5000, tf.float32)) self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.9), learning_rate=learning_rate, clip_gradients=Config.train.max_gradient_norm)
def _build_train_op(self): global_step = tf.train.get_global_step() if Config.train.epoch <= 10: learning_rate = Config.train.initial_lr else: learning_rate = Config.train.initial_lr * 0.1 self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.MomentumOptimizer(learning_rate,0.9), learning_rate=learning_rate, clip_gradients=Config.train.max_gradient_norm)
def _build_train_op(self): global_step = tf.train.get_global_step() if Config.train.epoch < Config.train.max_epoch * 0.8: learning_rate = Config.train.learning_rate else: learning_rate = Config.train.learning_rate * 0.1 self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.MomentumOptimizer(learning_rate, 0.9), learning_rate=learning_rate)
def _build_optimizer(self): global_step = tf.train.get_global_step() learning_rate = tf.train.exponential_decay( Config.train.learning_rate, global_step, Config.train.learning_decay_steps, Config.train.learning_decay_rate) self.train_op = slim.optimize_loss(self.loss, global_step, optimizer=Config.train.get( 'optimizer', 'Adam'), learning_rate=learning_rate, summaries=['loss'], name="train_op")
def _build_train_op(self): global_step = tf.train.get_global_step() learning_rate = Config.train.learning_rate * tf.pow( Config.train.learning_decay_rate, tf.cast(Config.train.epoch, tf.float32)) self.train_op = slim.optimize_loss( self.loss, global_step, optimizer=tf.train.MomentumOptimizer(learning_rate, 0.9), learning_rate=learning_rate, clip_gradients=Config.train.max_gradient_norm)
def _build_train_op(self): global_step = tf.train.get_global_step() if Config.train.switch_optimizer == 0: print('using Adadelta') optimizer = tf.train.AdadeltaOptimizer(Config.train.initial_lr) lr = Config.train.initial_lr else: print('using SGD') optimizer = tf.train.GradientDescentOptimizer(Config.train.sgd_lr) lr = Config.train.sgd_lr self.train_op = slim.optimize_loss(self.loss, global_step, optimizer=optimizer, learning_rate=lr)
def cnn_model(learning_rate): with tf.Graph().as_default() as graph: mnist = input_data.read_data_sets('MNIST_data', one_hot=True) x = tf.placeholder(tf.float32, shape=[None, 784]) y = tf.placeholder(tf.float32, shape=[None, 10]) x_train = tf.reshape(x, [-1, 28, 28, 1]) tf.summary.image('input', x_train, 10) with slim.arg_scope([slim.conv2d, slim.fully_connected], normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu): with slim.arg_scope([slim.max_pool2d], padding='SAME'): conv1 = slim.conv2d(x_train, 32, [5, 5]) conv_vars = tf.get_collection(tf.GraphKeys.MODEL_VARIABLES, 'Conv') tf.summary.histogram('conv_weights', conv_vars[0]) pool1 = slim.max_pool2d(conv1, [2, 2]) conv2 = slim.conv2d(pool1, 64, [5, 5]) pool2 = slim.max_pool2d(conv2, [2, 2]) flatten = slim.flatten(pool2) fc = slim.fully_connected(flatten, 1024) logits = slim.fully_connected(fc, 10, activation_fn=None) softmax = tf.nn.softmax(logits, name='output') with tf.name_scope('loss'): loss = slim.losses.softmax_cross_entropy(logits, y) tf.summary.scalar('loss', loss) train_op = slim.optimize_loss(loss, slim.get_or_create_global_step(), learning_rate=learning_rate, optimizer='Adam') with tf.name_scope('accuracy'): correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar('accuracy', accuracy) summary = tf.summary.merge_all() return { 'x': x, 'y': y, 'accuracy': accuracy, 'summary': summary, 'mnist': mnist }, train_op, graph
def build_model(self): config = self.config data_generator = self.data_generator logging.info('Building the model...') # Placeholders self.inputs = tf.placeholder(dtype=tf.int32, shape=[None, None], name='inputs') self.inputs_length = tf.placeholder(dtype=tf.int32, shape=[None], name='inputs_length') self.targets = tf.placeholder(dtype=tf.int32, shape=[None, None], name='targets') self.targets_length = tf.placeholder(dtype=tf.int32, shape=[None], name='targets_length') vocab_size = len(data_generator.vocab) embeddings = tf.get_variable(name='embeddings', shape=[vocab_size, config.word_dim], dtype=tf.float32) with tf.variable_scope('decoder'): with tf.variable_scope('output') as output_scope: # This variable-scope-trick is used to ensure that # output_fn has a proper scope regardless of a caller's # scope. def output_fn(cell_outputs): return layers.fully_connected(inputs=cell_outputs, num_outputs=vocab_size, activation_fn=None, scope=output_scope) self.rnn_cell = rnn.GRUBlockCell(config.sentence_dim) self.encoder_state = self.encode(cell=self.rnn_cell, embeddings=embeddings, inputs=inputs, inputs_length=inputs_length, scope='encoder') self.decoder_outputs = self.decode_train(cell=self.rnn_cell, embeddings=embeddings, encoder_state=self.encoder_state, targets=self.targets[:, :-1], targets_length=self.targets_length - 1, scope='decoder') self.generated = self.decode_inference(cell=self.rnn_cell, embeddings=embeddings, encoder_state=self.encoder_state, output_fn=output_fn, vocab_size=vocab_size, bos_id=data_generator.vocab['<EOS>'], eos_id=data_generator.vocab['<EOS>'], max_length=config.max_length, scope='decoder', reuse=True) self.loss = self.loss(decoder_outputs=self.decoder_outputs, output_fn=output_fn, targets=targets[:, 1:], targets_length=self.targets_length - 1) self.global_step = get_or_create_global_step() self.train_op = slim.optimize_loss(loss=self.loss, global_step=self.global_step, learning_rate=None, optimizer=tf.train.AdamOptimizer(), clip_gradients=5.0) self.summary_writer = tf.summary.FileWriter(logdir=os.path.join(config.save_dir, 'log')) self.summary = tf.summary.merge_all() tf.get_variable_scope().set_initializer(tf.random_normal_initializer(mean=0.0, stddev=0.01)) tf.global_variables_initializer().run() self.saver = tf.train.Saver(max_to_keep=20)
def model(image, label): net = slim.conv2d(image, 48, [5, 5], scope='conv1') net = slim.max_pool2d(net, [2, 2], scope='pool1') net = slim.conv2d(net, 96, [5, 5], scope='conv2') net = slim.max_pool2d(net, [2, 2], scope='pool2') net = slim.flatten(net, scope='flatten') net = slim.fully_connected(net, 512, scope='fully_connected1') logits = slim.fully_connected(net, 10, activation_fn=None, scope='fully_connected2') prob = slim.softmax(logits) loss = slim.losses.softmax_cross_entropy(logits, label) train_op = slim.optimize_loss(loss, slim.get_global_step(), learning_rate=0.001, optimizer='Adam') return train_op
def model_fn(features, labels, mode, params=None, config=None): train_op = None loss = None eval_metrics = None predictions = None if mode == ModeKeys.TRAIN: transformer_model = TransformerModule(params=self.model_params) step = slim.get_or_create_global_step() loss = transformer_model(features) train_op = slim.optimize_loss(loss=loss, global_step=step, learning_rate=self.training_params["learning_rate"], clip_gradients=self.training_params["clip_gradients"], optimizer=params["optimizer"], summaries=slim.OPTIMIZER_SUMMARIES ) elif mode == ModeKeys.PREDICT: raise NotImplementedError elif mode == ModeKeys.EVAL: transformer_model = TransformerModule(params=self.model_params) loss = transformer_model(features) return EstimatorSpec(train_op=train_op, loss=loss, eval_metric_ops=eval_metrics, predictions=predictions, mode=mode)
def main(): data_path = args.data vocab_path = args.vocab save_dir = args.save_dir word_dim = args.word_dim sentence_dim = args.sentence_dim omit_prob = args.omit_prob swap_prob = args.swap_prob config_path = args.config batch_size = args.batch_size max_epoch = args.max_epoch max_length = args.max_length if not os.path.exists(save_dir): os.makedirs(save_dir) # Check whether all needed options are given if config_path is not None: assert (word_dim is None and sentence_dim is None and omit_prob is None and swap_prob is None), ( 'Model hyperparameter options must not be provided when ' 'the "config" option is given.') config = ModelConfig.load(config_path) else: assert not ( word_dim is None or sentence_dim is None or omit_prob is None or swap_prob is None), ( 'All model hyperparameter options must be provided when ' 'the "config" option is not given.') config = ModelConfig(word_dim=word_dim, sentence_dim=sentence_dim, omit_prob=omit_prob, swap_prob=swap_prob) config_path = os.path.join(save_dir, 'config.ini') config.save(config_path) logging.info('Initializing the data generator...') data_generator = DataGenerator(data_path=data_path, vocab_path=vocab_path, eos_symbol='<EOS>', unk_symbol='<UNK>', omit_prob=config.omit_prob, swap_prob=config.swap_prob, batch_size=batch_size, max_length=max_length, max_epoch=max_epoch) with tf.Graph().as_default() as graph: with tf.Session() as sess: logging.info('Building the model...') # Placeholders inputs = tf.placeholder(dtype=tf.int32, shape=[None, None], name='inputs') inputs_length = tf.placeholder(dtype=tf.int32, shape=[None], name='inputs_length') targets = tf.placeholder(dtype=tf.int32, shape=[None, None], name='targets') targets_length = tf.placeholder(dtype=tf.int32, shape=[None], name='targets_length') vocab_size = len(data_generator.vocab) embeddings = tf.get_variable(name='embeddings', shape=[vocab_size, config.word_dim], dtype=tf.float32) with tf.variable_scope('decoder'): with tf.variable_scope('output') as output_scope: # This variable-scope-trick is used to ensure that # output_fn has a proper scope regardless of a caller's # scope. def output_fn(cell_outputs): return layers.fully_connected(inputs=cell_outputs, num_outputs=vocab_size, activation_fn=None, scope=output_scope) rnn_cell = rnn.GRUBlockCell(config.sentence_dim) encoder_state = sae.encode(cell=rnn_cell, embeddings=embeddings, inputs=inputs, inputs_length=inputs_length, scope='encoder') decoder_outputs = sae.decode_train(cell=rnn_cell, embeddings=embeddings, encoder_state=encoder_state, targets=targets[:, :-1], targets_length=targets_length - 1, scope='decoder') generated = sae.decode_inference( cell=rnn_cell, embeddings=embeddings, encoder_state=encoder_state, output_fn=output_fn, vocab_size=vocab_size, bos_id=data_generator.vocab['<EOS>'], eos_id=data_generator.vocab['<EOS>'], max_length=max_length, scope='decoder', reuse=True) loss = sae.loss(decoder_outputs=decoder_outputs, output_fn=output_fn, targets=targets[:, 1:], targets_length=targets_length - 1) global_step = get_or_create_global_step() train_op = slim.optimize_loss(loss=loss, global_step=global_step, learning_rate=None, optimizer=tf.train.AdamOptimizer(), clip_gradients=5.0) summary_writer = tf.summary.FileWriter(logdir=os.path.join( save_dir, 'log'), graph=graph) summary = tf.summary.merge_all() tf.get_variable_scope().set_initializer( tf.random_normal_initializer(mean=0.0, stddev=0.01)) tf.global_variables_initializer().run() saver = tf.train.Saver(max_to_keep=20) logging.info('Training starts!') for data_batch in data_generator: (inputs_v, inputs_length_v, targets_v, targets_length_v) = data_batch summary_v, global_step_v, _ = sess.run( fetches=[summary, global_step, train_op], feed_dict={ inputs: inputs_v, inputs_length: inputs_length_v, targets: targets_v, targets_length: targets_length_v }) summary_writer.add_summary(summary=summary_v, global_step=global_step_v) if global_step_v % 100 == 0: logging.info('{} Iter #{}, Epoch {:.2f}'.format( datetime.now(), global_step_v, data_generator.progress)) num_samples = 2 (inputs_sample_v, inputs_length_sample_v, targets_sample_v, targets_length_sample_v) = ( data_generator.sample(num_samples)) generated_v = sess.run(fetches=generated, feed_dict={ inputs: inputs_sample_v, inputs_length: inputs_length_sample_v }) for i in range(num_samples): logging.info('-' * 60) logging.info('Sample #{}'.format(i)) inputs_sample_words = data_generator.ids_to_words( inputs_sample_v[i][:inputs_length_sample_v[i]]) targets_sample_words = data_generator.ids_to_words( targets_sample_v[i][1:targets_length_sample_v[i]]) generated_words = data_generator.ids_to_words( generated_v[i]) if '<EOS>' in generated_words: eos_index = generated_words.index('<EOS>') generated_words = generated_words[:eos_index + 1] logging.info('Input: {}'.format( ' '.join(inputs_sample_words))) logging.info('Target: {}'.format( ' '.join(targets_sample_words))) logging.info('Generated: {}'.format( ' '.join(generated_words))) logging.info('-' * 60) if global_step_v % 500 == 0: save_path = os.path.join(save_dir, 'model.ckpt') real_save_path = saver.save(sess=sess, save_path=save_path, global_step=global_step_v) logging.info( 'Saved the checkpoint to: {}'.format(real_save_path))
def main(args): print("Starting training with parameters:", vars(args)) # Load the data print("Loading data...") timestamp = time() # load different aligned SSMs multiple_ssms_data = [ load_ssm_string(args.data), #load_ssm_phonetics(args.data), ] channels = len(multiple_ssms_data) print("Found", channels, "SSM channels") segment_borders = load_segment_borders(args.data) # ADDITIONAL FEATURES FOR AFTER CONVOLUTION # token_count_feat = load_linewise_feature(args.data, 'token_count') # token_count_feat.set_index(['id'], inplace=True) # syllable_count_feat = load_linewise_feature(args.data, 'syllable_count') # syllable_count_feat.set_index(['id'], inplace=True) char_count_feat = load_linewise_feature(args.data, 'char_count') char_count_feat.set_index(['id'], inplace=True) if not args.genre: train_borders, test_borders = load_segment_borders_watanabe(args.data) else: # load train/test for some genre only (training is always on whole Watanabe train set) train_borders, test_borders = load_segment_borders_for_genre( args.data, args.genre) train_borders_set = set(train_borders.id) test_borders_set = set(test_borders.id) train_test_borders_set = train_borders_set.union(test_borders_set) print("Done in %.1fs" % tdiff(timestamp)) # Figure out the maximum ssm size print("Gathering dataset statistics...") timestamp = time() max_ssm_size = 0 counter = 0 for ssm_obj in multiple_ssms_data[0].itertuples(): current_id = ssm_obj.id #skip ids not in training or dev if not current_id in train_test_borders_set: continue counter += 1 max_ssm_size = max(max_ssm_size, ssm_obj.ssm.shape[0]) print("Done in %.1fs (%.2fk items, max ssm size: %d)" % (tdiff(timestamp), k(counter), max_ssm_size)) # Producing training set train_buckets = dict() test_buckets = dict() print("Producing training set...") counter = 0 filtered = 0 timestamp = time() max_ssm_size = min(max_ssm_size, args.max_ssm_size) #allow indexed access to dataframes for elem in multiple_ssms_data: elem.set_index(['id'], inplace=True) for borders_obj in segment_borders.itertuples(): counter += 1 # temp. speedup for debugging #if counter % 100 != 0: # continue current_id = borders_obj.id #skip ids not in training or test if not current_id in train_test_borders_set: continue ssm_elems = [] for single_ssm in multiple_ssms_data: ssm_elems.append(single_ssm.loc[current_id].ssm) ssm_size = ssm_elems[0].shape[0] # Reporting if counter % 10000 == 0: print(" processed %3.0fk items (%4.1fs, filt.: %4.1fk)" % (k(counter), tdiff(timestamp), k(filtered))) timestamp = time() # Filter out too small or too large ssm if ssm_size < args.min_ssm_size or ssm_size > args.max_ssm_size: filtered += 1 continue # Sentences are grouped into buckets to improve performance bucket_size = ssm_size if not args.buckets: bucket_size = max_ssm_size bucket_id = int(math.ceil(math.log2(bucket_size))) # one tensor for one song ssm_tensor = tensor_from_multiple_ssms(ssm_elems, 2**bucket_id, args.window_size) # concatenate all added features at axis=1 here added_features = np.concatenate( ( #window_features(token_count_feat.loc[current_id].feat_val), #window_features(syllable_count_feat.loc[current_id].feat_val), window_features(char_count_feat.loc[current_id].feat_val), ), axis=1) added_feats_count = added_features.shape[1] ssm_labels = labels_from_label_array(borders_obj.borders, ssm_size) # fill train/test buckets according to definition files if current_id in train_borders_set: add_to_buckets(train_buckets, bucket_id, ssm_tensor, added_features, ssm_labels) else: assert current_id in test_borders_set, 'id ' + current_id + ' is neither in train nor in test!' add_to_buckets(test_buckets, bucket_id, ssm_tensor, added_features, ssm_labels) del multiple_ssms_data del added_features del segment_borders del train_borders del test_borders del train_borders_set del test_borders_set del train_test_borders_set # Compacting buckets and printing statistics print("Training set buckets:") train_buckets = compact_buckets(train_buckets) print("Test set buckets:") test_buckets = compact_buckets(test_buckets) # Define the neural network # nn = Dense(window_size=args.window_size, ssm_size=2 ** next(train_buckets.keys().__iter__())) nn = NoPadding1Conv(window_size=args.window_size, ssm_size=2**next(train_buckets.keys().__iter__()), added_features_size=added_feats_count, channels=channels) # nn = MnistLike(window_size=args.window_size, ssm_size=2 ** next(train_buckets.keys().__iter__()), channels=channels) # Defining optimisation problem g_global_step = tf.train.get_or_create_global_step() g_train_op = slim.optimize_loss(loss=nn.g_loss, global_step=g_global_step, learning_rate=None, optimizer=tf.train.AdamOptimizer(), clip_gradients=5.0) # Logging summary_writer = tf.summary.FileWriter(logdir=path.join( args.output, 'log'), graph=tf.get_default_graph()) g_summary = tf.summary.merge_all() saver = tf.train.Saver(max_to_keep=10) with tf.Session() as sess: # Checkpoint restore / variable initialising save_path = path.join(args.output, 'model.ckpt') latest_checkpoint = tf.train.latest_checkpoint(args.output) if latest_checkpoint is None: print("Initializing variables") timestamp = time() tf.get_variable_scope().set_initializer( tf.random_normal_initializer(mean=0.0, stddev=0.01)) tf.global_variables_initializer().run() print("Done in %.2fs" % tdiff(timestamp)) else: print("Restoring from checkpoint variables") timestamp = time() saver.restore(sess=sess, save_path=latest_checkpoint) print("Done in %.2fs" % tdiff(timestamp)) print() timestamp = time() global_step_v = 0 avg_loss = 0.0 eval_precisions = [] eval_recalls = [] eval_fscores = [] # Training loop for epoch in range(args.max_epoch): for bucket_id in train_buckets: for batch_X, batch_X_added_feats, batch_Y in feed( train_buckets[bucket_id], args.batch_size): # Single training step summary_v, global_step_v, loss_v, _ = sess.run( fetches=[ g_summary, g_global_step, nn.g_loss, g_train_op ], feed_dict={ nn.g_in: batch_X, nn.g_labels: batch_Y, nn.g_dprob: 0.6, nn.g_added_features: batch_X_added_feats }) summary_writer.add_summary(summary=summary_v, global_step=global_step_v) avg_loss += loss_v # Reporting if global_step_v % args.report_period == 0: print("Iter %d" % global_step_v) print(" epoch: %.0f, avg.loss: %.4f, iter/s: %.4f" % (epoch, avg_loss / args.report_period, args.report_period / tdiff(timestamp))) timestamp = time() avg_loss = 0.0 # Evaluation if global_step_v % (args.report_period * 10) == 0: tp = 0 fp = 0 fn = 0 for bucket_id in test_buckets: for test_X, text_X_added_feats, true_Y in feed( test_buckets[bucket_id], args.batch_size): pred_Y = nn.g_results.eval( feed_dict={ nn.g_in: test_X, nn.g_dprob: 1.0, nn.g_added_features: text_X_added_feats }) try: _, cur_fp, cur_fn, cur_tp = confusion_matrix( true_Y, pred_Y).ravel() tp += cur_tp fp += cur_fp fn += cur_fn except Exception as e: print(e) print( confusion_matrix(true_Y, pred_Y).ravel()) print(confusion_matrix(true_Y, pred_Y)) current_precision = precision(tp, fp) * 100 current_recall = recall(tp, fn) * 100 current_fscore = f1(tp, fp, fn) * 100 eval_precisions.append(current_precision) eval_recalls.append(current_recall) eval_fscores.append(current_fscore) print(" P: %.2f%%, R: %.2f%%, F1: %.2f%%" % (current_precision, current_recall, current_fscore)) # Checkpointing if global_step_v % 10000 == 0: real_save_path = saver.save(sess=sess, save_path=save_path, global_step=global_step_v) print("Saved the checkpoint to: %s" % real_save_path) print('precisions:', eval_precisions) print('recalls:', eval_recalls) print('fscores:', eval_fscores) real_save_path = saver.save(sess=sess, save_path=save_path, global_step=global_step_v) print("Saved the checkpoint to: %s" % real_save_path) print('total precisions:', eval_precisions) print('total recalls:', eval_recalls) print('total fscores:', eval_fscores) print('--------------') n = 10 print('n =', n) print('avg. of last n precisions:', np.round(np.median(eval_precisions[-n:]), 1), '+-', np.round(np.std(eval_precisions[-n:]), 1), '%') print('avg. of last n recalls :', np.round(np.median(eval_recalls[-n:]), 1), '+-', np.round(np.std(eval_recalls[-n:]), 1), '%') print('avg. of last n fscores :', np.round(np.median(eval_fscores[-n:]), 1), '+-', np.round(np.std(eval_fscores[-n:]), 1), '%')
activities_loss = - tf.reduce_mean(activities_in_one_hot * tf.log(activities_preds + EPS)) activities_avg_preds = tf.reduce_mean(tf.reshape(activities_preds, [B,T,c.num_activities]), [1]) activities_avg_labels = tf.to_int32(tf.argmax(activities_avg_preds, 1)) activities_avg_accuracy = tf.reduce_mean(tf.to_float(tf.equal(activities_avg_labels, activities_in[:,5]))) sequence_vars = tf.get_collection(tf.GraphKeys.VARIABLES, 'ActNet/sequence') with tf.variable_scope('train'): global_step = slim.create_global_step() learning_rate = c.train_learning_rate total_loss = activities_loss + c.actions_loss_weight * actions_loss train_op = slim.optimize_loss(total_loss, global_step, learning_rate, tf.train.AdamOptimizer) train_vars = tf.get_collection(tf.GraphKeys.VARIABLES, 'train') # TODO: generate the tag print('finished building the model %s' % c.out_model_path) pickle.dump(c, open(c.out_config_path, 'wb')) # In[ ]: # In[ ]: ## training