def initialize(hparams, train_dataset, val_dataset, test_dataset, protein_profile, cuda_devices=None, mode="regression"): frozen_models = FrozenModels() # create network view_lbl = hparams["view"] create_comp_model = {"ecfp4": create_ecfp_net, "ecfp8": create_ecfp_net, "weave": create_weave_net, "gconv": create_gconv_net, "gnn": create_gnn_net}.get(view_lbl) comp_model = create_comp_model(hparams) # pt_embeddings = create_torch_embeddings(frozen_models_hook=frozen_models, # np_embeddings=protein_embeddings) comp_net_pcnn = ProtCnnForward(prot2vec=Prot2Vec(protein_profile=protein_profile, vocab_size=hparams["prot"]["vocab_size"], embedding_dim=hparams["prot"]["dim"], batch_first=True), prot_cnn_model=ProteinCNNAttention(dim=hparams["prot"]["dim"], window=hparams["prot"]["window"], num_layers=hparams["prot"][ "prot_cnn_num_layers"]), comp_model=comp_model) p = 2 * hparams["prot"]["dim"] layers = [comp_net_pcnn] # for dim in hparams["hdims"]: # # layers.append(nn.Linear(p, dim)) # # layers.append(nn.BatchNorm1d(dim)) # # layers.append(nn.ReLU()) # # layers.append(nn.Dropout(hparams["dprob"])) # p = dim # Output layer layers.append(nn.Linear(in_features=p, out_features=hparams["output_dim"])) model = nn.Sequential(*layers) print("Number of trainable parameters = {}".format(count_parameters(model))) if cuda: model = model.cuda() # data loaders train_data_loader = DataLoader(dataset=train_dataset, batch_size=hparams["tr_batch_size"], shuffle=True, collate_fn=lambda x: x) val_data_loader = DataLoader(dataset=val_dataset, batch_size=hparams["val_batch_size"], shuffle=False, collate_fn=lambda x: x) test_data_loader = None if test_dataset is not None: test_data_loader = DataLoader(dataset=test_dataset, batch_size=hparams["test_batch_size"], shuffle=False, collate_fn=lambda x: x) # optimizer configuration optimizer = { "adadelta": torch.optim.Adadelta, "adagrad": torch.optim.Adagrad, "adam": torch.optim.Adam, "adamax": torch.optim.Adamax, "asgd": torch.optim.ASGD, "rmsprop": torch.optim.RMSprop, "Rprop": torch.optim.Rprop, "sgd": torch.optim.SGD, }.get(hparams["optimizer"].lower(), None) assert optimizer is not None, "{} optimizer could not be found" # filter optimizer arguments optim_kwargs = dict() optim_key = hparams["optimizer"] for k, v in hparams.items(): if "optimizer__" in k: attribute_tup = k.split("__") if optim_key == attribute_tup[1] or attribute_tup[1] == "global": optim_kwargs[attribute_tup[2]] = v optimizer = optimizer(model.parameters(), **optim_kwargs) # metrics metrics = [mt.accuracy_score, mt.roc_auc_score, mt.recall_score, mt.f1_score, mt.precision_score] return model, optimizer, {"train": train_data_loader, "val": val_data_loader, "test": test_data_loader}, metrics, frozen_models
def initialize(hparams, train_dataset, val_dataset, test_dataset, cuda_devices=None, mode="regression"): # create network model = create_integrated_net(hparams) print("Number of trainable parameters = {}".format( count_parameters(model))) if cuda: model = model.cuda() # data loaders train_data_loader = DataLoader(dataset=train_dataset, batch_size=hparams["tr_batch_size"], shuffle=True, collate_fn=lambda x: x) val_data_loader = DataLoader(dataset=val_dataset, batch_size=hparams["val_batch_size"], shuffle=False, collate_fn=lambda x: x) test_data_loader = None if test_dataset is not None: test_data_loader = DataLoader( dataset=test_dataset, batch_size=hparams["test_batch_size"], shuffle=False, collate_fn=lambda x: x) # optimizer configuration optimizer = { "adadelta": torch.optim.Adadelta, "adagrad": torch.optim.Adagrad, "adam": torch.optim.Adam, "adamax": torch.optim.Adamax, "asgd": torch.optim.ASGD, "rmsprop": torch.optim.RMSprop, "Rprop": torch.optim.Rprop, "sgd": torch.optim.SGD, }.get(hparams["optimizer"].lower(), None) assert optimizer is not None, "{} optimizer could not be found" # filter optimizer arguments optim_kwargs = dict() optim_key = hparams["optimizer"] for k, v in hparams.items(): if "optimizer__" in k: attribute_tup = k.split("__") if optim_key == attribute_tup[1] or attribute_tup[ 1] == "global": optim_kwargs[attribute_tup[2]] = v optimizer = optimizer(model.parameters(), **optim_kwargs) # metrics metrics = [ mt.Metric(mt.rms_score, np.nanmean), mt.Metric(mt.concordance_index, np.nanmean), mt.Metric(mt.pearson_r2_score, np.nanmean) ] return model, optimizer, { "train": train_data_loader, "val": val_data_loader, "test": test_data_loader }, metrics
def initialize(hparams, train_dataset, val_dataset, test_dataset, cuda_devices=None, mode="regression"): # create networks generator = create_integrated_net(hparams) discriminator = create_discriminator_net(hparams) print("Number of trainable parameters: generator={}, discriminator={}". format(count_parameters(generator), count_parameters(discriminator))) if cuda: generator = generator.cuda() discriminator = discriminator.cuda() # data loaders train_data_loader = DataLoader(dataset=train_dataset, batch_size=hparams["tr_batch_size"], shuffle=True, collate_fn=lambda x: x) val_data_loader = DataLoader(dataset=val_dataset, batch_size=hparams["val_batch_size"], shuffle=False, collate_fn=lambda x: x) test_data_loader = None if test_dataset is not None: test_data_loader = DataLoader( dataset=test_dataset, batch_size=hparams["test_batch_size"], shuffle=False, collate_fn=lambda x: x) # filter optimizer arguments optimizer_disc = optimizer_gen = None for suffix in ["_gen", "_disc"]: key = "optimizer{}".format(suffix) # optimizer configuration optimizer = { "adadelta": torch.optim.Adadelta, "adagrad": torch.optim.Adagrad, "adam": torch.optim.Adam, "adamax": torch.optim.Adamax, "asgd": torch.optim.ASGD, "rmsprop": torch.optim.RMSprop, "Rprop": torch.optim.Rprop, "sgd": torch.optim.SGD, }.get(hparams[key].lower(), None) assert optimizer is not None, "{} optimizer could not be found" optim_kwargs = dict() optim_key = hparams[key] for k, v in hparams.items(): if "optimizer{}__".format(suffix) in k: attribute_tup = k.split("__") if optim_key == attribute_tup[1] or attribute_tup[ 1] == "global": optim_kwargs[attribute_tup[2]] = v if suffix == "_gen": optimizer_gen = optimizer(generator.parameters(), **optim_kwargs) else: optimizer_disc = optimizer(discriminator.parameters(), **optim_kwargs) # metrics metrics = [ mt.Metric(mt.rms_score, np.nanmean), mt.Metric(mt.concordance_index, np.nanmean), mt.Metric(mt.pearson_r2_score, np.nanmean) ] return (generator, discriminator), (optimizer_gen, optimizer_disc), \ {"train": train_data_loader, "val": val_data_loader, "test": test_data_loader}, metrics, hparams["weighted_loss"], hparams["neigh_dist"]