def __init__(self): self.conf = ModelConfig() self.seq_max_len, self.input_size, self.num_class = cal_model_para( filename=self.conf.training_data) self._init_varible() self.loss_op, self.optimizer_op, self.accuracy_op, self.predict_op = self.define_operator( )
def create(configuration, input, reuse=False, is_training=True): input_size = configuration.data().input_size() num_classes = configuration.settings().num_classes() dropout = configuration.settings().dropout() conf = ModelConfig() with tf.variable_scope('ConvNet', reuse=reuse): # przeskalowanie do wymaganego rozmiaru x = tf.reshape(input, shape=[-1, input_size[0], input_size[1], 1]) activation = Model.__get_activation(conf.conv_1_activation) # tworzenie warstw conv1 = tf.layers.conv2d(x, conf.conv_1_filters, conf.conv_1_size, activation=activation, padding=conf.conv_1_padding) pool1 = tf.layers.max_pooling2d(conv1, conf.pool_1_size, conf.pool_1_size) conv2 = tf.layers.conv2d(pool1, conf.conv_2_filters, conf.conv_2_size, activation=activation, padding=conf.conv_2_padding) pool2 = tf.layers.max_pooling2d(conv2, conf.conv_2_size, conf.conv_2_size) fc1 = tf.contrib.layers.flatten(pool2) fc1 = tf.layers.dense(fc1, conf.full_size) fc1 = tf.layers.dropout(fc1, rate=dropout, training=is_training) out = tf.layers.dense(fc1, num_classes) # out = tf.nn.dropout(out, dropout) # out = tf.nn.softmax(out) return out
def execute(model_config_dict): model_config: ModelConfig = ModelConfig(model_config_dict) print(model_config) print() train_df = data_loader.load_train_csv(model_config.train_data_path) model_config.set_defaults(train_df) if model_config.problem_type == ProblemType.REGRESSION: for strategy in ['mean', 'median']: pipeline: GeneralPipeline = GeneralPipeline( model_config, DummyRegressor(strategy), train_df) evaluation.evaluate(pipeline, train_df, model_config.goal_metric) if model_config.problem_type == ProblemType.CLASSIFICATION: for strategy in ['stratified', 'most_frequent', 'uniform']: pipeline: GeneralPipeline = GeneralPipeline( model_config, DummyClassifier(strategy), train_df) evaluation.evaluate(pipeline, train_df, model_config.goal_metric) pipeline: GeneralPipeline = GeneralPipeline(model_config, model_config.model_class(), train_df) # evaluation.evaluate(pipeline, main_df, model_config.goal_metric) df = pd.read_csv('./example_data/test.csv') pipeline.train_predict(train_df, df)
def __save_results(self, accuracies, output_model_folder, saver, tf_session): # utworzenie modelu z datą w nazwie ( data wstawiana jest poza tą metodą) os.makedirs(output_model_folder) # zapisanie modelu saver.save(tf_session, output_model_folder + '/model.ckpt') # zapisanie listy wyników w poszczególnych iteracji with open(output_model_folder + '/accuracy.txt', 'w+') as file: for acc in accuracies: file.write(str(acc) + '\n') # zapisanie parametrów wykorzystanych do uczenia modelu with open(output_model_folder + "/settings.txt", 'w+') as file: for field, value in ModelConfig().get_config().items(): file.write(field + ": " + str(value) + '\n')
from __future__ import absolute_import from __future__ import division from __future__ import print_function import tensorflow as tf import numpy as np import tfplot import tfplot.summary from train_config import TrainConfig from model_config import ModelConfig # config instance generation train_config = TrainConfig() model_config = ModelConfig() def argmax_2d(tensor): # input format: BxHxWxD assert len(tensor.get_shape()) == 4 with tf.name_scope(name='argmax_2d', values=[tensor]): tensor_shape = tensor.get_shape().as_list() # flatten the Tensor along the height and width axes flat_tensor = tf.reshape(tensor, (tensor_shape[0], -1, tensor_shape[3])) # argmax of the flat tensor
# @Author : [email protected] # @FileName: dataset_augument.py # @Software: PyCharm # @updated by Jaewook Kang 20181010 for tf-tiny-pose-estimation import math import random import cv2 import numpy as np from tensorpack.dataflow.imgaug.geometry import RotationAndCropValid from enum import Enum # custom addition for tf-tiny-pose-estimation from model_config import ModelConfig model_config = ModelConfig(setuplog_dir=None) _network_w = int(model_config._input_size) _network_h = _network_w _scale = int(model_config._input_size / model_config._output_size) class CocoPart(Enum): Top = 0 Neck = 1 RShoulder = 2 RElbow = 3 RWrist = 4 LShoulder = 5 LElbow = 6 LWrist = 7
def train(dataset_train, dataset_test): model_config = ModelConfig() train_config = TrainConfig() dataset_handle = tf.placeholder(tf.string, shape=[]) dataset_train_iterator = dataset_train.make_one_shot_iterator() # dataset_test_iterator = dataset_test.make_one_shot_iterator() inputs = tf.placeholder(dtype=model_config.dtype, shape=[ train_config.batch_size, model_config._input_size, model_config._input_size, model_config.input_chnum ]) true_heatmap = tf.placeholder(dtype=model_config.dtype, shape=[ train_config.batch_size, model_config._output_size, model_config._output_size, model_config.output_chnum ]) # model building ========================= # < complete codes here > modelbuilder = ModelBuilder(model_config=model_config) pred_heatmap = modelbuilder.get_model(model_in=inputs, scope='model') # traning ops ============================================= # < complete codes here > loss_heatmap = train_config.loss_fn(true_heatmap - pred_heatmap) / train_config.batch_size loss_regularizer = tf.losses.get_regularization_loss() loss_op = loss_heatmap + loss_regularizer global_step = tf.Variable(0, trainable=False) batchnum_per_epoch = np.floor(train_config.train_data_size / train_config.batch_size) lr_op = tf.train.exponential_decay( learning_rate=train_config.learning_rate, global_step=global_step, decay_steps=train_config.learning_rate_decay_step, decay_rate=train_config.learning_rate_decay_rate, staircase=True) opt_op = train_config.opt_fn(learning_rate=lr_op, name='opt_op') train_op = opt_op.minimize(loss_op, global_step) # For Tensorboard =========================================== file_writer = tf.summary.FileWriter(logdir=train_config.tflogdir) file_writer.add_graph(tf.get_default_graph()) tb_summary_loss_train = tf.summary.scalar('loss_train', loss_op) tb_summary_loss_test = tf.summary.scalar('loss_test', loss_op) tb_summary_lr = tf.summary.scalar('learning_rate', lr_op) # training ============================== init_var = tf.global_variables_initializer() print('[train] training_epochs = %s' % train_config.training_epochs) print('------------------------------------') # build dataset ======================== # inputs_test_op, true_heatmap_test_op = dataset_test_iterator.get_next() inputs_train_op, true_heatmap_train_op = dataset_train_iterator.get_next() with tf.Session() as sess: # Run the variable initializer sess.run(init_var) # train_handle = sess.run(dataset_train_iterator.string_handle()) # test_handle = sess.run(dataset_test_iterator.string_handle()) for epoch in range(train_config.training_epochs): inputs_train, true_heatmap_train = sess.run( [inputs_train_op, true_heatmap_train_op]) # inputs_valid,true_heatmap_valid = sess.run([inputs_test_op,true_heatmap_test_op]) train_start_time = time.time() # train model # _,loss_train = sess.run([train_op,loss_op], # feed_dict={dataset_handle: train_handle, # modelbuilder.dropout_keeprate:model_config.output.dropout_keeprate}) _, loss_train = sess.run( [train_op, loss_op], feed_dict={ inputs: inputs_train, true_heatmap: true_heatmap_train, modelbuilder.dropout_keeprate: model_config.output.dropout_keeprate }) train_elapsed_time = time.time() - train_start_time global_step_eval = global_step.eval() if train_config.display_step == 0: continue elif global_step_eval % train_config.display_step == 0: print('[train] curr epochs = %s' % epoch) # # test model # loss_test = loss_op.eval(feed_dict={dataset_handle: test_handle, # modelbuilder.dropout_keeprate: 1.0}) # # loss_test = loss_op.eval( feed_dict={inputs: inputs_valid, # true_heatmap: true_heatmap_valid, # modelbuilder.dropout_keeprate: 1.0}) # tf summary summary_loss_train = tb_summary_loss_train.eval( feed_dict={ inputs: inputs_train, true_heatmap: true_heatmap_train, modelbuilder.dropout_keeprate: 1.0 }) # summary_loss_test = tb_summary_loss_test.eval( feed_dict={inputs: inputs_valid, # true_heatmap: true_heatmap_valid, # modelbuilder.dropout_keeprate: 1.0}) # # summary_loss_train = tb_summary_loss_train.eval(feed_dict={dataset_handle: train_handle, # modelbuilder.dropout_keeprate:1.0}) # # summary_loss_test = tb_summary_loss_test.eval(feed_dict={dataset_handle: test_handle, # modelbuilder.dropout_keeprate: 1.0}) summary_lr = tb_summary_lr.eval() file_writer.add_summary(summary_loss_train, global_step_eval) # file_writer.add_summary(summary_loss_test,global_step_eval) file_writer.add_summary(summary_lr, global_step_eval) print('At step = %d, train elapsed_time = %.1f ms' % (global_step_eval, train_elapsed_time)) print("Training set loss (avg over batch)= %.2f " % (loss_train)) # print("Test set Err loss (total batch)= %.2f %%" % (loss_test)) print("--------------------------------------------") print("Training finished!") file_writer.close()
train_config.ckpt_dir + 'model.ckpt', global_step=global_step_eval) tf.logging.info("Global step - %s: Model saved in file: %s" % (global_step_eval, ckpt_save_path)) print("Training finished!") file_writer_train.close() file_writer_valid.close() if __name__ == '__main__': tf.logging.set_verbosity(tf.logging.INFO) train_config = TrainConfig() model_config = ModelConfig(setuplog_dir=train_config.setuplog_dir) preproc_config = PreprocessingConfig( setuplog_dir=train_config.setuplog_dir) train_config.send_setuplog_to_gcp_bucket() preproc_config.show_info() # dataloader instance gen dataloader_train, dataloader_valid = \ [DataLoader( is_training =is_training, data_dir =DATASET_DIR, transpose_input =False, train_config = train_config, model_config = model_config, preproc_config = preproc_config,
def main(): sys.path.insert(0, TF_MODULE_DIR) sys.path.insert(0, EXPORT_DIR) sys.path.insert(0, COCO_DATALOAD_DIR) # # configuration file # config = configparser.ConfigParser() # # config_file = "mv2_cpm.cfg" # if os.path.exists(config_file): # config.read(config_file) # params = {} # for _ in config.options("Train"): # params[_] = eval(config.get("Train", _)) # # os.environ['CUDA_VISIBLE_DEVICES'] = params['visible_devices'] train_config = TrainConfig() model_config = ModelConfig(setuplog_dir=train_config.setuplog_dir) preproc_config = PreprocessingConfig( setuplog_dir=train_config.setuplog_dir) # ================================================ # =============== dataset pipeline =============== # ================================================ # dataloader instance gen dataloader_train, dataloader_valid = \ [DataLoader( is_training =is_training, data_dir =DATASET_DIR, transpose_input =False, train_config =train_config, model_config =model_config, preproc_config =preproc_config, use_bfloat16 =False) for is_training in [True, False]] dataset_train = dataloader_train.input_fn() # dataset_valid = dataloader_valid.input_fn() data = dataset_train.repeat() # data = dataset_train # ================================================ # ============== configure model ================= # ================================================ model_builder = HourglassModelBuilder() model_builder.build_model() model = model_builder.model model.summary() model.compile( optimizer=tf.optimizers.Adam(0.001, epsilon=1e-8), #'adam', loss=tf.losses.MeanSquaredError(), metrics=['accuracy']) #tf.metrics.Accuracy # ================================================ # =============== setup output =================== # ================================================ current_time = datetime.now().strftime("%Y%m%d%H%M%S") output_path = os.path.join(PROJ_HOME, "outputs") # output model file(.hdf5) model_path = os.path.join(output_path, "models") if not os.path.exists(model_path): os.mkdir(model_path) checkpoint_path = os.path.join(model_path, "hg_" + current_time + ".hdf5") #".ckpt" check_pointer = tf.keras.callbacks.ModelCheckpoint(checkpoint_path, save_weights_only=False, verbose=1) # output tensorboard log log_path = os.path.join(output_path, "logs") log_path = os.path.join(log_path, "hg_" + current_time) tensorboard = tf.keras.callbacks.TensorBoard(log_path) # ================================================ # ==================== train! ==================== # ================================================ model.fit(data, epochs=300, steps_per_epoch=100, callbacks=[check_pointer, tensorboard]) # steps_per_epoch=100,