def main():
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 = CNNModel(config, data_generator.get_word_index())
print("Trainer initiatise")
trainer = ModelTrainer(model.model, data_generator.get_train_data(),
config)
print("Training Start")
trainer.train()
print("Visualization of loss and accuracy")
trainer.visualize("FastText +CNN")
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():
# 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])
# create tensorflow session
sess = tf.Session()
# create your data generator
data = DataGenerator(config)
# use mnist dataset
data.load_mnist()
# create an instance of the cnn model
model = CnnMnistModel(config)
# create tensorboard logger
logger = Logger(sess, config)
# create trainer and pass all the previous components to it
trainer = CnnMnistTrainer(sess, model, data, config, logger)
#load model if exists
model.load(sess)
# here you train your model
trainer.train()
def run_trail(config):
# capture the config path from the run arguments
# then process the json configuration file
# try:
# except:
# print("missing or invalid arguments")
# exit(0)
if config.gpu_mode is True and not torch.cuda.is_available(): #虽然开启gpu模式，但是找不到GPU
raise Exception("No GPU found, please run without --gpu_mode=False")
# create an instance of the model you want
# model = Net(config)
# model = torch.nn.DataParallel(Net(config), device_ids=[0, 1])
model = torch.nn.DataParallel(Net(config))
# set the logger
log_dir = os.path.join(config.save_dir, 'logs_'+config.exp_name)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
# logger = Logger(log_dir)
logger = None
train_indices, test_indices = shuffle()
# create your data generator
data_train = DataGenerator(config, 'train').load_dataset()
# create your data generator
data_test = DataGenerator(config, 'test').load_dataset()
# create trainer and pass all the previous components to it
trainer = Trainer(model, config, data_train, logger, data_test)
trainer.train_test()
def __init__(self, config):
super(GEO1dDataLoader, self).__init__(config)
'Create the training data generator'
print('Creating the training data generator')
tr_ids = os.listdir(self.config.data_loader.train_dir)
tr_labels_str = list(map(self.label_image, tr_ids))
tr_ids = list(map(self.png_to_id, tr_ids))
tr_labels = dict(zip(tr_ids, tr_labels_str))
self.train_generator = DataGenerator(tr_ids, tr_labels,
self.config.data_loader.train_dir,
batch_size=self.config.trainer.batch_size,
dim=[self.config.model.input_shape[0],self.config.model.input_shape[1]],
n_channels=1,
n_classes=self.config.model.output_shape,
shuffle=False,
class_mode=self.config.model.loss)
'Create the testing data generator'
print('Creating the testing data generator')
te_ids = os.listdir(self.config.data_loader.test_dir)
te_labels_str = list(map(self.label_image, te_ids))
te_ids = list(map(self.png_to_id, te_ids))
te_labels = dict(zip(te_ids, te_labels_str))
self.test_generator = DataGenerator(te_ids, te_labels,
self.config.data_loader.test_dir,
batch_size=self.config.trainer.batch_size,
dim=[self.config.model.input_shape[0],self.config.model.input_shape[1]],
n_channels=1,
n_classes=self.config.model.output_shape,
shuffle=False,
class_mode=self.config.model.loss)
def train():
def monkey_patched_train(self):
"""
Train from current epoch to number of epochs in the config.
Call train_epoch for each epoch, and increase cur_epoch_tensor.
"""
tf.logging.info('Training...')
begin_epoch = self.model.cur_epoch_tensor.eval(sess)
# initialize training data set
self.sess.run([self.data_loader.data_set_init_ops['train']])
for cur_epoch in range(begin_epoch, begin_epoch + self.config.epochs):
self.train_epoch()
self.sess.run(self.model.increment_cur_epoch_tensor)
'''validation'''
if cur_epoch % self.config.epochs_per_validation == 0:
'''validate'''
validater.validate()
'''recover training environment'''
self.sess.run([self.data_loader.data_set_init_ops['train']])
train_config = process_config("configs/train_with_validation.json")
validate_config = process_config("configs/validate.json")
g = tf.Graph()
with g.as_default():
# train data
train_data_gen = DataGenerator()
# validate data
validate_data_gen = DataGenerator()
data_loader = DataSetLoader(train_config, {
'train': train_data_gen,
'validate': validate_data_gen
},
default_set_name='train')
next_data = data_loader.next_data
# TODO
# create an instance of the model you want
model = FCNetModel(train_config, next_data)
with tf.Session() as sess:
# create tensorboard logger
train_logger = Logger(sess, train_config)
# create trainer and pass all the previous components to it
trainer = ExampleTrainer(sess, model, data_loader, train_config,
train_logger)
# create tensorboard logger
validate_logger = Logger(sess, validate_config)
# create validater and pass all the previous components to it
validater = ExampleValidater(sess, model, data_loader,
validate_config, validate_logger)
# load model if exists
model.load(sess)
# make a monkey patch to model
trainer.train = monkey_patched_train.__get__(
trainer, ExampleTrainer)
# here you train your model
trainer.train()
# save model
model.save(sess)
def test_data():
config_file = 'configs/config.json'
config = process_config(config_file)
generator = DataGenerator(config)
x, y = generator.generateBatch(2)
print(x[0].shape)
# print(generator.dictionary[''])
print(generator.dictionary[' '])
print(generator.dictionary['['])
print(generator.dictionary[']'])
print(generator.dictionary['，'])
print(generator.dictionary['。'])
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("An error occurred during processing the configuration file")
print(e)
exit(0)
# create the experiments dirs
create_dirs([
config.summary_dir, config.checkpoint_dir, config.config_file_dir
])
# create tensorflow session
sess = tf.Session()
# create your data generator
train_data = DataGenerator(config,
sess,
old_tfrecords=config.old_tfrecords,
train=True)
test_data = DataGenerator(config,
sess,
old_tfrecords=config.old_tfrecords,
train=False)
model = EncodeProcessDecode_v2(config)
# create tensorboard logger
logger = Logger(sess, config)
# create trainer and pass all the previous components to it
trainer = MPCTrainer(sess,
model,
train_data,
test_data,
config,
logger,
N=10)
# load model if exists
model.load(sess)
results = trainer.mpc()
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 = 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, config, logger, data_loader)
# load model if exists
model.load(sess)
# here you train your model
trainer.train()
def summarize(self):
"""Creating summaries for feature importance and other attributes of the graph
:return: graph summaries of the weights and mse error for training and testing process
:rtype: a scalar Tensor of type string.
"""
features_map = DataGenerator.get_features_names()
# getting the first weights of shape (filter_size, filter_size, filter_size, input_channel, out_channel)
w_zeroconv = self.sess.graph.get_tensor_by_name(
'convolution/conv_layer_0/w:0')
# just splitting the weights by each feature, axis points to the input_channel split
feature_weights = tf.split(w_zeroconv,
w_zeroconv.shape[-2].value,
axis=3)
# features_importance = tf.reduce_sum(tf.abs(w_zeroconv), reduction_indices = [1,2,4], name = "feature_importance")
summaries = tf.summary.merge(
(tf.summary.histogram('weights', w_zeroconv),
*(tf.summary.histogram(f'weights_{feature_name}', value)
for feature_name, value in zip(features_map, feature_weights)),
tf.summary.scalar(
'mse', self.sess.graph.get_tensor_by_name('training/mse:0')),
tf.summary.scalar(
'mse',
self.sess.graph.get_tensor_by_name('training/loss:0'))))
return summaries
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():
tmp = FLAGS.params # necessary to get updated FLAGS values
config = process_config("../configs/config.json", FLAGS.flag_values_dict())
create_dirs([config.summary_dir, config.checkpoint_dir])
print(config)
sess = tf.Session()
# Data process and generator
print("Data Start Loading!", datetime.now())
data = DataGenerator(config)
print("Data Loaded!", datetime.now())
# Create model
# model_name = FLAGS.model_name
model = S2S_TAtt(data.handle, config, data.next_batch)
print("Model Initialized!", datetime.now())
if config.tensorboard == 1:
# Tensorboard logger
logger = Logger(sess, config)
print("Logger Initialized!", datetime.now())
# Model trainer
trainer = S2STrainer(sess, model, data, config, logger)
else:
trainer = S2STrainer(sess, model, data, config)
print("Trainer Initialized!", datetime.now())
# Training processs
if FLAGS.train:
trainer.train()
with h5py.File("./result.h5", "w") as f:
f.create_dataset("predictions",
data=trainer.predictions,
compression="lzf")
f.create_dataset("groundtruth",
data=trainer.ground_truth,
compression="lzf")
f.create_dataset("weights", data=trainer.weights, compression="lzf")
def main():
#-c 'json파일경로'로 받아온 json경로를 config객체에 저장한다
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()
# 데이터를 불러온다. 전달한 config객체는 batch사이즈로 데이터를 쪼개기위해 사용된다
data = DataGenerator(config)
# 사용할 모델의 개형을 불러온다. 해당 프로젝트에는 input사이즈외에 참고하지 않았지만
#본래 모델의 깊이,모양,loss함수,optimizer 등 config 값에 따라 다른 모델을 불러올 수 있다
model = mlp(config)
# 학습진행과 저장을 담당하는 logger객체를 생성한다
logger = Logger(sess, config)
#먼저 생성한 학습에 필요한 세션,모델,데이터셋,설정,logger를 전달해 학습 준비를 마친다
trainer = ExampleTrainer(sess, model, data, config, logger)
#기존에 학습중이던 같은 모델이 있다면 해당 모델을 이어서 학습한다
model.load(sess)
# here you train your model
trainer.train()
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 = ExampleModel(config)
# create your data generator
data = DataGenerator(config)
# create tensorboard logger
logger = Logger(sess, config)
# create trainer and path all previous components to it
trainer = ExampleTrainer(sess, model, data, config, logger)
# here you train your model
trainer.train()
def eval():
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
# Get Model
model_types = import_module('models.' + config.architecture + '_model')
Model = getattr(model_types, 'Model')
# create tensorflow session
sess = tf.Session()
# create your data generator
data_loader = DataGenerator(config, eval_phase=True, eval_on_test_data=True)
# create instance of the model you want
model = Model(data_loader, config)
# create trainer and path all previous components to it
trainer = Trainer(sess, model, config, None, data_loader, load_best=True)
# here we evaluate on the test dataset
test_loss, test_cer = trainer.test(tqdm_enable=True)
print('\nTest set Loss:', test_loss)
print('Test set CER:', round(test_cer*100, 2), '%')
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 train(self, max_iters, restore=False):
"""Network training loop."""
data_layer = DataGenerator(self.roidb, self.imdb.nrof_classes,
self.data)
total_loss, model_loss, rpn_cross_entropy, rpn_loss_box = self.model.build_loss(
ohem=cfg.TRAIN.OHEM)
summary_op, log_image, log_image_data, log_image_name = self.logger.init_summary(
rpn_reg_loss=rpn_loss_box,
rpn_cls_loss=rpn_cross_entropy,
model_loss=model_loss,
total_loss=total_loss)
train_op, lr = self.get_train_op(total_loss)
# intialize variables
self.sess.run(tf.global_variables_initializer())
restore_iter = self.load_model(restore)
fetch_list = [
total_loss, model_loss, rpn_cross_entropy, rpn_loss_box,
summary_op, train_op
]
print(restore_iter, max_iters)
for _iter in range(restore_iter, max_iters, cfg.TRAIN.EPOCH_SIZE):
losses = self.train_epoch(_iter, lr, data_layer, fetch_list)
print('iter: %d / %d, total loss: %.4f, model loss: %.4f, rpn_loss_cls: %.4f, rpn_loss_box: %.4f, lr: %f' % \
(_iter+cfg.TRAIN.EPOCH_SIZE, max_iters, losses[0], losses[1], losses[2], losses[3], losses[5].eval()))
self.logger.summarize(losses[4], self.global_step.eval())
self.save(_iter + cfg.TRAIN.EPOCH_SIZE)
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 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():
# 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(argv=sys.argv):
"""
main function
:param argv: Incoming parameters
:return:
"""
# parse and load parameters
parameters = load_parameters('parameters.json')
arguments = parse_arguments(argv[1:])
parameters = utils.parse_params(arguments, parameters)
utils.print_parametes('parameters', parameters)
# get model parameters
model_parametes = get_model_parametes(parameters)
# log file
log_file = os.path.join(parameters["output_dir"], "log_%d" % time.time())
log_f = utils.get_log_f(log_file)
# data generator
data_generator = DataGenerator(parameters)
# create, train and infer model
with tf.Session() as sess:
model = ExampleModel(model_parametes)
trainer = ExampleTrainer(sess, model, data_generator, parameters,
log_f)
trainer.train()
# inference
inference = ExampleInference(sess, model, data_generator, parameters,
log_f)
inference.infer()
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 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():
# 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():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
config.old_tfrecords = args.old_tfrecords
config.normalize_data = False
except Exception as e:
print("An error occurred during processing the configuration file")
print(e)
exit(0)
# create the experiments dirs
create_dirs(
[config.summary_dir, config.checkpoint_dir, config.config_file_dir])
# create tensorflow session
sess = tf.Session()
# create your data generator
#train_data = DataGenerator(config, sess, train=True)
test_data = DataGenerator(config, sess, train=False)
next_element = test_data.get_next_batch()
dir_name = "test"
while True:
try:
features = sess.run(next_element)
features = convert_dict_to_list_subdicts(features,
config.test_batch_size)
features = features[0]
summaries = create_target_summary_dicts(features)
dir_path = check_exp_folder_exists_and_create(features, dir_name)
if dir_path is not None:
export_summary_images(config=config,
summaries_dict_images=summaries,
dir_path=dir_path)
except tf.errors.OutOfRangeError:
print("done exporting")
break
def main():
# capture the config path from the run arguments
# then process the json configration file
# try:
data_loader = DataLoader(data_dir, config)
data_loader.load_directory('.tif')
data_loader.create_np_arrays()
data_loader.create_data_label_pairs()
preptt = PrepTrainTest(config, data_loader)
for data_label_pair in data_loader.data_label_pairs:
x_data = data_label_pair[0][data_loader]
y_true = data_label_pair[1][data_loader.data_label_pairs[i][1][:, :, 0]]
preptt.add_data(x_data, y_true)
# Create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir, config.input_dir])
# Create tensorflow session
sess = tf.Session()
# Create instance of the model you want
model = PopModel(config)
# Load model if exist
model.load(sess)
# Create Tensorboard logger
logger = Logger(sess, config)
logger.log_config()
# Create your data generator
data = DataGenerator(config, preptraintest = preptt)
data.create_traintest_data()
# Create trainer and path all previous components to it
trainer = PopTrainer(sess, model, data, config, logger)
# Train model
trainer.train()
def train_and_eval(self, config):
# serving_feature_spec = tf.feature_column.make_parse_example_spec(self._get_feature_columns())
# serving_input_receiver_fn = tf.estimator.export.build_parsing_serving_input_receiver_fn(serving_feature_spec)
# exporter = tf.estimator.BestExporter(
# name="best_exporter",
# serving_input_receiver_fn=serving_input_receiver_fn,
# exports_to_keep=5)
tf.estimator.train_and_evaluate(
self.model,
train_spec=tf.estimator.TrainSpec(
input_fn=DataGenerator('train', config).get_dataset),
eval_spec=tf.estimator.EvalSpec(input_fn=DataGenerator(
'validation', config).get_dataset,
steps=1000,
start_delay_secs=0,
throttle_secs=1))
def test(self, config):
predictions = self.model.predict(
DataGenerator(config.mode, config).get_dataset)
cls = [p['classes'] for p in predictions]
cls_pred = np.array(cls, dtype='int').squeeze()
df = pd.read_csv(config.submission_file)
df['AdoptionSpeed'] = cls_pred
df.to_csv(config.submission_file)
return cls_pred
def main():
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(-1)
sess = tf.Session()
if (args.model == 'dcgan'):
from models.dcgan_model import DCGANModel
from trainers.dcgan_trainer import DCGANTrain
create_dirs([config.summary_dir, config.checkpoint_dir, config.resized_data_dir])
data = DataGenerator(config.data_dir, config.resized_data_dir, config.t_size, config.batch_size)
model = DCGANModel(config)
logger = Logger(sess, config)
trainer = DCGANTrain(sess, model, data, config, logger)
model.load(sess)
trainer.train()
elif (args.model == 'cyclegan'):
from models.cyclegan_model import CycleGANModel
from trainers.cyclegan_trainer import CycleGANTrain
create_dirs([config.summary_dir, config.checkpoint_dir, config.resized_data_dir_a, config.resized_data_dir_b])
dataA = DataGenerator(config.data_dir_a, config.resized_data_dir_a, config.t_size, config.batch_size)
dataB = DataGenerator(config.data_dir_b, config.resized_data_dir_b, config.t_size, config.batch_size)
model = CycleGANModel(config)
logger = Logger(sess, config)
trainer = CycleGANTrain(sess, model, [dataA, dataB], config, logger)
model.load(sess)
trainer.train()
else:
print("model doesn't exist")
exit(-1)