import warnings
from simdeep.simdeep_analysis import SimDeep
from simdeep.extract_data import LoadData
from simdeep.coxph_from_r import coxph
from simdeep.coxph_from_r import c_index
from simdeep.coxph_from_r import c_index_multiple
from simdeep.coxph_from_r import NALogicalType
from sklearn.model_selection import KFold
# from sklearn.preprocessing import OneHotEncoder
from collections import Counter
from collections import defaultdict
from itertools import combinations
import numpy as np
from scipy.stats import gmean
from sklearn.metrics import adjusted_rand_score
from simdeep.config import PROJECT_NAME
from simdeep.config import PATH_RESULTS
from simdeep.config import NB_THREADS
from simdeep.config import NB_ITER
from simdeep.config import NB_FOLDS
from simdeep.config import CLASS_SELECTION
from simdeep.config import NB_CLUSTERS
from simdeep.config import NORMALIZATION
from simdeep.config import EPOCHS
from simdeep.config import NEW_DIM
from simdeep.config import NB_SELECTED_FEATURES
from simdeep.config import PVALUE_THRESHOLD
from simdeep.config import CLUSTER_METHOD
from simdeep.config import CLASSIFICATION_METHOD
from simdeep.config import TRAINING_TSV
from simdeep.config import SURVIVAL_TSV
from simdeep.config import PATH_DATA
from simdeep.config import SURVIVAL_FLAG
from simdeep.config import NODES_SELECTION
from simdeep.config import CINDEX_THRESHOLD
from simdeep.config import USE_AUTOENCODERS
from simdeep.config import FEATURE_SURV_ANALYSIS
from simdeep.config import CLUSTERING_OMICS
from simdeep.config import USE_R_PACKAGES_FOR_SURVIVAL
# Parameter for autoencoder
from simdeep.config import LEVEL_DIMS_IN
from simdeep.config import LEVEL_DIMS_OUT
from simdeep.config import LOSS
from simdeep.config import OPTIMIZER
from simdeep.config import ACT_REG
from simdeep.config import W_REG
from simdeep.config import DROPOUT
from simdeep.config import ACTIVATION
from simdeep.config import PATH_TO_SAVE_MODEL
from simdeep.config import DATA_SPLIT
from simdeep.config import MODEL_THRES
from multiprocessing import Pool
from simdeep.deepmodel_base import DeepBase
import simplejson
from distutils.dir_util import mkpath
from os.path import isdir
from os import mkdir
from glob import glob
import gc
from time import time
from numpy import hstack
from numpy import vstack
import pandas as pd
from simdeep.survival_utils import \
_process_parallel_feature_importance_per_cluster
from simdeep.survival_utils import \
_process_parallel_survival_feature_importance_per_cluster
class SimDeepBoosting():
"""
Instanciate a new DeepProg Boosting instance.
The default parameters are defined in the config.py file
Parameters:
:nb_it: Number of models to construct
:do_KM_plot: Plot Kaplan-Meier (default: True)
:distribute: Distribute DeepProg using ray (default: False)
:nb_threads: Number of python threads to use to compute parallel Cox-PH
:class_selection: Consensus score to agglomerate DeepProg Instance {'mean', 'max', 'weighted_mean', 'weighted_max'} (default: 'mean')
:model_thres: Cox-PH p-value threshold to reject a model for DeepProg Boosting module
:verbose: Verobosity (Default: True)
:seed: Seed defining the random split of the training dataset (Default: None).
:project_name: Project name used to save files
:use_autoencoders: Use autoencoder steps to embed the data (default: True)
:feature_surv_analysis: Use individual survival feature detection to filter out features (default: True)
:split_n_fold: For each instance, the original dataset is split in folds and one fold is left
:path_results: Path to create a result folder
:nb_clusters: Number of clusters to use
:epochs: Number of epochs
:normalization: Normalisation procedure to use. See config.py file for details
:nb_selected_features: Number of top features selected for classification
:cluster_method: Clustering method. possible choice: ['mixture', 'kmeans', 'coxPH'] or class instance having fit and fit_proba attributes
:pvalue_thres: Threshold for survival significance to set a node as valid
:classification_method: Possible choice: {'ALL_FEATURES', 'SURVIVAL_FEATURES'} (default: 'ALL_FEATURES')
:new_dim: Size of the new embedding
:training_tsv: Input matrix files
:survival_tsv: Input surival file
:survival_flag: Survival flag to use
:path_data: Path of the input file
:level_dims_in: Autoencoder node layers before the middle layer (default: [])
:level_dims_out: Autoencoder node layers after the middle layer (default: [])
:loss: Loss function to minimize (default: 'binary_crossentropy')
:optimizer: Optimizer (default: adam)
:act_reg: L2 Regularization constant on the node activity (default: False)
:w_reg: L1 Regularization constant on the weight (default: False)
:dropout: Percentage of edges being dropout at each training iteration (None for no dropout) (default: 0.5)
:data_split: Fraction of the dataset to be used as test set when building the autoencoder (default: None)
:node_selection: possible choice: {'Cox-PH', 'C-index'} (default: Cox-PH)
:cindex_thres: Valid if 'c-index' is chosen (default: 0.65)
:activation: Activation function (default: 'tanh')
:clustering_omics: Which omics to use for clustering. If empty, then all the available omics will be used (default [] => all)
:path_to_save_model: path to save the model
:metadata_usage: Meta data usage with survival models (if metadata_tsv provided as argument to the dataset). Possible choice are [None, False, 'labels', 'new-features', 'all', True] (True is the same as all)
:subset_training_with_meta: Use a metadata key-value dict {meta_key:value} to subset the training sets
:alternative_embedding: alternative external embedding to use instead of building autoencoders (default None)
:kwargs_alternative_embedding: parameters for external embedding fitting
"""
def __init__(self,
nb_it=NB_ITER,
do_KM_plot=True,
distribute=False,
nb_threads=NB_THREADS,
class_selection=CLASS_SELECTION,
model_thres=MODEL_THRES,
verbose=True,
seed=None,
project_name='{0}_boosting'.format(PROJECT_NAME),
use_autoencoders=USE_AUTOENCODERS,
feature_surv_analysis=FEATURE_SURV_ANALYSIS,
split_n_fold=NB_FOLDS,
path_results=PATH_RESULTS,
nb_clusters=NB_CLUSTERS,
epochs=EPOCHS,
normalization=NORMALIZATION,
nb_selected_features=NB_SELECTED_FEATURES,
cluster_method=CLUSTER_METHOD,
pvalue_thres=PVALUE_THRESHOLD,
classification_method=CLASSIFICATION_METHOD,
new_dim=NEW_DIM,
training_tsv=TRAINING_TSV,
metadata_usage=None,
survival_tsv=SURVIVAL_TSV,
metadata_tsv=None,
subset_training_with_meta={},
survival_flag=SURVIVAL_FLAG,
path_data=PATH_DATA,
level_dims_in=LEVEL_DIMS_IN,
level_dims_out=LEVEL_DIMS_OUT,
loss=LOSS,
optimizer=OPTIMIZER,
act_reg=ACT_REG,
w_reg=W_REG,
dropout=DROPOUT,
data_split=DATA_SPLIT,
node_selection=NODES_SELECTION,
cindex_thres=CINDEX_THRESHOLD,
activation=ACTIVATION,
clustering_omics=CLUSTERING_OMICS,
path_to_save_model=PATH_TO_SAVE_MODEL,
feature_selection_usage='individual',
use_r_packages=USE_R_PACKAGES_FOR_SURVIVAL,
alternative_embedding=None,
kwargs_alternative_embedding={},
**additional_dataset_args):
""" """
assert(class_selection in ['max', 'mean', 'weighted_mean', 'weighted_max'])
self.class_selection = class_selection
self._instance_weights = None
self.distribute = distribute
self.model_thres = model_thres
self.models = []
self.verbose = verbose
self.nb_threads = nb_threads
self.do_KM_plot = do_KM_plot
self.project_name = project_name
self._project_name = project_name
self.path_results = '{0}/{1}'.format(path_results, project_name)
self.training_tsv = training_tsv
self.survival_tsv = survival_tsv
self.survival_flag = survival_flag
self.path_data = path_data
self.dataset = None
self.cindex_thres = cindex_thres
self.node_selection = node_selection
self.clustering_omics = clustering_omics
self.metadata_tsv = metadata_tsv
self.metadata_usage = metadata_usage
self.feature_selection_usage = feature_selection_usage
self.subset_training_with_meta = subset_training_with_meta
self.use_r_packages = use_r_packages
self.metadata_mat_full = None
self.cluster_method = cluster_method
self.use_autoencoders = use_autoencoders
self.feature_surv_analysis = feature_surv_analysis
if self.feature_selection_usage is None:
self.feature_surv_analysis = False
self.encoder_for_kde_plot_dict = {}
self.kde_survival_node_ids = {}
self.kde_train_matrices = {}
if not isdir(self.path_results):
try:
mkpath(self.path_results)
except Exception:
print('cannot find or create the current result path: {0}' \
'\n consider changing it as option' \
.format(self.path_results))
self.test_tsv_dict = None
self.test_survival_file = None
self.test_normalization = None
self.test_labels = None
self.test_labels_proba = None
self.cv_labels = None
self.cv_labels_proba = None
self.full_labels = None
self.full_labels_dicts = None
self.full_labels_proba = None
self.survival_full = None
self.sample_ids_full = None
self.feature_scores_per_cluster = {}
self.survival_feature_scores_per_cluster = {}
self._pretrained_fit = False
self.log = {}
self.alternative_embedding = alternative_embedding
self.kwargs_alternative_embedding = kwargs_alternative_embedding
######## deepprog instance parameters ########
self.nb_clusters = nb_clusters
self.normalization = normalization
self.epochs = epochs
self.new_dim = new_dim
self.nb_selected_features = nb_selected_features
self.pvalue_thres = pvalue_thres
self.cluster_method = cluster_method
self.cindex_test_folds = []
self.classification_method = classification_method
##############################################
self.test_fname_key = ''
self.matrix_with_cv_array = None
autoencoder_parameters = {
'epochs': self.epochs,
'new_dim': self.new_dim,
'level_dims_in': level_dims_in,
'level_dims_out': level_dims_out,
'loss': loss,
'optimizer': optimizer,
'act_reg': act_reg,
'w_reg': w_reg,
'dropout': dropout,
'data_split': data_split,
'activation': activation,
'path_to_save_model': path_to_save_model,
}
self.datasets = []
self.seed = seed
self.log['parameters'] = {}
for arg in self.__dict__:
self.log['parameters'][arg] = str(self.__dict__[arg])
self.log['seed'] = seed
self.log['parameters'].update(autoencoder_parameters)
self.log['nb_it'] = nb_it
self.log['normalization'] = normalization
self.log['nb clusters'] = nb_clusters
self.log['success'] = False
self.log['survival_tsv'] = self.survival_tsv
self.log['metadata_tsv'] = self.metadata_tsv
self.log['subset_training_with_meta'] = self.subset_training_with_meta
self.log['training_tsv'] = self.training_tsv
self.log['path_data'] = self.path_data
additional_dataset_args['survival_tsv'] = self.survival_tsv
additional_dataset_args['metadata_tsv'] = self.metadata_tsv
additional_dataset_args['subset_training_with_meta'] = self.subset_training_with_meta
additional_dataset_args['training_tsv'] = self.training_tsv
additional_dataset_args['path_data'] = self.path_data
additional_dataset_args['survival_flag'] = self.survival_flag
if 'fill_unkown_feature_with_0' in additional_dataset_args:
self.log['fill_unkown_feature_with_0'] = additional_dataset_args[
'fill_unkown_feature_with_0']
self.ray = None
self._init_datasets(nb_it, split_n_fold,
autoencoder_parameters,
**additional_dataset_args)
def _init_datasets(self, nb_it, split_n_fold,
autoencoder_parameters,
**additional_dataset_args):
"""
"""
if self.seed:
np.random.seed(self.seed)
else:
self.seed = np.random.randint(0, 10000000)
max_seed = 1000
min_seed = 0
if self.seed > max_seed:
min_seed = self.seed - max_seed
max_seed = self.seed
np.random.seed(self.seed)
random_states = np.random.randint(min_seed, max_seed, nb_it)
self.split_n_fold = split_n_fold
for it in range(nb_it):
if self.split_n_fold:
split = KFold(n_splits=split_n_fold,
shuffle=True, random_state=random_states[it])
else:
split = None
autoencoder_parameters['seed'] = random_states[it]
dataset = LoadData(cross_validation_instance=split,
verbose=False,
normalization=self.normalization,
_autoencoder_parameters=autoencoder_parameters.copy(),
**additional_dataset_args)
self.datasets.append(dataset)
def __del__(self):
"""
"""
for model in self.models:
del model
try:
gc.collect()
except Exception as e:
print('Warning: Exception {0} from garbage collector. continuing... '.format(
e))
def _from_models(self, fname, *args, **kwargs):
"""
"""
if self.distribute:
return self.ray.get([getattr(model, fname).remote(*args, **kwargs)
for model in self.models])
else:
return [getattr(model, fname)(*args, **kwargs)
for model in self.models]
def _from_model(self, model, fname, *args, **kwargs):
"""
"""
if self.distribute:
return self.ray.get(getattr(model, fname).remote(
*args, **kwargs))
else:
return getattr(model, fname)(*args, **kwargs)
def _from_model_attr(self, model, atname):
"""
"""
if self.distribute:
return self.ray.get(model._get_attibute.remote(atname))
else:
return model._get_attibute(atname)
def _from_models_attr(self, atname):
"""
"""
if self.distribute:
return self.ray.get([model._get_attibute.remote(atname)
for model in self.models])
else:
return [model._get_attibute(atname) for model in self.models]
def _from_model_dataset(self, model, atname):
"""
"""
if self.distribute:
return self.ray.get(model._get_from_dataset.remote(atname))
else:
return model._get_from_dataset(atname)
def _do_class_selection(self, inputs, **kwargs):
"""
"""
if self.class_selection == 'max':
return _highest_proba(inputs)
elif self.class_selection == 'mean':
return _mean_proba(inputs)
elif self.class_selection == 'weighted_mean':
return _weighted_mean(inputs, **kwargs)
elif self.class_selection == 'weighted_max':
return _weighted_max(inputs, **kwargs)
def partial_fit(self, debug=False):
"""
"""
self._fit(debug=debug)
def fit_on_pretrained_label_file(
self,
labels_files=[],
labels_files_folder="",
file_name_regex="*.tsv",
verbose=False,
debug=False,
):
"""
fit a deepprog simdeep models without training autoencoders but using isntead ID->labels files (one for each model instance)
"""
assert(isinstance((labels_files), list))
if not labels_files and not labels_files_folder:
raise Exception(
'## Error with fit_on_pretrained_label_file: ' \
' either labels_files or labels_files_folder should be non empty')
if not labels_files:
labels_files = glob('{0}/{1}'.format(labels_files_folder,
file_name_regex))
if not labels_files:
raise Exception('## Error: labels_files empty')
self.fit(
verbose=verbose,
debug=debug,
pretrained_labels_files=labels_files)
def fit(self, debug=False, verbose=False, pretrained_labels_files=[]):
"""
if pretrained_labels_files, is given, the models are constructed using these labels
"""
with warnings.catch_warnings():
warnings.simplefilter("ignore")
if pretrained_labels_files:
self._pretrained_fit = True
else:
self._pretrained_fit = False
if self.distribute:
self._fit_distributed(
pretrained_labels_files=pretrained_labels_files)
else:
self._fit(
debug=debug,
verbose=verbose,
pretrained_labels_files=pretrained_labels_files)
def _fit_distributed(self, pretrained_labels_files=[]):
""" """
print('fit models...')
start_time = time()
from simdeep.simdeep_distributed import SimDeepDistributed
import ray
assert(ray.is_initialized())
self.ray = ray
try:
self.models = [SimDeepDistributed.remote(
nb_clusters=self.nb_clusters,
nb_selected_features=self.nb_selected_features,
pvalue_thres=self.pvalue_thres,
dataset=dataset,
load_existing_models=False,
verbose=dataset.verbose,
_isboosting=True,
do_KM_plot=False,
cluster_method=self.cluster_method,
clustering_omics=self.clustering_omics,
use_autoencoders=self.use_autoencoders,
use_r_packages=self.use_r_packages,
feature_surv_analysis=self.feature_surv_analysis,
path_results=self.path_results,
project_name=self.project_name,
classification_method=self.classification_method,
cindex_thres=self.cindex_thres,
alternative_embedding=self.alternative_embedding,
kwargs_alternative_embedding=self.kwargs_alternative_embedding,
node_selection=self.node_selection,
metadata_usage=self.metadata_usage,
feature_selection_usage=self.feature_selection_usage,
deep_model_additional_args=dataset._autoencoder_parameters)
for dataset in self.datasets]
if pretrained_labels_files:
nb_files = len(pretrained_labels_files)
if nb_files < len(self.models):
print(
'Number of pretrained label files' \
' inferior to number of instance{0}'.format(
nb_files))
self.models = self.models[:nb_files]
results = ray.get([
model._partial_fit_model_with_pretrained_pool.remote(
labels)
for model, labels in zip(self.models,
pretrained_labels_files)])
else:
results = ray.get([
model._partial_fit_model_pool.remote()
for model in self.models])
print("Results: {0}".format(results))
self.models = [model for model, is_fitted in zip(self.models, results) if is_fitted]
nb_models = len(self.models)
print('{0} models fitted'.format(nb_models))
self.log['nb. models fitted'] = nb_models
assert(nb_models)
except Exception as e:
self.log['failure'] = str(e)
raise e
else:
self.log['success'] = True
self.log['fitting time (s)'] = time() - start_time
if self.class_selection in ['weighted_mean', 'weighted_max']:
self.collect_cindex_for_test_fold()
def _fit(self, debug=False, verbose=False, pretrained_labels_files=[]):
"""
if pretrained_labels_files, is given, the models are constructed using these labels
"""
print('fit models...')
start_time = time()
try:
self.models = [SimDeep(
nb_clusters=self.nb_clusters,
nb_selected_features=self.nb_selected_features,
pvalue_thres=self.pvalue_thres,
dataset=dataset,
load_existing_models=False,
verbose=dataset.verbose,
_isboosting=True,
do_KM_plot=False,
cluster_method=self.cluster_method,
use_autoencoders=self.use_autoencoders,
feature_surv_analysis=self.feature_surv_analysis,
path_results=self.path_results,
project_name=self.project_name,
cindex_thres=self.cindex_thres,
node_selection=self.node_selection,
metadata_usage=self.metadata_usage,
use_r_packages=self.use_r_packages,
feature_selection_usage=self.feature_selection_usage,
alternative_embedding=self.alternative_embedding,
kwargs_alternative_embedding=self.kwargs_alternative_embedding,
classification_method=self.classification_method,
deep_model_additional_args=dataset._autoencoder_parameters)
for dataset in self.datasets]
if pretrained_labels_files:
nb_files = len(pretrained_labels_files)
if nb_files < len(self.models):
print(
'Number of pretrained label files' \
' inferior to number of instance{0}'.format(
nb_files))
self.models = self.models[:nb_files]
results = [
model._partial_fit_model_with_pretrained_pool(labels)
for model, labels in zip(self.models, pretrained_labels_files)]
else:
results = [model._partial_fit_model_pool() for model in self.models]
print("Results: {0}".format(results))
self.models = [model for model, is_fitted in zip(self.models, results) if is_fitted]
nb_models = len(self.models)
print('{0} models fitted'.format(nb_models))
self.log['nb. models fitted'] = nb_models
assert(nb_models)
except Exception as e:
self.log['failure'] = str(e)
raise e
else:
self.log['success'] = True
self.log['fitting time (s)'] = time() - start_time
if self.class_selection in ['weighted_mean', 'weighted_max']:
self.collect_cindex_for_test_fold()
def predict_labels_on_test_dataset(self):
"""
"""
print('predict labels on test datasets...')
test_labels_proba = np.asarray(self._from_models_attr(
'test_labels_proba'))
res = self._do_class_selection(
test_labels_proba,
weights=self.cindex_test_folds)
self.test_labels, self.test_labels_proba = res
print('#### Report of assigned cluster for TEST dataset {0}:'.format(
self.test_fname_key))
for key, value in sorted(Counter(self.test_labels).items()):
print('class: {0}, number of samples :{1}'.format(key, value))
nbdays, isdead = self._from_model_dataset(self.models[0], "survival_test").T.tolist()
if np.isnan(nbdays).all():
return np.nan, np.nan
pvalue, pvalue_proba, pvalue_cat = self._compute_test_coxph(
'KM_plot_boosting_test',
nbdays, isdead,
self.test_labels, self.test_labels_proba,
self.project_name)
self.log['pvalue test {0}'.format(self.test_fname_key)] = pvalue
self.log['pvalue proba test {0}'.format(self.test_fname_key)] = pvalue_proba
self.log['pvalue cat test {0}'.format(self.test_fname_key)] = pvalue_cat
sample_id_test = self._from_model_dataset(self.models[0], 'sample_ids_test')
self._from_model(self.models[0], '_write_labels',
sample_id_test,
self.test_labels,
'{0}_test_labels'.format(self.project_name),
labels_proba=self.test_labels_proba.T[0],
nbdays=nbdays, isdead=isdead)
return pvalue, pvalue_proba
def compute_pvalue_for_merged_test_fold(self):
"""
"""
print('predict labels on test fold datasets...')
isdead_cv, nbdays_cv, labels_cv = [], [], []
if self.metadata_usage in ['all', 'labels'] and \
self.metadata_tsv:
metadata_mat = []
else:
metadata_mat = None
for model in self.models:
survival_cv = self._from_model_dataset(model, 'survival_cv')
if survival_cv is None:
print('No survival dataset for CV fold returning')
return
nbdays, isdead = survival_cv.T.tolist()
nbdays_cv += nbdays
isdead_cv += isdead
labels_cv += self._from_model_attr(model, "cv_labels").tolist()
if metadata_mat is not None:
meta2 = self._from_model_dataset(model, 'metadata_mat_cv')
if not len(metadata_mat):
metadata_mat = meta2
else:
metadata_mat = pd.concat([metadata_mat, meta2])
metadata_mat = metadata_mat.fillna(0)
pvalue = coxph(
labels_cv, isdead_cv, nbdays_cv,
isfactor=False,
do_KM_plot=self.do_KM_plot,
png_path=self.path_results,
fig_name='cv_analysis', seed=self.seed,
use_r_packages=self.use_r_packages,
metadata_mat=metadata_mat
)
print('Pvalue for test fold concatenated: {0}'.format(pvalue))
self.log['pvalue cv test'] = pvalue
return pvalue
def collect_pvalue_on_test_fold(self):
"""
"""
print('predict labels on test fold datasets...')
pvalues, pvalues_proba = [], []
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for model in self.models:
pvalues.append(self._from_model_attr(model, 'cp_pvalue'))
pvalues_proba.append(self._from_model_attr(model, 'cp_pvalue_proba'))
pvalue_gmean, pvalue_proba_gmean = gmean(pvalues), gmean(pvalues_proba)
if self.verbose:
print('geo mean pvalues: {0} geo mean pvalues probas: {1}'.format(
pvalue_gmean, pvalue_proba_gmean))
self.log['pvalue geo mean test fold'] = pvalue_gmean
self.log['pvalue proba geo mean test fold'] = pvalue_proba_gmean
return pvalues, pvalues_proba
def collect_pvalue_on_training_dataset(self):
"""
"""
print('predict labels on training datasets...')
pvalues, pvalues_proba = [], []
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for model in self.models:
pvalues.append(self._from_model_attr(model, 'train_pvalue'))
pvalues_proba.append(self._from_model_attr(model, 'train_pvalue_proba'))
pvalue_gmean, pvalue_proba_gmean = gmean(pvalues), gmean(pvalues_proba)
if self.verbose:
print('training geo mean pvalues: {0} geo mean pvalues probas: {1}'.format(
pvalue_gmean, pvalue_proba_gmean))
self.log['pvalue geo mean train'] = pvalue_gmean
self.log['pvalue proba geo mean train'] = pvalue_proba_gmean
return pvalues, pvalues_proba
def collect_pvalue_on_test_dataset(self):
"""
"""
print('collect pvalues on test datasets...')
pvalues, pvalues_proba = [], []
for model in self.models:
pvalues.append(self._from_model_attr(model, 'test_pvalue'))
pvalues_proba.append(self._from_model_attr(model, 'test_pvalue_proba'))
pvalue_gmean, pvalue_proba_gmean = gmean(pvalues), gmean(pvalues_proba)
if self.verbose:
print('test geo mean pvalues: {0} geo mean pvalues probas: {1}'.format(
pvalue_gmean, pvalue_proba_gmean))
self.log['pvalue geo mean test {0}'.format(self.test_fname_key)] = pvalue_gmean
self.log['pvalue proba geo mean test {0}'.format(
self.test_fname_key)] = pvalue_proba_gmean
return pvalues, pvalues_proba
def collect_pvalue_on_full_dataset(self):
"""
"""
print('collect pvalues on full datasets...')
pvalues, pvalues_proba = zip(*self._from_models('_get_pvalues_and_pvalues_proba'))
pvalue_gmean, pvalue_proba_gmean = gmean(pvalues), gmean(pvalues_proba)
if self.verbose:
print('full geo mean pvalues: {0} geo mean pvalues probas: {1}'.format(
pvalue_gmean, pvalue_proba_gmean))
self.log['pvalue geo mean full'] = pvalue_gmean
self.log['pvalue proba geo mean full'] = pvalue_proba_gmean
return pvalues, pvalues_proba
def collect_number_of_features_per_omic(self):
"""
"""
counter = defaultdict(list)
self.log['number of features per omics'] = {}
for model in self.models:
valid_node_ids_array = self._from_model_attr(model, 'valid_node_ids_array')
for key in valid_node_ids_array:
counter[key].append(len(valid_node_ids_array[key]))
if self.verbose:
for key in counter:
print('key:{0} mean: {1} std: {2}'.format(
key, np.mean(counter[key]), np.std(counter[key])))
self.log['number of features per omics'][key] = float(np.mean(counter[key]))
return counter
def collect_cindex_for_test_fold(self):
"""
"""
self.cindex_test_folds = []
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self._from_models('predict_labels_on_test_fold')
try:
cindexes = self._from_models('compute_c_indexes_for_test_fold_dataset')
except Exception as e:
print('Exception while computing the c-index for test fold: {0}'.format(e))
return np.nan
for cindex in cindexes:
if np.isnan(cindex) or isinstance(cindex, NALogicalType):
cindex = np.nan
self.cindex_test_folds.append(cindex)
if self.verbose:
mean, std = np.nanmean(self.cindex_test_folds), np.nanstd(self.cindex_test_folds)
print('C-index results for test fold: mean {0} std {1}'.format(mean, std))
self.log['c-indexes test fold (mean)'] = np.mean(mean)
return self.cindex_test_folds
def collect_cindex_for_full_dataset(self):
"""
"""
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self._from_models('predict_labels_on_test_fold')
try:
cindexes_list = self._from_models('compute_c_indexes_for_full_dataset')
except Exception as e:
print('Exception while computing the c-index for full dataset: {0}'.format(e))
return np.nan
if self.verbose:
print('c-index results for full dataset: mean {0} std {1}'.format(
np.mean(cindexes_list), np.std(cindexes_list)))
self.log['c-indexes full (mean)'] = np.mean(cindexes_list)
return cindexes_list
def collect_cindex_for_training_dataset(self):
"""
"""
try:
cindexes_list = self._from_models('compute_c_indexes_for_training_dataset')
except Exception as e:
print('Exception while computing the c-index for training dataset: {0}'.format(e))
self.log['c-indexes train (mean)'] = np.nan
return np.nan
if self.verbose:
print('C-index results for training dataset: mean {0} std {1}'.format(
np.mean(cindexes_list), np.std(cindexes_list)))
self.log['c-indexes train (mean)'] = np.mean(cindexes_list)
return cindexes_list
def collect_cindex_for_test_dataset(self):
"""
"""
try:
cindexes_list = self._from_models('compute_c_indexes_for_test_dataset')
except Exception as e:
print('Exception while computing the c-index for test dataset: {0}'.format(e))
self.log['C-index test {0}'.format(self.test_fname_key)] = np.nan
return np.nan
if self.verbose:
print('C-index results for test: mean {0} std {1}'.format(
np.mean(cindexes_list), np.std(cindexes_list)))
self.log['C-index test {0}'.format(self.test_fname_key)] = np.mean(cindexes_list)
return cindexes_list
def predict_labels_on_full_dataset(self):
"""
"""
print('predict labels on full datasets...')
self._get_probas_for_full_models()
self._reorder_survival_full_and_metadata()
print('#### Report of assigned cluster for the full training dataset:')
for key, value in sorted(Counter(self.full_labels).items()):
print('class: {0}, number of samples :{1}'.format(key, value))
nbdays, isdead = self.survival_full.T.tolist()
pvalue, pvalue_proba, pvalue_cat = self._compute_test_coxph(
'KM_plot_boosting_full',
nbdays, isdead,
self.full_labels, self.full_labels_proba,
self._project_name)
self.log['pvalue full'] = pvalue
self.log['pvalue proba full'] = pvalue_proba
self.log['pvalue cat full'] = pvalue_cat
self._from_model(self.models[0], '_write_labels',
self.sample_ids_full,
self.full_labels,
'{0}_full_labels'.format(self._project_name),
labels_proba=self.full_labels_proba.T[0],
nbdays=nbdays, isdead=isdead)
return pvalue, pvalue_proba
def compute_clusters_consistency_for_full_labels(self):
"""
"""
scores = []
for model_1, model_2 in combinations(self.models, 2):
full_labels_1_old = self._from_model_attr(model_1, 'full_labels')
full_labels_2_old = self._from_model_attr(model_2, 'full_labels')
full_ids_1 = self._from_model_dataset(model_1, 'sample_ids_full')
full_ids_2 = self._from_model_dataset(model_2, 'sample_ids_full')
full_labels_1 = _reorder_labels(full_labels_1_old, full_ids_1)
full_labels_2 = _reorder_labels(full_labels_2_old, full_ids_2)
scores.append(adjusted_rand_score(full_labels_1,
full_labels_2))
print('Adj. Rand scores for full label: mean: {0} std: {1}'.format(
np.mean(scores), np.std(scores)))
self.log['Adj. Rand scores'] = np.mean(scores)
return scores
def compute_clusters_consistency_for_test_labels(self):
"""
"""
scores = []
for model_1, model_2 in combinations(self.models, 2):
scores.append(adjusted_rand_score(
self._from_model_attr(model_1, 'test_labels'),
self._from_model_attr(model_2, 'test_labels'),
))
print('Adj. Rand scores for test label: mean: {0} std: {1}'.format(
np.mean(scores), np.std(scores)))
self.log['Adj. Rand scores test {0}'.format(self.test_fname_key)] = np.mean(scores)
return scores
def _reorder_survival_full_and_metadata(self):
"""
"""
survival_old = self._from_model_dataset(self.models[0], 'survival_full')
sample_ids = self._from_model_dataset(self.models[0], 'sample_ids_full')
surv_dict = {sample: surv for sample, surv in zip(sample_ids, survival_old)}
self.survival_full = np.asarray([np.asarray(surv_dict[sample])[0]
for sample in self.sample_ids_full])
metadata = self._from_model_dataset(self.models[0], 'metadata_mat_full')
if metadata is not None:
index_dict = {sample: pos for pos, sample in enumerate(sample_ids)}
index = np.asarray([index_dict[sample] for sample in self.sample_ids_full])
self.metadata_mat_full = metadata.T[index].T
def _reorder_matrix_full(self):
"""
"""
sample_ids = self._from_model_dataset(self.models[0], 'sample_ids_full')
index_dict = {sample: ids for ids, sample in enumerate(sample_ids)}
index = [index_dict[sample] for sample in self.sample_ids_full]
self.matrix_with_cv_array = self._from_model_dataset(
self.models[0], 'matrix_array').copy()
matrix_cv_unormalized_array = self._from_model_dataset(
self.models[0],
'matrix_cv_unormalized_array')
for key in self.matrix_with_cv_array:
if len(matrix_cv_unormalized_array):
self.matrix_with_cv_array[key] = vstack(
[self.matrix_with_cv_array[key],
matrix_cv_unormalized_array[key]])
self.matrix_with_cv_array[key] = self.matrix_with_cv_array[key][index]
def _get_probas_for_full_models(self):
"""
"""
proba_dict = defaultdict(list)
for sample_proba in self._from_models('_get_probas_for_full_model'):
sample_set = set()
for sample, proba in sample_proba:
if sample in sample_set:
continue
proba_dict[sample].append([np.nan_to_num(proba).tolist()])
sample_set.add(sample)
labels, probas = self._do_class_selection(hstack(list(proba_dict.values())),
weights=self.cindex_test_folds)
self.full_labels = np.asarray(labels)
self.full_labels_proba = probas
self.sample_ids_full = list(proba_dict.keys())
def _compute_test_coxph(self, fname_base, nbdays,
isdead, labels, labels_proba,
project_name, metadata_mat=None):
""" """
pvalue = coxph(
labels, isdead, nbdays,
isfactor=False,
do_KM_plot=self.do_KM_plot,
png_path=self.path_results,
fig_name='{0}_{1}'.format(project_name, fname_base),
use_r_packages=self.use_r_packages,
metadata_mat=metadata_mat,
seed=self.seed)
if self.verbose:
print('Cox-PH p-value (Log-Rank) for inferred labels: {0}'.format(pvalue))
pvalue_proba = coxph(
labels_proba.T[0],
isdead, nbdays,
isfactor=False,
use_r_packages=self.use_r_packages,
metadata_mat=metadata_mat,
seed=self.seed)
if self.verbose:
print('Cox-PH proba p-value (Log-Rank) for inferred labels: {0}'.format(pvalue_proba))
labels_categorical = self._labels_proba_to_labels(labels_proba)
pvalue_cat = coxph(
labels_categorical, isdead, nbdays,
isfactor=False,
do_KM_plot=self.do_KM_plot,
png_path=self.path_results,
use_r_packages=self.use_r_packages,
fig_name='{0}_proba_{1}'.format(project_name, fname_base),
metadata_mat=metadata_mat,
seed=self.seed)
if self.verbose:
print('Cox-PH categorical p-value (Log-Rank) for inferred labels: {0}'.format(
pvalue_cat))
return pvalue, pvalue_proba, pvalue_cat
def _labels_proba_to_labels(self, labels_proba):
"""
"""
probas = labels_proba.T[0]
labels = np.zeros(len(probas))
nb_clusters = labels_proba.shape[1]
for cluster in range(nb_clusters):
percentile = 100 * (1.0 - 1.0 / (cluster + 1.0))
value = np.percentile(probas, percentile)
labels[probas >= value] = nb_clusters - cluster
return labels
def compute_c_indexes_for_test_dataset(self):
"""
return c-index using labels as predicat
"""
days_full, dead_full = np.asarray(self.survival_full).T
days_test, dead_test = self._from_model_dataset(self.models[0], 'survival_test').T
if np.isnan(days_test).all():
print("Cannot compute C-index for test dataset. Need test survival file")
return
labels_test_categorical = self._labels_proba_to_labels(self.test_labels_proba)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
if isinstance(days_test, np.matrix):
days_test = np.asarray(days_test)[0]
dead_test = np.asarray(dead_test)[0]
cindex = c_index(self.full_labels, dead_full, days_full,
self.test_labels, dead_test, days_test,
use_r_packages=self.use_r_packages,
seed=self.seed)
cindex_cat = c_index(self.full_labels, dead_full, days_full,
labels_test_categorical, dead_test, days_test,
use_r_packages=self.use_r_packages,
seed=self.seed)
cindex_proba = c_index(self.full_labels_proba.T[0], dead_full, days_full,
self.test_labels_proba.T[0], dead_test, days_test,
use_r_packages=self.use_r_packages,
seed=self.seed)
if self.verbose:
print('c-index for boosting test dataset:{0}'.format(cindex))
print('c-index proba for boosting test dataset:{0}'.format(cindex_proba))
print('c-index cat for boosting test dataset:{0}'.format(cindex_cat))
self.log['c-index test boosting {0}'.format(self.test_fname_key)] = cindex
self.log['c-index proba test boosting {0}'.format(self.test_fname_key)] = cindex_proba
self.log['c-index cat test boosting {0}'.format(self.test_fname_key)] = cindex_cat
return cindex
def compute_c_indexes_for_full_dataset(self):
"""
return c-index using labels as predicat
"""
days_full, dead_full = np.asarray(self.survival_full).T
labels_categorical = self._labels_proba_to_labels(self.full_labels_proba)
cindex = c_index(self.full_labels, dead_full, days_full,
self.full_labels, dead_full, days_full,
use_r_packages=self.use_r_packages,
seed=self.seed)
cindex_cat = c_index(labels_categorical, dead_full, days_full,
labels_categorical, dead_full, days_full,
use_r_packages=self.use_r_packages,
seed=self.seed)
cindex_proba = c_index(self.full_labels_proba.T[0], dead_full, days_full,
self.full_labels_proba.T[0], dead_full, days_full,
use_r_packages=self.use_r_packages,
seed=self.seed)
if self.verbose:
print('c-index for boosting full dataset:{0}'.format(cindex))
print('c-index proba for boosting full dataset:{0}'.format(cindex_proba))
print('c-index cat for boosting full dataset:{0}'.format(cindex_cat))
self.log['c-index full boosting {0}'.format(self.test_fname_key)] = cindex
self.log['c-index proba full boosting {0}'.format(self.test_fname_key)] = cindex_proba
self.log['c-index cat full boosting {0}'.format(self.test_fname_key)] = cindex_cat
return cindex
def compute_c_indexes_multiple_for_test_dataset(self):
"""
Not Functionnal !
"""
print('not funtionnal!')
return
matrix_array_train = self._from_model_dataset(self.models[0], 'matrix_ref_array')
matrix_array_test = self._from_model_dataset(self.models[0], 'matrix_test_array')
nbdays, isdead = self._from_model_dataset(self.models[0],
'survival').T.tolist()
nbdays_test, isdead_test = self._from_model_dataset(self.models[0],
'survival_test').T.tolist()
activities_train, activities_test = [], []
for model in self.models:
activities_train.append(model.predict_nodes_activities(matrix_array_train))
activities_test.append(model.predict_nodes_activities(matrix_array_test))
activities_train = hstack(activities_train)
activities_test = hstack(activities_test)
cindex = c_index_multiple(
activities_train, isdead, nbdays,
activities_test, isdead_test, nbdays_test, seed=self.seed)
print('total number of survival features: {0}'.format(activities_train.shape[1]))
print('cindex multiple for test set: {0}:'.format(cindex))
self.log['c-index multiple test {0}'.format(self.test_fname_key)] = cindex
self.log['Number of survival features {0}'.format(
self.test_fname_key)] = activities_train.shape[1]
return cindex
def plot_supervised_predicted_labels_for_test_sets(
self,
define_as_main_kernel=False,
use_main_kernel=False):
"""
"""
print('#### plotting supervised labels....')
self._from_model(self.models[0], "plot_supervised_kernel_for_test_sets",
define_as_main_kernel=define_as_main_kernel,
use_main_kernel=use_main_kernel,
test_labels_proba=self.test_labels_proba,
test_labels=self.test_labels,
key='_' + self.test_fname_key)
def plot_supervised_kernel_for_test_sets(self):
"""
"""
from simdeep.plot_utils import plot_kernel_plots
if self.verbose:
print('plotting survival features using autoencoder...')
encoder_key = self._create_autoencoder_for_kernel_plot()
activities, activities_test = self._predict_kde_matrices(
encoder_key, self.dataset.matrix_test_array)
html_name = '{0}/{1}_{2}_supervised_kdeplot.html'.format(
self.path_results,
self.project_name,
self.test_fname_key)
plot_kernel_plots(
test_labels=self.test_labels,
test_labels_proba=self.test_labels_proba,
labels=self.full_labels,
activities=activities,
activities_test=activities_test,
dataset=self.dataset,
path_html=html_name)
def _predict_kde_survival_nodes_for_train_matrices(self, encoder_key):
"""
"""
self.kde_survival_node_ids = {}
encoder_array = self.encoder_for_kde_plot_dict[encoder_key]
for key in encoder_array:
encoder = encoder_array[key]
matrix_ref = encoder.predict(self.dataset.matrix_ref_array[key])
survival_node_ids = self._from_model(self.models[0], '_look_for_survival_nodes',
activities=matrix_ref, survival=self.dataset.survival)
self.kde_survival_node_ids[key] = survival_node_ids
self.kde_train_matrices[key] = matrix_ref
def _predict_kde_matrices(self, encoder_key,
matrix_test_array):
"""
"""
matrix_test_list = []
matrix_ref_list = []
encoder_array = self.encoder_for_kde_plot_dict[encoder_key]
for key in matrix_test_array:
encoder = encoder_array[key]
matrix_test = encoder.predict(matrix_test_array[key])
matrix_ref = self.kde_train_matrices[key]
survival_node_ids = self.kde_survival_node_ids[key]
if len(survival_node_ids) > 1:
matrix_test = matrix_test.T[survival_node_ids].T
matrix_ref = matrix_ref.T[survival_node_ids].T
else:
if self.verbose:
print('not enough survival nodes to construct kernel for key: {0}' \
'skipping the {0} matrix'.format(key))
continue
matrix_ref_list.append(matrix_ref)
matrix_test_list.append(matrix_test)
if not matrix_ref_list:
if self.verbose:
print('\n<!><!><!><!><!><!><!><!><!><!><!><!><!><!><!><!><!>\n' \
' matrix_ref_list / matrix_test_list empty!' \
'take the last OMIC ({0}) matrix as ref \n' \
'<!><!><!><!><!><!><!><!><!><!><!><!><!><!><!><!><!><!>\n'.format(key))
matrix_ref_list.append(matrix_ref)
matrix_test_list.append(matrix_test)
return hstack(matrix_ref_list), hstack(matrix_test_list)
def _create_autoencoder_for_kernel_plot(self):
"""
"""
key_normalization = {
key: self.test_normalization[key]
for key in self.test_normalization
if self.test_normalization[key]
}
encoder_key = str(key_normalization)
encoder_key = 'omic:{0} normalisation: {1}'.format(
list(self.test_tsv_dict.keys()),
encoder_key)
if encoder_key in self.encoder_for_kde_plot_dict:
if self.verbose:
print('loading test data for plotting...')
self.dataset.load_new_test_dataset(
tsv_dict=self.test_tsv_dict,
path_survival_file=self.test_survival_file,
normalization=self.test_normalization)
return encoder_key
self.dataset = LoadData(
cross_validation_instance=None,
training_tsv=self.training_tsv,
survival_tsv=self.survival_tsv,
metadata_tsv=self.metadata_tsv,
survival_flag=self.survival_flag,
path_data=self.path_data,
verbose=False,
normalization=self.test_normalization,
subset_training_with_meta=self.subset_training_with_meta
)
if self.verbose:
print('preparing data for plotting...')
self.dataset.load_array()
self.dataset.load_survival()
self.dataset.load_meta_data()
self.dataset.subset_training_sets()
self.dataset.reorder_matrix_array(self.sample_ids_full)
self.dataset.create_a_cv_split()
self.dataset.normalize_training_array()
self.dataset.load_new_test_dataset(
tsv_dict=self.test_tsv_dict,
path_survival_file=self.test_survival_file,
normalization=self.test_normalization)
if self.verbose:
print('fitting autoencoder for plotting...')
autoencoder = DeepBase(dataset=self.dataset,
seed=self.seed,
verbose=False,
dropout=0.1,
epochs=50)
autoencoder.matrix_train_array = self.dataset.matrix_ref_array
# label_encoded = OneHotEncoder().fit_transform(
# self.full_labels.reshape(-1, 1)).todense()
# autoencoder.construct_supervized_network(label_encoded)
autoencoder.construct_supervized_network(self.full_labels_proba)
self.encoder_for_kde_plot_dict[encoder_key] = autoencoder.encoder_array
if self.verbose:
print('fitting done!')
self._predict_kde_survival_nodes_for_train_matrices(encoder_key)
return encoder_key
def load_new_test_dataset(self, tsv_dict,
fname_key=None,
path_survival_file=None,
normalization=None,
debug=False,
verbose=False,
survival_flag=None,
metadata_file=None
):
"""
"""
self.test_tsv_dict = tsv_dict
self.test_survival_file = path_survival_file
if normalization is None:
normalization = self.normalization
self.test_normalization = normalization
if debug or self.nb_threads < 2:
pass
# for model in self.models:
# model.verbose = True
# model.dataset.verbose = True
self.test_fname_key = fname_key
print("Loading new test dataset {0} ...".format(
self.test_fname_key))
t_start = time()
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self._from_models('_predict_new_dataset',
tsv_dict=tsv_dict,
path_survival_file=path_survival_file,
normalization=normalization,
survival_flag=survival_flag,
metadata_file=metadata_file
)
print("Test dataset {1} loaded in {0} s".format(
time() - t_start, self.test_fname_key))
if fname_key:
self.project_name = '{0}_{1}'.format(self._project_name, fname_key)
def compute_survival_feature_scores_per_cluster(self,
pval_thres=0.001,
use_meta=False):
"""
"""
print('computing survival feature importance per cluster...')
pool = Pool(self.nb_threads)
mapf = pool.map
if (self.metadata_usage in ['all', 'new-features'] or use_meta) and \
self.metadata_mat_full is not None:
metadata_mat = self.metadata_mat_full
else:
metadata_mat = None
for label in set(self.full_labels):
self.survival_feature_scores_per_cluster[label] = []
feature_dict = self._from_model_dataset(self.models[0], 'feature_array')
def generator(feature_list, matrix, feature_index):
for feat in feature_list:
i = feature_index[feat[0]]
yield (feat,
np.asarray(matrix[i]).reshape(-1),
self.survival_full,
metadata_mat,
pval_thres,
self.use_r_packages)
for key in self.matrix_with_cv_array:
feature_index = {feat: i for i, feat in enumerate(feature_dict[key])}
for label in self.feature_scores_per_cluster:
matrix = self.matrix_with_cv_array[key][:]
feature_list = self.feature_scores_per_cluster[label]
feature_list = [feat for feat in feature_list
if feat[0] in feature_index]
input_list = generator(feature_list, matrix.T, feature_index)
features_scored = mapf(
_process_parallel_survival_feature_importance_per_cluster,
input_list)
for feature, pvalue in features_scored:
if feature is not None:
self.survival_feature_scores_per_cluster[label].append(
(feature, pvalue))
if label in self.survival_feature_scores_per_cluster:
self.survival_feature_scores_per_cluster[label].sort(
key=lambda x: x[1])
def compute_feature_scores_per_cluster(self, pval_thres=0.001):
"""
"""
print('computing feature importance per cluster...')
self._reorder_matrix_full()
mapf = map
for label in set(self.full_labels):
self.feature_scores_per_cluster[label] = []
def generator(labels, feature_list, matrix):
for i in range(len(feature_list)):
yield feature_list[i], matrix[i], labels, pval_thres
feature_dict = self._from_model_dataset(self.models[0], 'feature_array')
for key in self.matrix_with_cv_array:
matrix = self.matrix_with_cv_array[key][:]
labels = self.full_labels[:]
input_list = generator(labels, feature_dict[key], matrix.T)
features_scored = mapf(
_process_parallel_feature_importance_per_cluster, input_list)
features_scored = [feat for feat_list in features_scored
for feat in feat_list]
for label, feature, median_diff, pvalue in features_scored:
self.feature_scores_per_cluster[label].append((
feature, median_diff, pvalue))
for label in self.feature_scores_per_cluster:
self.feature_scores_per_cluster[label].sort(
key=lambda x: x[2])
def write_feature_score_per_cluster(self):
"""
"""
f_file_name = '{0}/{1}_features_scores_per_clusters.tsv'.format(
self.path_results, self._project_name)
f_anti_name = '{0}/{1}_features_anticorrelated_scores_per_clusters.tsv'.format(
self.path_results, self._project_name)
f_file = open(f_file_name, 'w')
f_anti_file = open(f_anti_name, 'w')
f_file.write('#label\tfeature\tmedian difference\tp-value\n')
f_anti_file.write('#label\tfeature\tmedian difference\tp-value\n')
f_file.write('cluster id\tfeature\tmedian diff\tWilcoxon p-value\n')
for label in self.feature_scores_per_cluster:
for feature, median_diff, pvalue in self.feature_scores_per_cluster[label]:
if median_diff > 0:
f_to_write = f_file
else:
f_to_write = f_anti_file
f_to_write.write('{0}\t{1}\t{2}\t{3}\n'.format(
label, feature, median_diff, pvalue))
print('{0} written'.format(f_file_name))
print('{0} written'.format(f_anti_name))
if self.survival_feature_scores_per_cluster:
f_file_name = '{0}/{1}_survival_features_scores_per_clusters.tsv'.format(
self.path_results, self._project_name)
f_to_write = open(f_file_name, 'w')
f_to_write.write(
'#label\tfeature\tmedian difference\tcluster logrank p-value\tCoxPH Log-rank p-value\n')
for label in self.survival_feature_scores_per_cluster:
for feature, pvalue in self.survival_feature_scores_per_cluster[label]:
f_to_write.write('{0}\t{1}\t{2}\t{3}\t{4}\n'.format(
label, feature[0], feature[1], feature[2], pvalue))
print('{0} written'.format(f_file_name))
else:
print("No survival features detected. File: {0} not writtten".format(f_file_name))
def evalutate_cluster_performance(self):
"""
"""
if self._pretrained_fit:
print('model is fitted on pretrained labels' \
' Cannot evaluate cluster performance')
return
bic_scores = np.array([self._from_model_attr(model, 'bic_score') for model in self.models])
if bic_scores[0] is not None:
bic = np.nanmean(bic_scores)
print('bic score: mean: {0} std :{1}'.format(bic_scores.mean(), bic_scores.std()
))
self.log['bic'] = bic
else:
bic = np.nan
silhouette_scores = np.array([self._from_model_attr(model, 'silhouette_score')
for model in self.models])
silhouette = silhouette_scores.mean()
print('silhouette score: mean: {0} std :{1}'.format(silhouette,
silhouette_scores.std()
))
self.log['silhouette'] = silhouette
calinski_scores = np.array([self._from_model_attr(model, 'calinski_score')
for model in self.models])
calinski = calinski_scores.mean()
print('calinski harabasz score: mean: {0} std :{1}'.format(calinski_scores.mean(),
calinski_scores.std()
))
self.log['calinski'] = calinski
return bic, silhouette, calinski
def save_cv_models_classes(self, path_results=""):
"""
"""
self.save_models_classes(path_results=path_results,
use_cv_labels=True)
def save_test_models_classes(self, path_results=""):
"""
"""
self.save_models_classes(path_results=path_results,
use_test_labels=True)
def save_models_classes(self, path_results="",
use_cv_labels=False,
use_test_labels=False):
"""
"""
if not path_results:
if use_test_labels:
path_results = '{0}/saved_models_test_classes'.format(
self.path_results)
elif use_cv_labels:
path_results = '{0}/saved_models_cv_classes'.format(
self.path_results)
else:
path_results = '{0}/saved_models_classes'.format(
self.path_results)
if not isdir(path_results):
mkdir(path_results)
for i, model in enumerate(self.models):
if use_test_labels:
labels = self._from_model_attr(model, 'test_labels')
labels_proba = self._from_model_attr(model, 'test_labels_proba')
sample_ids = self._from_model_dataset(model, 'sample_ids_test')
survival = self._from_model_dataset(model, 'survival_test')
elif use_cv_labels:
labels = self._from_model_attr(model, 'cv_labels')
labels_proba = self._from_model_attr(model, 'cv_labels_proba')
sample_ids = self._from_model_dataset(model, 'sample_ids_cv')
survival = self._from_model_dataset(model, 'survival_cv')
else:
labels = self._from_model_attr(model, 'labels')
labels_proba = self._from_model_attr(model, 'labels_proba')
sample_ids = self._from_model_dataset(model, 'sample_ids')
survival = self._from_model_dataset(model, 'survival')
seed = self._from_model_attr(model, 'seed')
nbdays, isdead = survival.T.tolist()
if not seed:
seed = i
path_file = '{0}/model_instance_{1}.tsv'.format(
path_results, seed)
labels_proba = labels_proba.T[0]
self._from_model(
model, '_write_labels',
sample_ids,
labels,
path_file=path_file,
labels_proba=labels_proba,
nbdays=nbdays, isdead=isdead)
print('individual model labels saved at: {0}'.format(path_results))
def _convert_logs(self):
"""
"""
for key in self.log:
if isinstance(self.log[key], np.float32):
self.log[key] = float(self.log[key])
elif isinstance(self.log[key], NALogicalType):
self.log[key] = None
elif pd.isna(self.log[key]):
self.log[key] = None
try:
str(self.log[key])
except Exception:
self.log.pop(key)
def write_logs(self):
"""
"""
self._convert_logs()
with open('{0}/{1}.log.json'.format(self.path_results, self._project_name), 'w') as f:
f.write(simplejson.dumps(self.log, indent=2))
def _highest_proba(proba):
"""
"""
labels = []
probas = []
clusters = range(proba.shape[2])
samples = range(proba.shape[1])
for sample in samples:
proba_vector = [proba.T[cluster][sample].max() for cluster in clusters]
label = max(enumerate(proba_vector), key=lambda x:x[1])[0]
labels.append(label)
probas.append(proba_vector)
return np.asarray(labels), np.asarray(probas)
def _mean_proba(proba):
"""
"""
labels = []
probas = []
clusters = range(proba.shape[2])
samples = range(proba.shape[1])
for sample in samples:
proba_vector = [proba.T[cluster][sample].mean() for cluster in clusters]
label = max(enumerate(proba_vector), key=lambda x:x[1])[0]
labels.append(label)
probas.append(proba_vector)
return np.asarray(labels), np.asarray(probas)
def _weighted_mean(proba, weights):
"""
"""
labels = []
probas = []
weights = np.array(weights)
weights[weights < 0.50] = 0.0
weights = np.power(weights, 4)
if weights.sum() == 0:
weights[:] = 1.0
clusters = range(proba.shape[2])
samples = range(proba.shape[1])
for sample in samples:
proba_vector = [np.average(proba.T[cluster][sample]) for cluster in clusters]
label = max(enumerate(proba_vector), key=lambda x:x[1])[0]
labels.append(label)
probas.append(proba_vector)
return np.asarray(labels), np.asarray(probas)
def _weighted_max(proba, weights):
"""
"""
labels = []
probas = []
weights = np.array(weights)
weights[weights < 0.50] = 0.0
weights = np.power(weights, 4)
if weights.sum() == 0:
weights[:] = 1.0
clusters = range(proba.shape[2])
samples = range(proba.shape[1])
for sample in samples:
proba_vector = [np.max(proba.T[cluster][sample] * weights) for cluster in clusters]
label = max(enumerate(proba_vector), key=lambda x:x[1])[0]
labels.append(label)
probas.append(proba_vector)
return np.asarray(labels), np.asarray(probas)
def _reorder_labels(labels, sample_ids):
"""
"""
sample_dict = {sample: id for id, sample in enumerate(sample_ids)}
sample_ordered = set(sample_ids)
index = [sample_dict[sample] for sample in sample_ordered]
return labels[index]
Datasets
Models
