def test_model_generator_config_copy(self):
class MyArchFactory(tpmaf.ArchitectureFactory):
def new_architecture(self):
return tpma.ModdedLeNet5Net(channels=1)
arch = MyArchFactory()
# setup the xforms to ensure we can test the callables
def data_xform(x):
return x * x
def label_xform(y):
return y * y * y
data = tpmd.DataManager(self.experiment_path,
self.train_file,
self.clean_test_file,
triggered_test_file=self.triggered_file,
data_transform=data_xform,
label_transform=label_xform,
file_loader='image',
shuffle_train=True,
shuffle_clean_test=False,
shuffle_triggered_test=False)
num_models = 1
mgc1 = tpmc.ModelGeneratorConfig(arch, data, self.model_save_dir,
self.stats_save_dir, num_models)
mgc2 = copy.deepcopy(mgc1)
self.assertEqual(mgc1, mgc2)
optim='adam',
objective='cross_entropy_loss',
early_stopping=early_stopping_argin,
train_val_split=a.train_val_split)
reporting_params = tpmc.ReportingConfig(
num_batches_per_logmsg=500,
num_epochs_per_metric=1,
num_batches_per_metrics=default_nbpvdm,
tensorboard_output_dir=a.tensorboard_dir,
experiment_name=experiment_cfg['name'])
optimizer_cfg = tpmc.DefaultOptimizerConfig(training_params,
reporting_params)
cfg = tpmc.ModelGeneratorConfig(arch,
data_obj,
model_save_dir,
stats_save_dir,
num_models,
optimizer=optimizer_cfg,
experiment_cfg=experiment_cfg,
parallel=True)
# may also provide lists of run_ids or filenames are arguments to ModelGeneratorConfig to have more control
# of saved model file names; see RunnerConfig and ModelGeneratorConfig for more information
modelgen_cfgs.append(cfg)
model_generator = mg.ModelGenerator(modelgen_cfgs)
start = time.time()
model_generator.run()
print("\nTime to run: ", (time.time() - start) / 60 / 60, 'hours')
def train_models(top_dir, data_folder, experiment_folder, experiment_list, model_save_folder, stats_save_folder,
early_stopping, train_val_split, tensorboard_dir, gpu, uge, uge_dir):
"""
Given paths to the experiments and specifications to where models and model statistics should be saved, create
triggered models for each experiment in the experiment directory.
:param top_dir: (str) path to top level directory for text classification data and models are to be stored
:param data_folder: (str) name of folder containing the experiments folder
:param experiment_folder: (str) name of folder containing the experiments used to generate models
:param model_save_folder: (str) name of folder under which models are to be saved
:param stats_save_folder: (str) name of folder under which model training information is to be saved
:param tensorboard_dir: (str) name of folder under which tensorboard information is to be saved
:param gpu: (bool) use a gpu in training
:param uge: (bool) use a Univa Grid Engine (UGE) to generate models
:param uge_dir: (str) working directory for UGE models
:return: None
"""
class MyArchFactory(tpm_af.ArchitectureFactory):
def new_architecture(self, input_dim=25000, embedding_dim=100, hidden_dim=256, output_dim=1,
n_layers=2, bidirectional=True, dropout=0.5, pad_idx=-999):
return tpta.EmbeddingLSTM(input_dim, embedding_dim, hidden_dim, output_dim,
n_layers, bidirectional, dropout, pad_idx)
def arch_factory_kwargs_generator(train_dataset_desc, clean_test_dataset_desc, triggered_test_dataset_desc):
# Note: the arch_factory_kwargs_generator returns a dictionary, which is used as kwargs input into an
# architecture factory. Here, we allow the input-dimension and the pad-idx to be set when the model gets
# instantiated. This is useful because these indices and the vocabulary size are not known until the
# vocabulary is built.
output_dict = dict(input_dim=train_dataset_desc.vocab_size,
pad_idx=train_dataset_desc.pad_idx)
return output_dict
# get all available experiments from the experiment root directory
experiment_path = os.path.join(top_dir, data_folder, experiment_folder)
modelgen_cfgs = []
arch_factory_kwargs = dict(
input_dim=25000,
embedding_dim=100,
hidden_dim=256,
output_dim=1,
n_layers=2,
bidirectional=True,
dropout=0.5
)
for i in range(len(experiment_list)):
experiment_cfg = experiment_list[i]
data_obj = dm.DataManager(experiment_path,
experiment_cfg['train_file'],
experiment_cfg['clean_test_file'],
data_type='text',
triggered_test_file=experiment_cfg['triggered_test_file'],
shuffle_train=True,
data_configuration=dc.TextDataConfiguration(
max_vocab_size=arch_factory_kwargs['input_dim'],
embedding_dim=arch_factory_kwargs['embedding_dim']))
num_models = 5
if uge:
if gpu:
device = torch.device('cuda')
else:
device = torch.device('cpu')
else:
device = torch.device('cuda' if torch.cuda.is_available() and gpu else 'cpu')
default_nbpvdm = None if device.type == 'cpu' else 500
early_stopping_argin = tpmc.EarlyStoppingConfig() if early_stopping else None
training_params = tpmc.TrainingConfig(device=device,
epochs=10,
batch_size=64,
lr=1e-3,
optim='adam',
objective='BCEWithLogitsLoss',
early_stopping=early_stopping_argin,
train_val_split=train_val_split)
reporting_params = tpmc.ReportingConfig(num_batches_per_logmsg=100,
num_epochs_per_metric=1,
num_batches_per_metrics=default_nbpvdm,
tensorboard_output_dir=tensorboard_dir,
experiment_name=experiment_cfg['name'])
lstm_optimizer_config = tpmc.TorchTextOptimizerConfig(training_cfg=training_params,
reporting_cfg=reporting_params,
copy_pretrained_embeddings=True)
optimizer = tptto.TorchTextOptimizer(lstm_optimizer_config)
# There seem to be some issues w/ using the DataParallel w/ RNN's (hence, parallel=False).
# See here:
# - https://discuss.pytorch.org/t/pack-padded-sequence-with-multiple-gpus/33458
# - https://pytorch.org/docs/master/notes/faq.html#pack-rnn-unpack-with-data-parallelism
# - https://github.com/pytorch/pytorch/issues/10537
# Although these issues are "old," the solutions provided in these forums haven't yet worked
# for me to try to resolve the data batching error. For now, we suffice to using the single
# GPU version.
cfg = tpmc.ModelGeneratorConfig(MyArchFactory(),
data_obj,
model_save_folder,
stats_save_folder,
num_models,
arch_factory_kwargs=arch_factory_kwargs,
arch_factory_kwargs_generator=arch_factory_kwargs_generator,
optimizer=optimizer,
experiment_cfg=experiment_cfg,
parallel=False,
save_with_hash=True)
# may also provide lists of run_ids or filenames as arguments to ModelGeneratorConfig to have more control
# of saved model file names; see RunnerConfig and ModelGeneratorConfig for more information
modelgen_cfgs.append(cfg)
if uge:
if gpu:
q1 = tpmc.UGEQueueConfig("gpu-k40.q", True)
q2 = tpmc.UGEQueueConfig("gpu-v100.q", True)
q_cfg = tpmc.UGEConfig([q1, q2], queue_distribution=None)
else:
q1 = tpmc.UGEQueueConfig("htc.q", False)
q_cfg = tpmc.UGEConfig(q1, queue_distribution=None)
working_dir = uge_dir
try:
shutil.rmtree(working_dir)
except IOError:
pass
model_generator = ugemg.UGEModelGenerator(modelgen_cfgs, q_cfg, working_directory=working_dir)
else:
model_generator = mg.ModelGenerator(modelgen_cfgs)
start = time.time()
model_generator.run()
logger.debug("Time to run: ", (time.time() - start) / 60 / 60, 'hours')