elif args.model == 'auto':
network = None
########################################################################################################################
# define logger
logger = logging.getLogger()
# define tensorboard writer
exp_name = args.experiment+'_'+args.approach+'_'+str(args.seed)+'_'+args.id
# in polyaxon
if args.location == 'polyaxon':
from polyaxon_client.tracking import Experiment
experiment = Experiment()
output_path = experiment.get_outputs_path()
print("Output path: {}".format(output_path))
logger.info("Output path: {}".format(output_path))
writer = SummaryWriter(log_dir='/'+output_path)
else:
writer = SummaryWriter(log_dir='../logs/' + exp_name)
# Load date
print('Load data...')
data, taskcla, inputsize = dataloader.get(path='../dat/', seed=args.seed)
print('Input size =', inputsize, '\nTask info =', taskcla)
logger.info('Input size =', inputsize, '\nTask info =', taskcla)
# logging the experiment config
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--conv1_size', type=int, default=5)
parser.add_argument('--conv1_out', type=int, default=32)
parser.add_argument('--conv1_activation', type=str, default='relu')
parser.add_argument('--pool1_size', type=int, default=2)
parser.add_argument('--conv2_size', type=int, default=5)
parser.add_argument('--conv2_out', type=int, default=64)
parser.add_argument('--conv2_activation', type=str, default='relu')
parser.add_argument('--pool2_size', type=int, default=2)
parser.add_argument('--dropout', type=float, default=0.2)
parser.add_argument('--fc1_size', type=int, default=1024)
parser.add_argument('--fc1_activation', type=str, default='sigmoid')
parser.add_argument('--optimizer', type=str, default='adam')
parser.add_argument('--log_learning_rate', type=int, default=-3)
parser.add_argument('--batch_size', type=int, default=100)
parser.add_argument('--epochs', type=int, default=1)
args = parser.parse_args()
experiment = Experiment()
(x_train, y_train), (x_test, y_test) = load_mnist_data()
logger.info("loaded data (info)")
experiment.log_data_ref(data=x_train, data_name='x_train')
experiment.log_data_ref(data=y_train, data_name='y_train')
experiment.log_data_ref(data=x_test, data_name='x_test')
experiment.log_data_ref(data=y_test, data_name='y_test')
with tf.Session() as sess:
model = create_model(conv1_size=args.conv1_size,
conv1_out=args.conv1_out,
conv1_activation=args.conv1_activation,
pool1_size=args.pool1_size,
conv2_size=args.conv2_size,
conv2_out=args.conv2_out,
conv2_activation=args.conv2_activation,
pool2_size=args.pool2_size,
fc1_activation=args.fc1_activation,
fc1_size=args.fc1_size,
optimizer=args.optimizer,
log_learning_rate=args.log_learning_rate)
logger.info("model created")
if os.environ.get('POLYAXON_NO_OP', "0") != "1":
saver = tf.train.Saver(save_relative_paths=False)
saver.save_path = os.path.join(experiment.get_outputs_path(),
'model.ckpt')
logger.info(f"saving model at {str(saver.save_path)}")
else:
saver = tf.train.Saver(save_relative_paths=True)
saver.save_path = os.path.join('log_dir', 'model.ckpt')
logger.info(f"saving model at {str(saver.save_path)}")
sess.run(tf.global_variables_initializer())
logger.info("model initialized")
train_model(model,
x_train,
y_train,
batch_size=args.batch_size,
dropout=args.dropout,
epochs=args.epochs,
x_test=x_test,
y_test=y_test,
experiment=experiment)
logger.info("model trained")
model_save_path = saver.save(sess=sess, save_path=saver.save_path)
logger.info(f"model saved at {str(model_save_path)}")
accuracy = evaluate_model(model, x_test, y_test)
logger.info(f"model evaluated acc:{accuracy}")
# Polyaxon
experiment.log_metrics(accuracy=accuracy)
logger.info("done")
def gru_train(X_train, X_val, y_train, y_val, params):
tokenizer_obj = Tokenizer()
tokenizer_obj.fit_on_texts(X_train)
# save tokenizer
experiment = Experiment()
save_tokenizer = experiment.get_outputs_path() + '/GRU_tokenizer.pickle'
with open(save_tokenizer, 'wb') as handle:
pickle.dump(tokenizer_obj, handle, protocol=pickle.HIGHEST_PROTOCOL)
# for pad sequences
seq_length = params['seq_length']
#seq_length = int(max([len(s.split()) for s in X_train]))
# vocab size
vocab_size = len(tokenizer_obj.word_index) + 1
# tokenize
X_train_tokens = tokenizer_obj.texts_to_sequences(X_train)
X_val_tokens = tokenizer_obj.texts_to_sequences(X_val)
# pad sequences
X_train_pad = pad_sequences(X_train_tokens,
maxlen=seq_length,
padding='post')
X_train_pad = X_train_pad.astype(int)
X_val_pad = pad_sequences(X_val_tokens, maxlen=seq_length, padding='post')
X_val_pad = X_val_pad.astype(int)
model = Sequential()
model.add(
Embedding(input_dim=vocab_size,
output_dim=100,
input_length=seq_length))
if params['bidirectional'] == True:
model.add(Bidirectional(GRU(units=params['units'])))
else:
model.add(GRU(units=params['units']))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='Adam')
experiment = Experiment()
saved_path = experiment.get_outputs_path() + '/GRU_coronatweetmodel.h5'
es = EarlyStopping(monitor='val_loss', mode='min', patience=3)
cp = ModelCheckpoint(saved_path,
monitor='val_loss',
mode='max',
save_best_only=True)
model.fit(X_train_pad,
y_train,
epochs=params['epochs'],
batch_size=params['batch_size'],
validation_data=(X_val_pad, y_val),
callbacks=[es, cp])
return model, X_train_pad, X_val_pad
# Polyaxon
experiment = Experiment()
experiment.log_params(n_estimators=args.n_estimators,
max_features=args.max_features,
min_samples_leaf=args.min_samples_leaf)
(X, y) = load_data()
# Polyaxon
experiment.log_data_ref(data=X, data_name='dataset_X')
experiment.log_data_ref(data=y, data_name='dataset_y')
accuracies, classifier = model(X=X,
y=y,
n_estimators=args.n_estimators,
max_features=args.max_features,
min_samples_leaf=args.min_samples_leaf)
accuracy_mean, accuracy_std = (np.mean(accuracies), np.std(accuracies))
# Polyaxon
experiment.log_metrics(accuracy_mean=accuracy_mean, accuracy_std=accuracy_std)
outpath = os.path.join(experiment.get_outputs_path(), 'model.pkl')
with (open(outpath, 'wb')) as outfile:
pickle.dump(classifier, outfile)
