def train_model(path_config, args=None):
x = get_data1(path_config[args.model_name]['train'], args)
x_test = get_data2(path_config[args.model_name]['test'], args)
hyperparams = utils.get_model_hyperparams('lstm_vae')
dirpath_results = path_config[args.model_name]['results']
logger = utils.get_logger()
logger.info((x.shape, x_test.shape))
input_dim = x.shape[-1] # 13
timesteps = x.shape[1] # 3
# batch_size = 1
vae, enc, gen = create_lstm_vae(input_dim, timesteps,
hyperparams['batch_size'],
hyperparams['intermediate_dim'],
hyperparams['latent_dim'],
hyperparams['epsilon_std'])
ep = hyperparams["num_iterations"]
if args.is_demo:
ep = 1
vae.fit(x, x, epochs=ep)
vae.save_weights(dirpath_results + args.model_name + "_weights.h5")
logger.info(vae.summary())
# preds = vae.predict(x, batch_size=batch_size)
predicted = enc.predict(x_test, batch_size=hyperparams['batch_size'])
np.save(dirpath_results + args.model_name + "_predicted", predicted)
logger.info(predicted.shape)
def train_model(path_config, args=None):
if torch.cuda.is_available():
device = torch.device("cuda")
else:
device = torch.device("cpu")
logger = utils.get_logger()
hyperparams = utils.get_model_hyperparams("rnn")
learning_rate = hyperparams['learning_rate']
path_config = path_config['rnn']
dirpath_results = path_config['dirpath_rnn']
logger.info('Training RNN Phylum Classifier')
parameters = Parameters('phylum')
data_config = path_config['phylum']
train_data = load_data(data_config['train'])
valid_data = load_data(data_config['val'])
test_data = load_data(data_config['test'])
model = LSTMClassifier(parameters.embedding_dim, parameters.hidden_dim,
parameters.vocab_size, parameters.label_size,
device).to(device)
loss_fun = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
train(train_data, valid_data, test_data, model, loss_fun, optimizer,
dirpath_results, parameters, device, logger, args.is_demo,
'rnn_phylum')
logger.info('Training RNN Class Classifier')
parameters = Parameters('class')
data_config = path_config['class']
train_data = load_data(data_config['train'])
valid_data = load_data(data_config['val'])
test_data = load_data(data_config['test'])
model = LSTMClassifier(parameters.embedding_dim, parameters.hidden_dim,
parameters.vocab_size, parameters.label_size,
device).to(device)
loss_fun = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
train(train_data, valid_data, test_data, model, loss_fun, optimizer,
dirpath_results, parameters, device, logger, args.is_demo,
'rnn_class')
logger.info('Training RNN Order Classifier')
parameters = Parameters('order')
data_config = path_config['order']
train_data = load_data(data_config['train'])
valid_data = load_data(data_config['val'])
test_data = load_data(data_config['test'])
model = LSTMClassifier(parameters.embedding_dim, parameters.hidden_dim,
parameters.vocab_size, parameters.label_size,
device).to(device)
loss_fun = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
train(train_data, valid_data, test_data, model, loss_fun, optimizer,
dirpath_results, parameters, device, logger, args.is_demo,
'rnn_order')
def train_model(path_config, args):
path_config = path_config["cnn_qrcode"]
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
cnn_config = utils.get_model_hyperparams("cnn_qrcode")
for level in ["phylum", "class", "order"]:
cnn_config[level]["device"] = DEVICE
train_best_cnn_models(cnn_config, path_config, is_demo=args.is_demo)
def train_model(path_config, args=None):
if args.model_name == 'basic_kmer':
logger = utils.get_logger()
path_config = path_config['basic_kmer']
kmer_config = utils.get_model_hyperparams('basic_kmer')
models = [
SVC(**kmer_config['svm']),
RandomForestClassifier(**kmer_config['random_forest'])
]
if args.is_demo:
logger.info(
'WARNING! Running in Demo Mode. Because of the fact that SVM is taking a long time, '
+
'training will be run only for k=1 to 4. Training for combined data will not be run.'
)
kmer_config['kmax'] = 4
kmer_train_basic(models,
dirpath_kmer=path_config['dirpath_kmer'],
dirpath_output=path_config['results'],
kmin=kmer_config['kmin'],
kmax=kmer_config['kmax'],
is_demo=args.is_demo)
elif args.model_name == 'basic_vector':
path_config = path_config['basic_vector']
vector_train_basic(dirpath_vector=path_config['dirpath_vector'],
dirpath_output=path_config['results'])
elif args.model_name == 'basic_onehot':
path_config = path_config['basic_onehot']
onehot_train_basic(dirpath_vector=path_config['dirpath_onehot'],
dirpath_output=path_config['results'])
else:
raise ValueError('Basic ML model {} not supported'.format(
args.model_name))
def get_helper_params(path_config, args=None):
feature_type = args.model_name.replace('hybrid_vae_', '')
hyperparams = utils.get_model_hyperparams('hybrid_vae')
path_config = path_config[args.model_name]
return path_config, feature_type, hyperparams