def cortex_benchmark(n_epochs=250, use_cuda=True, save_path='data/', show_plot=True): cortex_dataset = CortexDataset(save_path=save_path) vae = VAE(cortex_dataset.nb_genes) trainer_cortex_vae = UnsupervisedTrainer(vae, cortex_dataset, use_cuda=use_cuda) trainer_cortex_vae.train(n_epochs=n_epochs) trainer_cortex_vae.train_set.differential_expression_score( 'oligodendrocytes', 'pyramidal CA1', genes=["THY1", "MBP"]) trainer_cortex_vae.test_set.ll() # assert ~ 1200 vae = VAE(cortex_dataset.nb_genes) trainer_cortex_vae = UnsupervisedTrainer(vae, cortex_dataset, use_cuda=use_cuda) trainer_cortex_vae.corrupt_posteriors() trainer_cortex_vae.train(n_epochs=n_epochs) trainer_cortex_vae.uncorrupt_posteriors() trainer_cortex_vae.train_set.imputation_benchmark(verbose=(n_epochs > 1), save_path=save_path, show_plot=show_plot) n_samples = 10 if n_epochs == 1 else None # n_epochs == 1 is unit tests trainer_cortex_vae.train_set.show_t_sne(n_samples=n_samples) return trainer_cortex_vae
def cortex_benchmark(n_epochs=250, use_cuda=True, save_path="data/", show_plot=True): cortex_dataset = CortexDataset(save_path=save_path) vae = VAE(cortex_dataset.nb_genes) trainer_cortex_vae = UnsupervisedTrainer(vae, cortex_dataset, use_cuda=use_cuda) trainer_cortex_vae.train(n_epochs=n_epochs) couple_celltypes = (4, 5) # the couple types on which to study DE cell_idx1 = cortex_dataset.labels.ravel() == couple_celltypes[0] cell_idx2 = cortex_dataset.labels.ravel() == couple_celltypes[1] trainer_cortex_vae.train_set.differential_expression_score( cell_idx1, cell_idx2, genes=["THY1", "MBP"]) trainer_cortex_vae.test_set.reconstruction_error() # assert ~ 1200 vae = VAE(cortex_dataset.nb_genes) trainer_cortex_vae = UnsupervisedTrainer(vae, cortex_dataset, use_cuda=use_cuda) trainer_cortex_vae.corrupt_posteriors() trainer_cortex_vae.train(n_epochs=n_epochs) trainer_cortex_vae.uncorrupt_posteriors() trainer_cortex_vae.train_set.imputation_benchmark(save_path=save_path, show_plot=show_plot) n_samples = 10 if n_epochs == 1 else None # n_epochs == 1 is unit tests trainer_cortex_vae.train_set.show_t_sne(n_samples=n_samples) return trainer_cortex_vae
def test_iwae(save_path): import time dataset = CortexDataset(save_path=save_path) torch.manual_seed(42) vae = VAE(n_input=dataset.nb_genes, n_batch=dataset.n_batches).cuda() start = time.time() trainer = UnsupervisedTrainer(vae, gene_dataset=dataset, ratio_loss=True, k_importance_weighted=5, single_backward=True) trainer.train(n_epochs=10) stop1 = time.time() - start vae = VAE(n_input=dataset.nb_genes, n_batch=dataset.n_batches).cuda() start = time.time() trainer = UnsupervisedTrainer(vae, gene_dataset=dataset, ratio_loss=True, k_importance_weighted=5, single_backward=False) trainer.train(n_epochs=10) stop2 = time.time() - start print('Time single backward : ', stop1) print('Time all elements : ', stop2)
def benchmark(dataset, n_epochs=250, use_cuda=True): vae = VAE(dataset.nb_genes, n_batch=dataset.n_batches) trainer = UnsupervisedTrainer(vae, dataset, use_cuda=use_cuda) trainer.train(n_epochs=n_epochs) trainer.test_set.reconstruction_error() trainer.test_set.marginal_ll() return trainer
def unsupervised_training_one_epoch(dataset: GeneExpressionDataset): vae = VAE(dataset.nb_genes, dataset.n_batches, dataset.n_labels) trainer = UnsupervisedTrainer(vae, dataset, train_size=0.5, use_cuda=use_cuda) trainer.train(n_epochs=1)
def benchmark(dataset, n_epochs=250, use_cuda=True): vae = VAE(dataset.nb_genes, n_batch=dataset.n_batches) trainer = UnsupervisedTrainer(vae, dataset, use_cuda=use_cuda) trainer.train(n_epochs=n_epochs) trainer.test_set.ll(verbose=True) trainer.test_set.marginal_ll(verbose=True) return trainer
def test_gamma_de(): cortex_dataset = CortexDataset() cortex_vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches) trainer_cortex_vae = UnsupervisedTrainer(cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda) trainer_cortex_vae.train(n_epochs=2) full = trainer_cortex_vae.create_posterior(trainer_cortex_vae.model, cortex_dataset, indices=np.arange( len(cortex_dataset))) n_samples = 10 M_permutation = 100 cell_idx1 = cortex_dataset.labels.ravel() == 0 cell_idx2 = cortex_dataset.labels.ravel() == 1 full.differential_expression_score(cell_idx1, cell_idx2, n_samples=n_samples, M_permutation=M_permutation) full.differential_expression_gamma(cell_idx1, cell_idx2, n_samples=n_samples, M_permutation=M_permutation)
def run(self): n_epochs = 100 n_latent = 10 n_hidden = 128 n_layers = 2 net_data = self.data.copy() net_data.X = self.data.layers['counts'] del net_data.layers['counts'] net_data.raw = None # Ensure that the raw counts are not accidentally used # Define batch indices le = LabelEncoder() net_data.obs['batch_indices'] = le.fit_transform( net_data.obs[self.batch].values) net_data = AnnDatasetFromAnnData(net_data) vae = VAE(net_data.nb_genes, reconstruction_loss='nb', n_batch=net_data.n_batches, n_layers=n_layers, n_latent=n_latent, n_hidden=n_hidden) trainer = UnsupervisedTrainer(vae, net_data, train_size=1, use_cuda=False) trainer.train(n_epochs=n_epochs, lr=1e-3) full = trainer.create_posterior(trainer.model, net_data, indices=np.arange(len(net_data))) latent, _, _ = full.sequential().get_latent() self.data.obsm['X_emb'] = latent self.dump_to_h5ad("scvi")
def test_annealing_procedures(save_path): cortex_dataset = CortexDataset(save_path=save_path) cortex_vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches) trainer_cortex_vae = UnsupervisedTrainer( cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda, n_epochs_kl_warmup=1, ) trainer_cortex_vae.train(n_epochs=2) assert trainer_cortex_vae.kl_weight >= 0.99, "Annealing should be over" trainer_cortex_vae = UnsupervisedTrainer( cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda, n_epochs_kl_warmup=5, ) trainer_cortex_vae.train(n_epochs=2) assert trainer_cortex_vae.kl_weight <= 0.99, "Annealing should be proceeding" # iter trainer_cortex_vae = UnsupervisedTrainer( cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda, n_iter_kl_warmup=1, n_epochs_kl_warmup=None, ) trainer_cortex_vae.train(n_epochs=2) assert trainer_cortex_vae.kl_weight >= 0.99, "Annealing should be over"
def correct_scvi(Xs, genes): import torch use_cuda = True torch.cuda.set_device(1) from scvi.dataset.dataset import GeneExpressionDataset from scvi.inference import UnsupervisedTrainer from scvi.models import SCANVI, VAE from scvi.dataset.anndata import AnnDataset all_ann = [AnnDataset(AnnData(X, var=genes)) for X in Xs] all_dataset = GeneExpressionDataset.concat_datasets(*all_ann) vae = VAE(all_dataset.nb_genes, n_batch=all_dataset.n_batches, n_labels=all_dataset.n_labels, n_hidden=128, n_latent=30, n_layers=2, dispersion='gene') trainer = UnsupervisedTrainer(vae, all_dataset, train_size=0.99999) n_epochs = 100 #trainer.train(n_epochs=n_epochs) #torch.save(trainer.model.state_dict(), # 'data/harmonization.vae.pkl') trainer.model.load_state_dict(torch.load('data/harmonization.vae.pkl')) trainer.model.eval() full = trainer.create_posterior(trainer.model, all_dataset, indices=np.arange(len(all_dataset))) latent, batch_indices, labels = full.sequential().get_latent() return latent
def benchmark(dataset, n_epochs=250, use_cuda=True): vae = VAE(dataset.nb_genes, n_batch=dataset.n_batches) infer = VariationalInference(vae, dataset, use_cuda=use_cuda) infer.train(n_epochs=n_epochs) infer.ll('test') infer.imputation('test', rate=0.1) # assert ~ 2.1 return infer
def test_special_dataset_size(self): gene_dataset = GeneExpressionDataset() x = np.random.randint(1, 100, (17 * 2, 10)) y = np.random.randint(1, 100, (17 * 2, 10)) gene_dataset.populate_from_data(x) protein_data = CellMeasurement( name="protein_expression", data=y, columns_attr_name="protein_names", columns=np.arange(10), ) gene_dataset.initialize_cell_measurement(protein_data) # Test UnsupervisedTrainer vae = VAE( gene_dataset.nb_genes, n_batch=gene_dataset.n_batches, n_labels=gene_dataset.n_labels, ) trainer = UnsupervisedTrainer( vae, gene_dataset, train_size=0.5, use_cuda=False, data_loader_kwargs={"batch_size": 8}, ) trainer.train(n_epochs=1) # Test JVATrainer jvae = JVAE( [gene_dataset.nb_genes, gene_dataset.nb_genes], gene_dataset.nb_genes, [slice(None)] * 2, ["zinb", "zinb"], [True, True], n_batch=1, ) cls = Classifier(gene_dataset.nb_genes, n_labels=2, logits=True) trainer = JVAETrainer( jvae, cls, [gene_dataset, gene_dataset], train_size=0.5, use_cuda=False, data_loader_kwargs={"batch_size": 8}, ) trainer.train(n_epochs=1) totalvae = TOTALVI(gene_dataset.nb_genes, len(gene_dataset.protein_names)) trainer = TotalTrainer( totalvae, gene_dataset, train_size=0.5, use_cuda=False, data_loader_kwargs={"batch_size": 8}, early_stopping_kwargs=None, ) trainer.train(n_epochs=1)
def get_vae(self): n_batch = self.gene_dataset.n_batches * self.use_batches if self.use_batches: vae = VAE(self.gene_dataset.nb_genes, n_batch=n_batch, dispersion='gene-batch', n_layers=2, n_hidden=128, n_latent=self.n_latent) else: vae = VAE(self.gene_dataset.nb_genes, n_batch=n_batch, dispersion='gene', n_layers=2, n_hidden=128, n_latent=self.n_latent) return vae
def base_benchmark(gene_dataset): vae = VAE(gene_dataset.nb_genes, gene_dataset.n_batches, gene_dataset.n_labels) trainer = UnsupervisedTrainer(vae, gene_dataset, train_size=0.5, use_cuda=use_cuda) trainer.train(n_epochs=1) return trainer
def base_benchmark(gene_dataset): vae = VAE(gene_dataset.nb_genes, gene_dataset.n_batches, gene_dataset.n_labels) infer = VariationalInference(vae, gene_dataset, train_size=0.5, use_cuda=use_cuda) infer.train(n_epochs=1) return infer
def cortex_benchmark(n_epochs=250, use_cuda=True, unit_test=False): cortex_dataset = CortexDataset() vae = VAE(cortex_dataset.nb_genes) infer_cortex_vae = VariationalInference(vae, cortex_dataset, use_cuda=use_cuda) infer_cortex_vae.train(n_epochs=n_epochs) infer_cortex_vae.ll('test') # assert ~ 1200 infer_cortex_vae.differential_expression('test') infer_cortex_vae.imputation('test', rate=0.1) # assert ~ 2.3 n_samples = 1000 if not unit_test else 10 infer_cortex_vae.show_t_sne('test', n_samples=n_samples) return infer_cortex_vae
def train_seq(self, n_epochs=20, reconstruction_seq='nb'): dataset = self.data.data_seq vae = VAE( dataset.nb_genes, dispersion="gene", n_latent=self.n_latent, reconstruction_loss=reconstruction_seq, ) self.trainer_seq = UnsupervisedTrainer(vae, dataset, train_size=0.95, use_cuda=self.USE_CUDA) self.trainer_seq.train(n_epochs=n_epochs, lr=0.001)
def test_differential_expression(save_path): dataset = CortexDataset(save_path=save_path) n_cells = len(dataset) all_indices = np.arange(n_cells) vae = VAE(dataset.nb_genes, dataset.n_batches) trainer = UnsupervisedTrainer(vae, dataset, train_size=0.5, use_cuda=use_cuda) trainer.train(n_epochs=2) post = trainer.create_posterior(vae, dataset, shuffle=False, indices=all_indices) # Sample scale example px_scales = post.scale_sampler(n_samples_per_cell=4, n_samples=None, selection=all_indices)["scale"] assert (px_scales.shape[1] == dataset.nb_genes ), "posterior scales should have shape (n_samples, n_genes)" # Differential expression different models idx_1 = [1, 2, 3] idx_2 = [4, 5, 6, 7] de_dataframe = post.differential_expression_score( idx1=idx_1, idx2=idx_2, n_samples=10, mode="vanilla", use_permutation=True, M_permutation=100, ) de_dataframe = post.differential_expression_score( idx1=idx_1, idx2=idx_2, n_samples=10, mode="change", use_permutation=True, M_permutation=100, ) print(de_dataframe.keys()) assert (de_dataframe["confidence_interval_0.5_min"] <= de_dataframe["confidence_interval_0.5_max"]).all() assert (de_dataframe["confidence_interval_0.95_min"] <= de_dataframe["confidence_interval_0.95_max"]).all() # DE estimation example de_probabilities = de_dataframe.loc[:, "proba_de"] assert ((0.0 <= de_probabilities) & (de_probabilities <= 1.0)).all()
def train_fish(self, n_epochs=20): dataset = self.data.data_fish vae = VAE( dataset.nb_genes, n_batch=dataset.n_batches, dispersion="gene-batch", n_latent=self.n_latent, reconstruction_loss="nb", ) self.trainer_fish = UnsupervisedTrainer(vae, dataset, train_size=0.95, use_cuda=self.USE_CUDA) self.trainer_fish.train(n_epochs=n_epochs, lr=0.001)
def test_multibatches_features(): data = [ np.random.randint(1, 5, size=(20, 10)), np.random.randint(1, 10, size=(20, 10)), np.random.randint(1, 10, size=(20, 10)), np.random.randint(1, 10, size=(30, 10)), ] dataset = GeneExpressionDataset() dataset.populate_from_per_batch_list(data) vae = VAE(dataset.nb_genes, dataset.n_batches) trainer = UnsupervisedTrainer(vae, dataset, train_size=0.5, use_cuda=use_cuda) trainer.train(n_epochs=2) trainer.test_set.imputation(n_samples=2, transform_batch=0) trainer.train_set.imputation(n_samples=2, transform_batch=[0, 1, 2])
def test_sampling_zl(save_path): cortex_dataset = CortexDataset(save_path=save_path) cortex_vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches) trainer_cortex_vae = UnsupervisedTrainer( cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda ) trainer_cortex_vae.train(n_epochs=2) cortex_cls = Classifier((cortex_vae.n_latent + 1), n_labels=cortex_dataset.n_labels) trainer_cortex_cls = ClassifierTrainer( cortex_cls, cortex_dataset, sampling_model=cortex_vae, sampling_zl=True ) trainer_cortex_cls.train(n_epochs=2) trainer_cortex_cls.test_set.accuracy()
def training_score_scvi(train, **kwargs): from scvi.dataset import GeneExpressionDataset from scvi.inference import UnsupervisedTrainer from scvi.models import VAE data = GeneExpressionDataset( *GeneExpressionDataset.get_attributes_from_matrix(train)) vae = VAE(n_input=train.shape[1]) m = UnsupervisedTrainer(vae, data, verbose=False) m.train(n_epochs=100) # Training permuted the data for minibatching. Unpermute before "imputing" # (estimating lambda) lam = np.vstack([ m.train_set.sequential().imputation(), m.test_set.sequential().imputation() ]) return st.poisson(mu=lam).logpmf(train).sum()
def train_both(self, n_epochs=20): vae_both = VAE( self.full_dataset.nb_genes, n_latent=self.n_latent, n_batch=self.full_dataset.n_batches, dispersion="gene-batch", reconstruction_loss=self.reconstruction_seq, ) self.trainer_both = UnsupervisedTrainer( vae_both, self.full_dataset, train_size=0.95, use_cuda=self.USE_CUDA, frequency=1, ) self.trainer_both.train(n_epochs=n_epochs, lr=0.001)
def generalization_score_scvi(train, test, **kwargs): from scvi.dataset import GeneExpressionDataset from scvi.inference import UnsupervisedTrainer from scvi.models import VAE data = GeneExpressionDataset( *GeneExpressionDataset.get_attributes_from_matrix(train)) vae = VAE(n_input=train.shape[1]) m = UnsupervisedTrainer(vae, data, verbose=False) m.train(n_epochs=100) # Training permuted the data for minibatching. Unpermute before "imputing" # (estimating lambda) with torch.autograd.set_grad_enabled(False): lam = np.vstack([ m.train_set.sequential().imputation(), m.test_set.sequential().imputation() ]) return pois_llik(lam, train, test)
def test_cortex(): cortex_dataset = CortexDataset() vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches) infer_cortex_vae = VariationalInference(vae, cortex_dataset, train_size=0.1, use_cuda=use_cuda) infer_cortex_vae.train(n_epochs=1) infer_cortex_vae.ll('train') infer_cortex_vae.differential_expression_stats('train') infer_cortex_vae.differential_expression('test') infer_cortex_vae.imputation('train', corruption='uniform') infer_cortex_vae.imputation('test', n_samples=2, corruption='binomial') svaec = SVAEC(cortex_dataset.nb_genes, cortex_dataset.n_batches, cortex_dataset.n_labels) infer_cortex_svaec = JointSemiSupervisedVariationalInference( svaec, cortex_dataset, n_labelled_samples_per_class=50, use_cuda=use_cuda) infer_cortex_svaec.train(n_epochs=1) infer_cortex_svaec.accuracy('labelled') infer_cortex_svaec.ll('all') svaec = SVAEC(cortex_dataset.nb_genes, cortex_dataset.n_batches, cortex_dataset.n_labels, logreg_classifier=True) infer_cortex_svaec = AlternateSemiSupervisedVariationalInference( svaec, cortex_dataset, n_labelled_samples_per_class=50, use_cuda=use_cuda) infer_cortex_svaec.train(n_epochs=1, lr=1e-2) infer_cortex_svaec.accuracy('unlabelled') infer_cortex_svaec.svc_rf(unit_test=True) cls = Classifier(cortex_dataset.nb_genes, n_labels=cortex_dataset.n_labels) infer_cls = ClassifierInference(cls, cortex_dataset) infer_cls.train(n_epochs=1) infer_cls.accuracy('train')
def correct_scvi(Xs, genes): import torch torch.manual_seed(0) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False from scvi.dataset import AnnDatasetFromAnnData from scvi.dataset.dataset import GeneExpressionDataset from scvi.inference import UnsupervisedTrainer from scvi.models import VAE all_ann = [AnnDatasetFromAnnData(AnnData(X, var=genes)) for X in Xs] all_dataset = GeneExpressionDataset() all_dataset.populate_from_datasets(all_ann) vae = VAE(all_dataset.nb_genes, n_batch=all_dataset.n_batches, n_labels=all_dataset.n_labels, n_hidden=128, n_latent=30, n_layers=2, dispersion='gene') trainer = UnsupervisedTrainer( vae, all_dataset, train_size=1., use_cuda=True, ) n_epochs = 100 #trainer.train(n_epochs=n_epochs) #torch.save(trainer.model.state_dict(), # 'data/harmonization.vae.pkl') trainer.model.load_state_dict(torch.load('data/harmonization.vae.pkl')) trainer.model.eval() full = trainer.create_posterior(trainer.model, all_dataset, indices=np.arange(len(all_dataset))) latent, batch_indices, labels = full.sequential().get_latent() return latent
def test_full_cov(): dataset = CortexDataset() mdl = VAE(n_input=dataset.nb_genes, n_batch=dataset.n_batches, reconstruction_loss='zinb', n_latent=2, full_cov=True) trainer = UnsupervisedTrainer(model=mdl, gene_dataset=dataset, use_cuda=True, train_size=0.7, frequency=1, early_stopping_kwargs={ 'early_stopping_metric': 'elbo', 'save_best_state_metric': 'elbo', 'patience': 15, 'threshold': 3 }) trainer.train(n_epochs=20, lr=1e-3) assert not np.isnan(trainer.history['ll_test_set']).any()
def test_cortex(save_path): cortex_dataset = CortexDataset(save_path=save_path) vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches) trainer_cortex_vae = UnsupervisedTrainer(vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda) trainer_cortex_vae.train(n_epochs=1) trainer_cortex_vae.train_set.ll() trainer_cortex_vae.train_set.differential_expression_stats() trainer_cortex_vae.corrupt_posteriors(corruption='binomial') trainer_cortex_vae.corrupt_posteriors() trainer_cortex_vae.train(n_epochs=1) trainer_cortex_vae.uncorrupt_posteriors() trainer_cortex_vae.train_set.imputation_benchmark(n_samples=1, show_plot=False, title_plot='imputation', save_path=save_path) svaec = SCANVI(cortex_dataset.nb_genes, cortex_dataset.n_batches, cortex_dataset.n_labels) trainer_cortex_svaec = JointSemiSupervisedTrainer(svaec, cortex_dataset, n_labelled_samples_per_class=3, use_cuda=use_cuda) trainer_cortex_svaec.train(n_epochs=1) trainer_cortex_svaec.labelled_set.accuracy() trainer_cortex_svaec.full_dataset.ll() svaec = SCANVI(cortex_dataset.nb_genes, cortex_dataset.n_batches, cortex_dataset.n_labels) trainer_cortex_svaec = AlternateSemiSupervisedTrainer(svaec, cortex_dataset, n_labelled_samples_per_class=3, use_cuda=use_cuda) trainer_cortex_svaec.train(n_epochs=1, lr=1e-2) trainer_cortex_svaec.unlabelled_set.accuracy() data_train, labels_train = trainer_cortex_svaec.labelled_set.raw_data() data_test, labels_test = trainer_cortex_svaec.unlabelled_set.raw_data() compute_accuracy_svc(data_train, labels_train, data_test, labels_test, param_grid=[{'C': [1], 'kernel': ['linear']}]) compute_accuracy_rf(data_train, labels_train, data_test, labels_test, param_grid=[{'max_depth': [3], 'n_estimators': [10]}]) cls = Classifier(cortex_dataset.nb_genes, n_labels=cortex_dataset.n_labels) cls_trainer = ClassifierTrainer(cls, cortex_dataset) cls_trainer.train(n_epochs=1) cls_trainer.train_set.accuracy()
def test_special_dataset_size(self): gene_dataset = GeneExpressionDataset() x = np.random.randint(1, 100, (17 * 2, 10)) gene_dataset.populate_from_data(x) # Test UnsupervisedTrainer vae = VAE( gene_dataset.nb_genes, n_batch=gene_dataset.n_batches, n_labels=gene_dataset.n_labels, ) trainer = UnsupervisedTrainer( vae, gene_dataset, train_size=0.5, use_cuda=False, data_loader_kwargs={"batch_size": 8}, ) trainer.train(n_epochs=1) # Test JVATrainer jvae = JVAE( [gene_dataset.nb_genes, gene_dataset.nb_genes], gene_dataset.nb_genes, [slice(None)] * 2, ["zinb", "zinb"], [True, True], n_batch=1, ) cls = Classifier(gene_dataset.nb_genes, n_labels=2, logits=True) trainer = JVAETrainer( jvae, cls, [gene_dataset, gene_dataset], train_size=0.5, use_cuda=False, data_loader_kwargs={"batch_size": 8}, ) trainer.train(n_epochs=1)
def test_vae_ratio_loss(save_path): cortex_dataset = CortexDataset(save_path=save_path) cortex_vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches) trainer_cortex_vae = UnsupervisedTrainer(cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda, ratio_loss=True) trainer_cortex_vae.train(n_epochs=2) dataset = LatentLogPoissonDataset(n_genes=5, n_latent=2, n_cells=300, n_comps=1) vae = LogNormalPoissonVAE(dataset.nb_genes, dataset.n_batches, full_cov=True) trainer_vae = UnsupervisedTrainer(vae, dataset, train_size=0.5, use_cuda=use_cuda, ratio_loss=True) trainer_vae.train(n_epochs=2)