def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") if os.path.isfile("configs/example.json"): config = process_config("configs/example.json") else: config = process_config("../configs/example.json") # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.Session() # create your data generator data = DataGenerator(config) # create an instance of the model you want model = ExampleModel(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = ExampleTrainer(sess, model, data, config, logger) # load model if exists model.load(sess) # here you train your model trainer.train()
def run_multi(): # Get the arguments args = get_args() config, _ = get_config_from_json(args.config) values_sn = config.exp.vals values_train = config.exp.vals values_init = config.exp.vals params = config.exp.params section = config.exp.section # Spectral Normalization for i in values_sn: # Mode for j in values_train: # Init for k in values_init: config[section][params[0]] = i config[section][params[1]] = j config[section][params[2]] = k config.exp.name = args.experiment + "_{}{}{}".format(int(i), int(j), int(k)) process_config(config) create_dirs( [ config.log.summary_dir, config.log.checkpoint_dir, config.log.step_generation_dir, config.log.log_file_dir, config.log.codebase_dir, ] ) # Copy the model code and the trainer code to the experiment folder run(config, args) tf.reset_default_graph()
def main(): global config try: args = get_args() config = process_config(args.config) # args.config = 'test_example.json' print(args.config) print(config.learning_rate) print(config.display_step) print(config.checkpoint_dir) print(config.summary_dir) print(config.training_epochs) except: print("Missing argument") exit(0) # create_dirs([config.summary_dir, config.checkpoint_dir]) already created dirs data = input_data.read_data_sets("/tmp/data/", one_hot=True) # sess = tf.Session() with tf.Session() as sess: model = MnistLogisticModel(config) logger = Logger(sess, config) trainer = MnistLogisticTrainer(sess, model, data, config, logger) trainer.train()
def __init__(self, cc_path, rc_path, ac_path): # Here comes all the initialization required # Initialize the models self.cc = process_config(cc_path) self.rc = process_config(rc_path) self.ac = process_config(ac_path) self.cae, self.c_s, self.rnn, self.r_s, self.actions, self.a_s = self.load_models( self.cc, self.rc, self.ac) self.current_frame = np.zeros((128, 128)) # Create the video stream thread try: t = threading.Thread(target=self.getVideoData) t.start() print("thread started") except: print("Something went wrong trying to start getVideoData")
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) os.environ['CUDA_VISIBLE_DEVICES'] = config.CUDA_VISIBLE_DEVICES # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.Session() # create your data generator data = DataGenerator(config) # create an instance of the model you want model = AutoEncodingConv2dBNModel(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = MyModelTrainer(sess, model, data, config, logger) #load model if exists model.load(sess) # here you train your model trainer.train()
def main(): try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) create_dirs([config.summary_dir, config.checkpoint_dir]) sess = tf.Session() data = DataGenerator(config) model = mlp(config) logger = Logger(sess, config) trainer = ExampleTrainer(sess, model, data, config, logger) model.load(sess) #trainer파일을 확인하면 trainer.train()과 새로 작성한 trainer.test()의 차이를 확인할 수 있다. #y는 테스트데이터의 실제 ppa, result는 학습된 모델의 추정 ppa값을 리스트로 받아온다. #result는 세션의 return이 [1][데이터개수]의 2차원 리스트의 형태이고 [0][i]로 각 input의 결과를 확인할 수 있다 y, result = trainer.test() cnt = 0 print(result[0]) for i in range(len(y)): #실제값-추측값을 실제값으로 나누어 오차10%내의 데이터의 수를 센다 if (abs(y[i] - float(result[0][i])) / y[i] <= 0.1): cnt += 1 print('10% 내외로 예측한 데이터는 ', cnt / len(y), '% 이다')
def generate_labels(): # capture the config path from the run arguments then process the json configuration file try: args = get_args() config = process_config(args.config) except ValueError: print("Missing or invalid arguments") exit(0) print('Creating the data loader...') data_loader = DataLoader(config.labels_generator.paths) data = data_loader.get_data() print('Creating the Preprocessor...') preprocessor = CorexPreprocessor(data, config) preprocessor.prepare_data() print('Loading and evaluating the Model...') model = CorexModel(config, preprocessor, load=True) trainer = CorexTrainer(model, preprocessor.get_data()) top_docs_df = trainer.get_top_documents( config.labels_generator.evaluate.extract_topics, preprocessor.get_raw_corpus(), config.labels_generator.evaluate.extraction_quantile) top_docs_df.to_csv(config.labels_generator.paths.save_data_path, index=False)
def main(): arg_parser = argparse.ArgumentParser(description="") arg_parser.add_argument( 'config', metavar='config_json_file', default=None, help="Configuration file in JSON format." ) args = arg_parser.parse_args() # parse config file config = process_config(args.config) # Create the agent and pass all the configuration to it and run agent_class = globals()[config["agent"]] agent = agent_class(config) # visualize training set agent.visualize_set() # # train model agent.run() agent.finalize() # Create inference agent and pass the configuration to it and interpret iagent_class = globals()[config["inference_agent"]] iagent = iagent_class(config) # plot learning rate, accuracy, loss graphs and misclassified images with gradcam iagent.show_per_class_accuracy() iagent.plot_lr_graph() iagent.plot_accuracy_graph() iagent.plot_loss_graph() iagent.show_misclassified_images()
def main(): # capture the config path from the run arguments # then process the json configration file config = process_config( 'F:/deep_learning/relaynet_tensorflow/configs/relaynet.json') # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session gpu_config = tf.ConfigProto() gpu_config.gpu_options.allow_growth = True sess = tf.Session(config=gpu_config) config.learning_rate = np.concatenate( (1e-1 * np.ones(20), 1e-2 * np.ones(20), 1e-2 * np.ones(20))) # network_fn = ReLayNet(10, config=config, scope='relaynet02') network_fn = ReLayNet(config=config) # create instance of the model you want model = ReLayNetModel(config, network_fn) # create your data generator data = RetinalDataset(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and path all previous components to it trainer = ReLayNetTrainer(sess, model, data, config, logger) # here you train your model trainer.train()
def main(memory_frac, config): tf_config = tf.ConfigProto() tf_config.gpu_options.per_process_gpu_memory_fraction = memory_frac set_session(tf.Session(config=tf_config)) if config is None: config_path = constants.LSTM_CONFIG else: config_path = config # process the json configuration file config = process_config(config_path) # create the experiments dirs create_dirs([ config.callbacks.tensorboard_log_dir, config.callbacks.checkpoint_dir, config.callbacks.model_dir, config.callbacks.config_dir, config.callbacks.result_dir ]) print('Create the data generator.') data_loader = LSTMDataLoader(config) print('Create the model.') model = LSTMModel(config) copyfile(inspect.getfile(model.__class__), os.path.join(config.callbacks.model_dir, "model.py")) copyfile(config_path, os.path.join(config.callbacks.config_dir, "config.json")) print('Create the trainer') trainer = LSTMTrainer(model.build_model(), data_loader, config) print('Start training the model.') trainer.train()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.Session() # create an instance of the model you want model = MyModel(config) # create your data generator data = DataGenerator(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = SimpleTrainer(sess, model, data, config, logger) saverExternal = tf.train.Saver(var_list=tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='external')) saverExternal.restore(sess, "experiments/model_8/model8.ckpt_2") # here you train your model trainer.train() trainer.validate()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() json_file = '../configs/example.json' # config = process_config(args.config) config = process_config(json_file) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.compat.v1.Session() # create your data generator data = DataGenerator(config) data.generate_data() # create an instance of the model you want model = ExampleModel(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = ExampleTrainer(sess, model, data, config, logger) #load model if exists model.load(sess) # here you train your model trainer.train() # here you evaluate your model evaluator = Evaluator(trainer.sess, trainer.model, data, config, logger) evaluator.evaluate() evaluator.analysis_results()
def main(): # capture the config path from the run arguments # then process the json configration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.Session() # create instance of the model you want model = CapsuleNet(config) # create your data generator data = MNISTLoader(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and path all previous components to it trainer = CapsuleNetTrainer(sess, model, data, config, logger) # here you train your model trainer.train()
def main(): # capture the config path from the run argments # then process the json configuration file try: args = get_args() config = process_config(args.config) except Exception as err: print("Missing or invalid arguments {}".format(err)) exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.Session() # create your data generator data_loader = MnistData(config) # create an instance of the model you want model = MnistModel(config, data_loader) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = MnistTrainer(sess, model, config, logger, data_loader) # load model if exists model.load(sess) # here you train your model trainer.train()
def main(): # capture the config path from the run arguments # then process the json configuration fill try: args = get_args() config = process_config(args.config) # create the experiments dirs create_dirs([config.callbacks.tensorboard_log_dir, config.callbacks.checkpoint_dir]) print('Create the data generator.') data_loader = factory.create("data_loader."+config.data_loader.name)(config) print('Create the model.') model = factory.create("models."+config.model.name)(config) if config.skip_train!=True: print('Create the trainer') trainer = factory.create("trainers."+config.trainer.name)(model.model, data_loader.get_train_data(), config) print('Start training the model.') trainer.train() # evaluator = factory.create("evaluators."+config.evaluator.name)(model.model, data_loader.get_test_data(), config) # evaluator.evaluate() evaluator = factory.create("evaluators."+config.evaluator.name)(model.model, data_loader.get_test_data(), config) result, y = evaluator.evaluate() result_idx = np.argmax(result,axis=1) y_idx = np.argmax(y,axis=1) print(classification_report(result_idx, y_idx)) except Exception as e: print(e) sys.exit(1)
def main(model_dir): tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True set_session(tf.Session(config=tf_config)) config = os.path.join(model_dir, "config.json") config_path = config # process the json configuration file config = process_config(config_path) config.trainer.batch_size = 1 print('Create the data generator.') data_loader = factory.create("data_loader." + config.data_loader.name)(config) print('Create the model.') model = factory.create("models." + config.model.name)(config) print('Create the trainer') trainer = BaseTrain(model.build_model(), data_loader, config) # checkpoint_path = os.path.join(constants.ROOT_FOLDER, config.callbacks.checkpoint_dir, config.exp.name + ".hdf5") checkpoint_path = os.path.join(model_dir, "model.hdf5") model.load(checkpoint_path) scores_dict = trainer.evaluate() for metric in scores_dict: open(os.path.join(model_dir, metric + ".txt"), "w").write(str(scores_dict[metric]))
def main(): """ capture the config path from the run arguments then processw the json configuration file """ try: args = get_args() config = process_config(args.config) except FileNotFoundError as e: print('missing or invalid arguments') exit(0) return create_dirs([ config.callbacks.tensorboard_log_dir, config.callbacks.checkpoint_dir ]) print('Get dataframe from csv') train_df, test_df = get_df_from_config(config) train_df['class'] = train_df['class'].astype('str') train_df = train_df[['img_file', 'class']] test_df = test_df[['img_file']] print('Create model') model = Resnet50Model(config) print('Create trainer') trainer = Resnet50Trainer(model, train_df, config) print('Start training model') trainer.train_with_cv(k=4)
def main(): # try: # args = get_args() # config = process_config(args.config) # # except: # print("missing or invalid arguments") # exit(0) config_file = "configs/config.json" config = process_config(config_file) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # embed_path = "data/glove.trimmed.{}.npz".format(config.embedding_size) # config.embed_path = embed_path # vocab_path = "data/vocab.dat" # config.vocab_path = vocab_path # create tensorflow session sess = tf.Session() # create data generator data = DataGenerator(config) sequence_length = data.sequence_length() vocab_size = data.get_vocab_size() # create an instance of the model model = CNNClassifier(config, sequence_length, vocab_size) #load model if exists model.load(sess) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = Trainer(sess, model, data, config, logger) trainer.train()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) print('Create the data generator.') data_generator = DataGenerator(config) print('Create the model.') model = MultiLabelConvModel(config, data_generator.get_word_index()) print('Create the trainer') trainer = MultiLabelConvModelTrainer(model.model, data_generator.get_train_data(), config) print('Start training the model.') trainer.train() print('Visualize the losses') trainer.visualize()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create your data generator data = DataGenerator(config) # create tensorflow session tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True sess = tf.Session(config=tf_config) K.set_session(sess) # create an instance of the model you want model = GolfBallModel(config, data) # load model if exists model.load(sess) # create tensorboard logger logger = Logger(sess, config) if config.do_training: # create trainer and pass all the previous components to it trainer = GolfBallTrainer(sess, model, data, config, logger) # here you train your model trainer.train() if config.do_predict: GolfBallPrediction(sess, model, data, config)
def main(): try: args = get_args() config = process_config(args.config) except Exception as e: print("missing or invalid arguments") print(e) exit(0) create_dirs([config.summary_dir, config.checkpoint_dir]) conf = tf.ConfigProto() conf.gpu_options.allow_growth = True sess = tf.Session(config=conf) with sess.as_default(): data_loader = USegNetLoader(config) model = USegNetModel(data_loader, config) logger = DefinedSummarizer( sess, summary_dir=config.summary_dir, scalar_tags=[ 'train/loss_per_epoch', 'train/dice_per_epoch', 'train/iou_per_epoch', 'eval/loss_per_epoch', 'eval/dice_per_epoch', 'eval/iou_per_epoch' ]) trainer = USegNetTrainer(sess, model, config, logger, data_loader) trainer.train()
def main(): try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) create_dirs([config.summary_dir, config.checkpoint_dir]) sess = tf.Session() data_loader = notMNISTDataLoaderNumpy(config) model = notMNISTModel(data_loader, config) logger = DefinedSummarizer(sess, summary_dir=config.summary_dir, scalar_tags=[ 'train/loss_per_epoch', 'train/acc_per_epoch', 'test/loss_per_epoch', 'test/acc_per_epoch', 'val/acc_per_epoch', 'val/loss_per_epoch' ]) trainer = notMNISTTrainer(sess, model, config, logger, data_loader) trainer.train()
def main(): # capture the config path from the run arguments # then process the json configuration fill try: args = get_args() config = process_config(args.config) amp, sr = librosa.load(config.predictor.predict_file_path, sr=8000) amp = audio_norm(amp) # normalize if amp.shape[0] < config.model.duration * sr: # 왼쪽 오른쪽 똑같은 크기로 reflect amp = np.pad(amp, int(np.ceil((10 * sr - amp.shape[0]) / 2)), mode='reflect') amp = amp[:config.model.duration * sr] data = np.expand_dims(amp, axis=0) data = np.expand_dims(data, axis=-1) print('Create the model.') model = factory.create("models." + config.model.name)(config) predictor = factory.create("predictors." + config.predictor.name)( model.model, data, config) predictor.predict() sys.stdout.flush() except Exception as e: print(e) sys.stdout.flush()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([ config.callbacks.tensorboard_log_dir, config.callbacks.checkpoint_dir ]) print('Create the data generator.') data_loader = ConvFashionMnistDataLoader(config) print('Create the model.') model = ConvMnistModel(config) print('Create the trainer') trainer = FashionMnistModelTrainer(model.model, data_loader.get_train_data(), config) print('Start training the model.') trainer.train()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir, config.visual_dir]) models = { 'noise_model1': NoiseModel.build_model1(config), 'noise_model2': NoiseModel.build_model2(config), 'noise_model3': NoiseModel.build_model3(config) } print('Create the data generator.') data_generator = DataLoader(config) print('Create the model.') model = models[config.exp_name] print('Create the trainer') trainer = NoiseModelTrainer(model, data_generator.get_train_data(), config) print('Start training the model.') trainer.train() print('Visualize the losses') trainer.visualize()
def main(): args = get_args() config = process_config(args.config) # create the experiments dirs create_dirs([config.cache_dir, config.model_dir, config.log_dir, config.img_dir]) # logging to the file and stdout logger = get_logger(config.log_dir, config.exp_name) # Intialize wandb model run = wandb.init(project="SemiSupervised", config=args) run.save() args.run_name = wandb.run.name # fix random seed to reproduce results random.seed(config.random_seed) logger.info('Random seed: {:d}'.format(config.random_seed)) if config.method in ['src', 'jigsaw', 'rotate']: model = AuxModel(config, logger) else: raise ValueError("Unknown method: %s" % config.method) src_loader, val_loader = get_train_val_dataloader(config.datasets.src) # test_loader = get_test_dataloader(config.datasets.test) test_loader = None tar_loader = None if config.datasets.get('tar', None): tar_loader = get_target_dataloader(config.datasets.tar) if config.mode == 'train': model.train(src_loader, tar_loader, val_loader, test_loader)
def main(): # Capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) Model = import_class(args.config, "model") Trainer = import_class(args.config, "trainer") except: print("Missing or invalid arguments") exit(0) # Create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # Create a tensorflow session sess = tf.InteractiveSession() # Create an instance of the model specified model = Model(config) # Load model if it exists model.load(sess) # Create the data generator data = DataGenerator(config) # Create tensorboard logger logger = Logger(sess, config) # Create trainer and pass all the previous components to it trainer = Trainer(sess, model, data, config, logger) # Train the model trainer.train() print("Training complete!") sess.close()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except Exception: print("missing or invalid arguments") raise # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session configSess = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) configSess.gpu_options.allow_growth = True sess = tf.Session(config=configSess) # create your data generator data = DataGenerator(config) # create an instance of the model you want try: ModelInit = all_models[config.model] model = ModelInit(config) except AttributeError: raise # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = NetworkTrainer(sess, model, data, config, logger) # load model if exists model.load(sess, args.checkpoint_nb) # here you train your model trainer.train()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except Exception as e: print("missing or invalid arguments %s" % e) exit(0) os.environ["CUDA_VISIBLE_devices"] = config.gpu import tensorflow as tf # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session gpuconfig = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) gpuconfig.gpu_options.visible_device_list = config.gpu sess = tf.Session(config=gpuconfig) # create your data generator data = DataGenerator(config) # create an instance of the model you want model = invariant_basic(config, data) # create trainer and pass all the previous components to it trainer = Trainer(sess, model, data, config) # load model if exists model.load(sess) # here you train your model trainer.train()
def main(): try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # config = process_config('configs/imc.json') create_dirs([config.summary_dir, config.checkpoint_dir]) sess = tf.Session() # create instance of the model you want model = IMCModel(config) # load model if exist model.load(sess) # create your data generator imc_data = DataGenerator(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and path all previous components to it trainer = IMCTrainer(sess, model, imc_data, config, logger) # # here you train your model trainer.train() # trainer.recognize() recogflag = input("recognize your image now? image in {} Y/N".format( config.dir_af)) if recogflag == "Y" or recogflag == "y" or recogflag == '': recognize_image(config.dir_af, config.checkpoint_dir, config.graph_dir, config.image_size) else: print("Process end!")
def __init__(self, config="configs/urbanSound.json"): if isinstance(config, str): config = process_config(config) super(SoundDataLoader, self).__init__(config) # get the absolute path of the datastore currentDrive, path = os.path.splitdrive(os.getcwd()) self.dataFolder = os.path.join( currentDrive, os.path.sep.join(path.split(os.path.sep)[:-1]), "Datastore", "Acoustical") self.attributes = pd.read_csv(os.path.join(self.dataFolder, self.config.testplan), sep=";") if not os.path.isfile( os.path.join(self.dataFolder, self.config.features)): print("features.csv not found...") print("\nLoading features...") self.createFeatureFrame(self.dataFolder) else: self.features = pd.read_csv(os.path.join(self.dataFolder, self.config.features), sep=";") self.data = None pd.options.mode.chained_assignment = None # default='warn'
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.summary_dir, config.checkpoint_dir]) # create tensorflow session sess = tf.Session() # create an instance of the model you want model = MyModel(config) # create your data generator data = DataGenerator(config) # create tensorboard logger logger = Logger(sess, config) # create trainer and pass all the previous components to it trainer = SimpleTrainer(sess, model, data, config, logger) # here you train your model trainer.train() trainer.validate()
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.tensorboard_log_dir, config.checkpoint_dir, "val_test"]) print('Create the data generator.') if hasattr(config, "data_set"): if config.data_set == "face_data_77": data_loader = FaceLandmark77DataLoader(config) else: data_loader = SimpleMnistDataLoader(config) else: data_loader = SimpleMnistDataLoader(config) print('Create the model.') if hasattr(config, "model_name"): if config.model_name == "mobile_net": model = MobileNetV2Model(config) else: model = SimpleMnistModel(config) else: model = SimpleMnistModel(config) print(model.model.input_names) print([out.op.name for out in model.model.outputs]) return if hasattr(config, "best_checkpoint"): model.load(config.best_checkpoint) frozen_graph = freeze_session(K.get_session(), output_names=[out.op.name for out in model.model.outputs]) ckpt_path = Path(config.best_checkpoint) tf.train.write_graph(frozen_graph, str(ckpt_path.parent), ckpt_path.with_suffix(".pb").name, as_text=False)
def main(): # capture the config path from the run arguments # then process the json configuration file try: args = get_args() config = process_config(args.config) except: print("missing or invalid arguments") exit(0) # create the experiments dirs create_dirs([config.tensorboard_log_dir, config.checkpoint_dir]) print('Create the data generator.') if hasattr(config, "data_set"): if config.data_set == "face_data_77": data_loader = FaceLandmark77DataLoader(config) else: data_loader = SimpleMnistDataLoader(config) else: data_loader = SimpleMnistDataLoader(config) print('Create the model.') if hasattr(config, "model_name"): if config.model_name == "mobile_net": model = MobileNetV2Model(config) else: model = SimpleMnistModel(config) else: model = SimpleMnistModel(config) print('Create the trainer') trainer = SimpleMnistModelTrainer(model.model, data_loader, config) print('Start training the model.') trainer.train()