def main(unused_argv): # Fix random seeds tf.set_random_seed(SEED) np.random.seed(SEED) # Define the TabNet model tabnet_forest_covertype = tabnet_model.TabNet( columns=data_helper_covertype.get_columns(), num_features=data_helper_covertype.NUM_FEATURES, feature_dim=4, output_dim=2, num_decision_steps=6, relaxation_factor=1.5, batch_momentum=0.7, virtual_batch_size=4, num_classes=data_helper_covertype.NUM_CLASSES) column_names = sorted(data_helper_covertype.FEATURE_COLUMNS) print( "Ordered column names, corresponding to the indexing in Tensorboard visualization" ) for fi in range(len(column_names)): print(str(fi) + " : " + column_names[fi]) # Input sampling train_batch = data_helper_covertype.input_fn(TRAIN_FILE, num_epochs=100000, shuffle=True, batch_size=BATCH_SIZE) val_batch = data_helper_covertype.input_fn( VAL_FILE, num_epochs=10000, shuffle=False, batch_size=data_helper_covertype.N_VAL_SAMPLES) test_batch = data_helper_covertype.input_fn( TEST_FILE, num_epochs=10000, shuffle=False, batch_size=data_helper_covertype.N_TEST_SAMPLES) train_iter = train_batch.make_initializable_iterator() val_iter = val_batch.make_initializable_iterator() test_iter = test_batch.make_initializable_iterator() feature_train_batch, label_train_batch = train_iter.get_next() feature_val_batch, label_val_batch = val_iter.get_next() feature_test_batch, label_test_batch = test_iter.get_next() # Define the model and losses encoded_train_batch, total_entropy = tabnet_forest_covertype.encoder( feature_train_batch, reuse=False, is_training=True) logits_orig_batch, _ = tabnet_forest_covertype.classify( encoded_train_batch, reuse=False) softmax_orig_key_op = tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=logits_orig_batch, labels=label_train_batch)) train_loss_op = softmax_orig_key_op + SPARSITY_LOSS_WEIGHT * total_entropy tf.summary.scalar("Total loss", train_loss_op) # Optimization step global_step = tf.train.get_or_create_global_step() learning_rate = tf.train.exponential_decay(INIT_LEARNING_RATE, global_step=global_step, decay_steps=DECAY_EVERY, decay_rate=DECAY_RATE) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): gvs = optimizer.compute_gradients(train_loss_op) capped_gvs = [(tf.clip_by_value(grad, -GRADIENT_THRESH, GRADIENT_THRESH), var) for grad, var in gvs] train_op = optimizer.apply_gradients(capped_gvs, global_step=global_step) # Model evaluation # Validation performance encoded_val_batch, _ = tabnet_forest_covertype.encoder(feature_val_batch, reuse=True, is_training=False) _, prediction_val = tabnet_forest_covertype.classify(encoded_val_batch, reuse=True) predicted_labels = tf.cast(tf.argmax(prediction_val, 1), dtype=tf.int32) val_eq_op = tf.equal(predicted_labels, label_val_batch) val_acc_op = tf.reduce_mean(tf.cast(val_eq_op, dtype=tf.float32)) tf.summary.scalar("Val accuracy", val_acc_op) # Test performance encoded_test_batch, _ = tabnet_forest_covertype.encoder(feature_test_batch, reuse=True, is_training=False) _, prediction_test = tabnet_forest_covertype.classify(encoded_test_batch, reuse=True) predicted_labels = tf.cast(tf.argmax(prediction_test, 1), dtype=tf.int32) test_eq_op = tf.equal(predicted_labels, label_test_batch) test_acc_op = tf.reduce_mean(tf.cast(test_eq_op, dtype=tf.float32)) tf.summary.scalar("Test accuracy", test_acc_op) # Training setup model_name = "tabnet_forest_covertype_model" init = tf.initialize_all_variables() init_local = tf.local_variables_initializer() init_table = tf.tables_initializer(name="Initialize_all_tables") saver = tf.train.Saver() summaries = tf.summary.merge_all() with tf.Session() as sess: summary_writer = tf.summary.FileWriter("./tflog/" + model_name, sess.graph) sess.run(init) sess.run(init_local) sess.run(init_table) sess.run(train_iter.initializer) sess.run(val_iter.initializer) sess.run(test_iter.initializer) for step in range(1, MAX_STEPS + 1): if step % DISPLAY_STEP == 0: _, train_loss, merged_summary = sess.run( [train_op, train_loss_op, summaries]) summary_writer.add_summary(merged_summary, step) print("Step " + str(step) + " , Training Loss = " + "{:.4f}".format(train_loss)) else: _ = sess.run(train_op) if step % VAL_STEP == 0: feed_arr = [ vars()["summaries"], vars()["val_acc_op"], vars()["test_acc_op"] ] val_arr = sess.run(feed_arr) merged_summary = val_arr[0] val_acc = val_arr[1] print("Step " + str(step) + " , Val Accuracy = " + "{:.4f}".format(val_acc)) summary_writer.add_summary(merged_summary, step) if step % SAVE_STEP == 0: saver.save(sess, "./checkpoints/" + model_name + ".ckpt")
def main(unused_argv): # Load training and eval data. train_file = "data/train.csv" val_file = "data/val.csv" test_file = "data/test.csv" # TabNet model tabnet_forest_covertype = tabnet_model.TabNet( columns=data_helper_covertype.get_columns(), num_features=data_helper_covertype.num_features, feature_dim=128, output_dim=64, num_decision_steps=6, relaxation_factor=1.5, batch_momentum=0.7, virtual_batch_size=512, num_classes=data_helper_covertype.num_classes) column_names = sorted(data_helper_covertype.feature_columns) print( "Ordered column names, corresponding to the indexing in Tensorboard visualization" ) for fi in range(len(column_names)): print(str(fi) + " : " + column_names[fi]) # Training parameters max_steps = 10 display_step = 5 val_step = 5 save_step = 5 init_localearning_rate = 0.02 decay_every = 500 decay_rate = 0.95 batch_size = 512 sparsity_loss_weight = 0.0001 gradient_thresh = 2000.0 # Input sampling train_batch = data_helper_covertype.input_fn(train_file, num_epochs=100000, shuffle=True, batch_size=batch_size, n_buffer=1, n_parallel=1) val_batch = data_helper_covertype.input_fn(val_file, num_epochs=10000, shuffle=False, batch_size=batch_size, n_buffer=1, n_parallel=1) test_batch = data_helper_covertype.input_fn(test_file, num_epochs=10000, shuffle=False, batch_size=batch_size, n_buffer=1, n_parallel=1) train_iter = train_batch.make_initializable_iterator() val_iter = val_batch.make_initializable_iterator() test_iter = test_batch.make_initializable_iterator() feature_train_batch, label_train_batch = train_iter.get_next() feature_val_batch, label_val_batch = val_iter.get_next() feature_test_batch, label_test_batch = test_iter.get_next() # Define the model and losses encoded_train_batch, total_entropy = tabnet_forest_covertype.encoder( feature_train_batch, reuse=False, is_training=True) logits_orig_batch, _ = tabnet_forest_covertype.classify( encoded_train_batch, reuse=False) softmax_orig_key_op = tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=logits_orig_batch, labels=label_train_batch)) train_loss_op = softmax_orig_key_op + sparsity_loss_weight * total_entropy tf.summary.scalar("Total loss", train_loss_op) # Optimization step global_step = tf.train.get_or_create_global_step() learning_rate = tf.train.exponential_decay(init_localearning_rate, global_step=global_step, decay_steps=decay_every, decay_rate=decay_rate) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): gvs = optimizer.compute_gradients(train_loss_op) capped_gvs = [(tf.clip_by_value(grad, -gradient_thresh, gradient_thresh), var) for grad, var in gvs] train_op = optimizer.apply_gradients(capped_gvs, global_step=global_step) # Model evaluation # Validation performance encoded_val_batch, _ = tabnet_forest_covertype.encoder(feature_val_batch, reuse=True, is_training=True) _, prediction_val = tabnet_forest_covertype.classify(encoded_val_batch, reuse=True) predicted_labels = tf.cast(tf.argmax(prediction_val, 1), dtype=tf.int32) val_eq_op = tf.equal(predicted_labels, label_val_batch) val_acc_op = tf.reduce_mean(tf.cast(val_eq_op, dtype=tf.float32)) tf.summary.scalar("Val accuracy", val_acc_op) # Test performance encoded_test_batch, _ = tabnet_forest_covertype.encoder(feature_test_batch, reuse=True, is_training=True) _, prediction_test = tabnet_forest_covertype.classify(encoded_test_batch, reuse=True) predicted_labels = tf.cast(tf.argmax(prediction_test, 1), dtype=tf.int32) test_eq_op = tf.equal(predicted_labels, label_test_batch) test_acc_op = tf.reduce_mean(tf.cast(test_eq_op, dtype=tf.float32)) tf.summary.scalar("Test accuracy", test_acc_op) # Training setup model_name = "tabnet_forest_covertype_model" init = tf.initialize_all_variables() init_local = tf.local_variables_initializer() init_table = tf.tables_initializer(name="Initialize_all_tables") saver = tf.train.Saver() summaries = tf.summary.merge_all() with tf.Session() as sess: summary_writer = tf.summary.FileWriter("./tflog/" + model_name, sess.graph) sess.run(init) sess.run(init_local) sess.run(init_table) sess.run(train_iter.initializer) sess.run(val_iter.initializer) sess.run(test_iter.initializer) for step in range(1, max_steps + 1): if step % display_step == 0: _, train_loss, merged_summary = sess.run( [train_op, train_loss_op, summaries]) summary_writer.add_summary(merged_summary, step) print("Step " + str(step) + " , Training Loss = " + "{:.4f}".format(train_loss)) else: _ = sess.run(train_op) if step % val_step == 0: feed_arr = [ vars()["summaries"], vars()["val_acc_op"], vars()["test_acc_op"] ] val_arr = sess.run(feed_arr) merged_summary = val_arr[0] val_acc = val_arr[1] print("Step " + str(step) + " , Val Accuracy = " + "{:.4f}".format(val_acc)) summary_writer.add_summary(merged_summary, step) if step % save_step == 0: saver.save(sess, "./checkpoints/" + model_name + ".ckpt")
def main(unused_argv): # Fix random seeds tf.set_random_seed(SEED) np.random.seed(SEED) # Define the TabNet model tabnet_forest_covertype = tabnet_model.TabNet( columns=data_helper_covertype.get_columns(), num_features=data_helper_covertype.NUM_FEATURES, feature_dim=4, output_dim=2, num_decision_steps=6, relaxation_factor=1.5, batch_momentum=0.7, virtual_batch_size=4, num_classes=data_helper_covertype.NUM_CLASSES) column_names = sorted(data_helper_covertype.FEATURE_COLUMNS) print( "Ordered column names, corresponding to the indexing in Tensorboard visualization" ) for fi in range(len(column_names)): print(str(fi) + " : " + column_names[fi]) # Input sampling/ Разбитие на несколько выборок. Для тренировки, для обучения, валидации train_batch = data_helper_covertype.input_fn(TRAIN_FILE, num_epochs=100000, shuffle=True, batch_size=BATCH_SIZE) val_batch = data_helper_covertype.input_fn( VAL_FILE, num_epochs=10000, shuffle=False, batch_size=data_helper_covertype.N_VAL_SAMPLES) test_batch = data_helper_covertype.input_fn( TEST_FILE, num_epochs=10000, shuffle=False, batch_size=data_helper_covertype.N_TEST_SAMPLES) # Создание итератора для последующего сохранения состояний. train_iter = train_batch.make_initializable_iterator() val_iter = val_batch.make_initializable_iterator() test_iter = test_batch.make_initializable_iterator() # Иициализация и запуск итератора под своими именами. feature_train_batch, label_train_batch = train_iter.get_next() feature_val_batch, label_val_batch = val_iter.get_next() feature_test_batch, label_test_batch = test_iter.get_next() # Define the model and losses # Прогнать обучающую выборку и результирующую по модели в прямом ходе encoded_train_batch, total_entropy = tabnet_forest_covertype.encoder( feature_train_batch, reuse=False, is_training=True) # Классифицировать результат на выходе logits_orig_batch, _ = tabnet_forest_covertype.classify( encoded_train_batch, reuse=False) # Эта функция вычисляет разреженную кросс-энтропию softmax между логитами и метками. # Другими словами, она измеряет вероятность ошибки в дискретных задачах классификации, # в которых классы являются взаимоисключающими. # Это означает, что каждый элемент данных принадлежит только одному классу. # Сверху все это усредняем. softmax_orig_key_op = tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=logits_orig_batch, labels=label_train_batch)) # Рассчитать ошибку на обучающих данных train_loss_op = softmax_orig_key_op + SPARSITY_LOSS_WEIGHT * total_entropy # Рассчитать сумму средних ошибок. tf.summary.scalar("Total loss", train_loss_op) # =======================Optimization step global_step = tf.train.get_or_create_global_step( ) # Returns and create (if necessary) the global step tensor. # При обучении модели часто рекомендуется снижать скорость обучения по мере продвижения обучения. # Эта функция применяет экспоненциальную функцию затухания к заданной начальной скорости обучения. learning_rate = tf.train.exponential_decay(INIT_LEARNING_RATE, global_step=global_step, decay_steps=DECAY_EVERY, decay_rate=DECAY_RATE) # Adam-алгоритм градиентной оптимизации # стохастических целевых функций первого порядка, основанный на адаптивных оценках моментов более низкого порядка optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) # The standard library uses various well-known names to collect and retrieve values associated with a graph update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) # иногда полезно знать какая версия значения переменной была использована в любой конкретной точке времени, # для того чтобы принудительно заставлять перечитывать значение переменной после того как что-то произошло with tf.control_dependencies(update_ops): # Вычислить градиенты gvs = optimizer.compute_gradients(train_loss_op) # Обрезает значения тензора до заданных значений min и max. capped_gvs = [(tf.clip_by_value(grad, -GRADIENT_THRESH, GRADIENT_THRESH), var) for grad, var in gvs] # Применение обработанныx градиентoв train_op = optimizer.apply_gradients(capped_gvs, global_step=global_step) # ===================Model evaluation \ Оценка модели # ===================Validation performance # Прогнать валидационную выборку, указать, что это переиспользование и что не обучение. encoded_val_batch, _ = tabnet_forest_covertype.encoder(feature_val_batch, reuse=True, is_training=False) # Классификация результирующего набора. _, prediction_val = tabnet_forest_covertype.classify(encoded_val_batch, reuse=True) # Возвращает индекс и приводит тензор к новому типу. predicted_labels = tf.cast(tf.argmax(prediction_val, 1), dtype=tf.int32) # Сверка значений. val_eq_op = tf.equal(predicted_labels, label_val_batch) # Вычисляет среднее значение элементов по измерениям тензора. val_acc_op = tf.reduce_mean(tf.cast(val_eq_op, dtype=tf.float32)) # Сумма всех проверенных значений. tf.summary.scalar("Val accuracy", val_acc_op) # ===================Test performance # Прогнать тестовую выборку, указать, что не переиспользуется и что не обучение. encoded_test_batch, _ = tabnet_forest_covertype.encoder(feature_test_batch, reuse=True, is_training=False) # Классификация результирующего набора. _, prediction_test = tabnet_forest_covertype.classify(encoded_test_batch, reuse=True) # Возвращает индекс и приводит тензор к новому типу. predicted_labels = tf.cast(tf.argmax(prediction_test, 1), dtype=tf.int32) # Сверка значений test_eq_op = tf.equal(predicted_labels, label_test_batch) # Вычисляет среднее значение элементов по измерениям тензора. test_acc_op = tf.reduce_mean(tf.cast(test_eq_op, dtype=tf.float32)) # Сумма всех проверенных значений. tf.summary.scalar("Test accuracy", test_acc_op) # ===================Training setup # Наименование модели. model_name = "tabnet_forest_covertype_model" # Задание глобальных и локальных параметров. init = tf.initialize_all_variables() init_local = tf.local_variables_initializer() # Возвращает операцию, которая инициализирует все таблицы графика по умолчанию. init_table = tf.tables_initializer(name="Initialize_all_tables") # Сохранение всех значений переменных. saver = tf.train.Saver() # Объединяет все информацию, собранную по графу по умолчанию summaries = tf.summary.merge_all() # запись логов в заданную директорию with tf.Session() as sess: summary_writer = tf.summary.FileWriter("./tflog/" + model_name, sess.graph) # Этот метод выполняет один "шаг" вычисления TensorFlow, запуская необходимый фрагмент графа для выполнения # каждой операции и оценки каждого тензора в выборках, # подставляя значения в feed_dict для соответствующих входных значений. sess.run(init) sess.run(init_local) sess.run(init_table) # Учимся, Валидируем, Проверяем sess.run(train_iter.initializer) sess.run(val_iter.initializer) sess.run(test_iter.initializer) # Запуск записи результатов # for step in range(1, MAX_STEPS + 1): if step % DISPLAY_STEP == 0: _, train_loss, merged_summary = sess.run( [train_op, train_loss_op, summaries]) summary_writer.add_summary( merged_summary, step ) # Запись результатов работы на каждом шаге кратный 0. Шаг, величина ошибки. print("Step " + str(step) + " , Training Loss = " + "{:.4f}".format(train_loss)) else: _ = sess.run( train_op ) # Запуск расчета работы с оптимизированными градиентами. if step % VAL_STEP == 0: feed_arr = [ vars()["summaries"], vars()["val_acc_op"], vars()["test_acc_op"] ] # Запись валидационных результатов и результатов на тестовой выборке. val_arr = sess.run(feed_arr) merged_summary = val_arr[0] val_acc = val_arr[1] print("Step " + str(step) + " , Val Accuracy = " + "{:.4f}".format(val_acc)) summary_writer.add_summary(merged_summary, step) # сохранение точек и параметров. if step % SAVE_STEP == 0: saver.save(sess, "./checkpoints/" + model_name + ".ckpt")