scmkl 0.1.0__tar.gz

scmkl-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: scmkl
+Version: 0.1.0
+Author: Sam Kupp, Ian VanGordon, Cigdem Ak
+Author-email: kupp@ohsu.edu, vangordi@ohsu.edu, ak@ohsu.edu
+Requires-Python: >3.11.1
+License-File: LICENSE
+Requires-Dist: wheel==0.41.2
+Requires-Dist: anndata==0.10.8
+Requires-Dist: celer==0.7.3
+Requires-Dist: numpy==1.26.0
+Requires-Dist: pandas==2.2.2
+Requires-Dist: scikit-learn==1.3.2
+Requires-Dist: scipy==1.14.1

scmkl-0.1.0/README.md

@@ -0,0 +1,86 @@
+### scMKL
+This is an introduction to single cell Multiple Kernel Learning. scMKL is a classification algorithm utilizing prior information to group features to enhance classification and aid understanding of distinguishing features in multi-omic data sets.
+
+
+```python
+# Packages needed to import data
+import numpy as np
+import pickle
+import sys
+
+# This sys command allows us to import the scMKL_src module from any directory. '..' can be replaced by any path to the module
+sys.path.insert(0, '..')
+import src.scMKL_src as src
+
+seed = np.random.default_rng(1)
+```
+
+#### Inputs for scMKL
+There are 4 required pieces of data (per modality) required for scMKL
+- The data matrix itself with cells as rows and features as columns.
+    - Can be either a Numpy Array or Scipy Sparse array.  
+- The sample labels in a Numpy Array.  To perform group lasso, these labels must be binary.
+- Feature names in a Numpy Array. These are the names of the features corresponding with the data matrix
+- A dictionary with grouping data.  The keys are the names of the groups, and the values are the corresponding features.
+    - Example: {Group1: [feature1, feature2, feature3], Group2: [feature4, feature5, feature6], ...}
+
+
+```python
+X = np.load('./data/TCGA-ESCA.npy', allow_pickle = True)
+labels = np.load('./data/TCGA-ESCA_cell_metadata.npy', allow_pickle = True)
+features = np.load('./data/TCGA-ESCA_RNA_feature_names.npy', allow_pickle = True)
+
+
+with open('./data/RNA_hallmark_groupings.pkl', 'rb') as fin:
+    group_dict = pickle.load(fin)
+
+# This value for D, the number of fourier features in Z, was found to be optimal in previous literature.  Generally increasing D increases accuracy, but runs slower.
+D = int(np.sqrt(len(labels)) * np.log(np.log(len(labels))))
+
+# Removes features in X and features that are not found in group_dict.  Done to reduce memory usage and search time
+X, features = src.Filter_Features(X, features, group_dict)
+```
+
+#### Parameter Optimization
+Kernel widths (sigma) are a parameter of the kernel approximation.  Here we estimate sigma on a random 2000 samples from the training set before optimizing it with k-Fold Cross Validation on the full training set.
+
+
+```python
+# The train/test sets are calculated to keep the proportion of each label the same in the training and testing sets.
+train_indices, test_indices = src.Train_Test_Split(labels, seed_obj= seed)
+
+X_train = X[train_indices,:]
+X_test = X[test_indices,:]
+y_train = labels[train_indices]
+y_test = labels[test_indices]
+
+sigmas = src.Estimate_Sigma(X= X_train, group_dict= group_dict, assay= 'rna', feature_set= features, seed_obj= seed)
+
+sigmas = src.Optimize_Sigma(X = X_train, y = y_train, group_dict = group_dict, assay = 'rna', D = D, feature_set = features, 
+                            sigma_list = sigmas, k = 2, sigma_adjustments = np.arange(0.1,2,0.1), seed_obj= seed)
+```
+
+#### Calculating Z and Model Evaluation
+Below, we calculate approximate kernels for each group in the grouping information.
+
+Then we train the model to view the distinguishing feature groups between phenotypes and evaluate on a test set to quantify classification performance.
+Looking at group normalized weights can reveal insights into underlying biology.
+
+
+```python
+Z_train, Z_test = src.Calculate_Z(X_train= X_train, X_test= X_test, group_dict= group_dict, assay= 'rna', D= D, feature_set= features, sigma_list= sigmas, seed_obj= seed)
+
+gl = src.Train_Model(Z_train, y_train, 2 * D)
+predictions, metrics = src.Predict(gl, Z_test, y_test, metrics = ['AUROC', 'F1-Score', 'Accuracy', 'Precision', 'Recall'])
+selected_groups = src.Find_Selected_Pathways(gl, group_names= group_dict.keys())
+```
+
+
+```python
+print(metrics)
+print(selected_groups)
+```
+
+    {'AUROC': 1.0, 'Accuracy': 1.0, 'F1-Score': 1.0, 'Precision': 1.0, 'Recall': 1.0}
+    ['HALLMARK_ESTROGEN_RESPONSE_EARLY']
+

scmkl-0.1.0/scmkl/__init__.py

@@ -0,0 +1,23 @@
+__all__ = ['approx_kernels', 'data_processing', 'estimate_sigma', 
+           'multimodal_processing', 'optimize_alpha', 'test', 'tfidf',
+           'train', 'utils']
+
+# from . import approx_kernels
+# from . import data_processing
+# from . import estimate_sigma
+# from . import multimodal_processing
+# from . import optimize_alpha
+# from . import test
+# from . import tfidf
+# from . import train
+# from . import utils
+
+from scmkl.approx_kernels import *
+from scmkl.data_processing import *
+from scmkl.estimate_sigma import *
+from scmkl.multimodal_processing import *
+from scmkl.optimize_alpha import *
+from scmkl.test import *
+from scmkl.tfidf import *
+from scmkl.train import *
+from scmkl.utils import *

scmkl-0.1.0/scmkl/approx_kernels.py

@@ -0,0 +1,83 @@
+import numpy as np
+import scipy
+
+from scmkl.data_processing import process_data
+
+
+def calculate_z(adata, n_features = 5000) -> tuple:
+    '''
+    Function to calculate approximate kernels.
+    Input:
+            adata- Adata obj as created by `Create_Adata`
+                Sigma can be calculated with Estimate_Sigma or a heuristic but must be positive.
+            n_features- Number of random feature to use when calculating Z- used for scalability
+    Output:
+            adata_object with Z matrices accessible with- adata.uns['Z_train'] and adata.uns['Z_test'] respectively
+
+    '''
+    assert np.all(adata.uns['sigma'] > 0), 'Sigma must be positive'
+
+    #Number of groupings taking from group_dict
+    N_pathway = len(adata.uns['group_dict'].keys())
+    D = adata.uns['D']
+
+    # Create Arrays to store concatenated group Z.  Each group of features will have a corresponding entry in each array
+    Z_train = np.zeros((len(adata.uns['train_indices']), 2 * adata.uns['D'] * N_pathway))
+    Z_test = np.zeros((len(adata.uns['test_indices']), 2 * adata.uns['D'] * N_pathway))
+
+    # Loop over each of the groups and creating Z for each
+    for m, group_features in enumerate(adata.uns['group_dict'].values()):
+        
+        #Extract features from mth group
+        num_group_features = len(group_features)
+
+        # group_feature_indices = adata.uns['seed_obj'].integers(low = 0, high = num_group_features, size = np.min([n_features, num_group_features]))
+        # group_features = np.array(list(group_features))[group_feature_indices]
+        group_features = adata.uns['seed_obj'].choice(np.array(list(group_features)), np.min([n_features, num_group_features]), replace = False) 
+
+        # Create data arrays containing only features within this group
+        X_train = adata[adata.uns['train_indices'],:][:, group_features].X
+        X_test = adata[adata.uns['test_indices'],:][:, group_features].X
+
+
+        X_train, X_test = process_data(X_train = X_train, X_test = X_test, data_type = adata.uns['data_type'], return_dense = True)
+
+        #Extract pre-calculated sigma used for approximating kernel
+        adjusted_sigma = adata.uns['sigma'][m]
+
+        #Calculates approximate kernel according to chosen kernel function- may add more functions in the future
+        #Distribution data comes from Fourier Transform of original kernel function
+        if adata.uns['kernel_type'].lower() == 'gaussian':
+
+            gamma = 1/(2*adjusted_sigma**2)
+            sigma_p = 0.5*np.sqrt(2*gamma)
+
+            W = adata.uns['seed_obj'].normal(0, sigma_p, X_train.shape[1]*D).reshape((X_train.shape[1]),D)
+
+        elif adata.uns['kernel_type'].lower() == 'laplacian':
+
+            gamma = 1/(2*adjusted_sigma)
+
+            W = gamma * adata.uns['seed_obj'].standard_cauchy(X_train.shape[1]*D).reshape((X_train.shape[1],D))
+
+        elif adata.uns['kernel_type'].lower() == 'cauchy':
+
+            gamma = 1/(2*adjusted_sigma**2)
+            b = 0.5*np.sqrt(gamma)
+
+            W = adata.uns['seed_obj'].laplace(0, b, X_train.shape[1]*D).reshape((X_train.shape[1],D))
+
+
+        train_projection = np.matmul(X_train, W)
+        test_projection = np.matmul(X_test, W)
+        
+
+        #Store group Z in whole-Z object.  Preserves order to be able to extract meaningful groups
+        Z_train[0:, np.arange( m * 2 * D , (m + 1) * 2 * D)] = np.sqrt(1/D)*np.hstack((np.cos(train_projection), np.sin(train_projection)))
+        Z_test[0:, np.arange( m * 2 * D , (m + 1) * 2 * D)] = np.sqrt(1/D)*np.hstack((np.cos(test_projection), np.sin(test_projection)))
+
+    adata.uns['Z_train'] = Z_train
+    adata.uns['Z_test'] = Z_test
+
+
+    return adata

scmkl-0.1.0/scmkl/data_processing.py

@@ -0,0 +1,242 @@
+import tracemalloc
+import numpy as np
+import scipy
+import anndata as ad
+import gc
+
+from scmkl.tfidf import tfidf_filter
+
+
+def filter_features(X, feature_names, group_dict):
+    '''
+    Function to remove unused features from X matrix.  Any features not included in group_dict will be removed from the matrix.
+    Also puts the features in the same relative order (of included features)
+    Input:
+            X- Data array. Can be Numpy array or Scipy Sparse Array
+            feature_names- Numpy array of corresponding feature names
+            group_dict- Dictionary containing feature grouping information.
+                        Example: {geneset: np.array(gene_1, gene_2, ..., gene_n)}
+    Output:
+            X- Data array containing data only for features in the group_dict
+            feature_names- Numpy array of corresponding feature names from group_dict
+    '''
+    assert X.shape[1] == len(feature_names), 'Given features do not correspond with features in X'    
+
+    group_features = set()
+    feature_set = set(feature_names)
+
+    # Store all objects in dictionary in array
+    for group in group_dict.keys():
+        group_features.update(set(group_dict[group]))
+
+        group_dict[group] = np.sort(np.array(list(feature_set.intersection(set(group_dict[group])))))
+
+    # Find location of desired features in whole feature set
+    group_feature_indices = np.where(np.in1d(feature_names, np.array(list(group_features)), assume_unique = True))[0]
+
+    # Subset only the desired features and their data
+    X = X[:,group_feature_indices]
+    feature_names = np.array(list(feature_names))[group_feature_indices]
+
+    return X, feature_names, group_dict
+
+
+def train_test_split(y, train_indices = None, seed_obj = np.random.default_rng(100), train_ratio = 0.8):
+    '''
+    Function to calculate training and testing indices for given dataset. If train indices are given, it will calculate the test indices.
+        If train_indices == None, then it calculates both indices, preserving the ratio of each label in y
+    Input:
+            y- Numpy array of cell labels. Can have any number of classes for this function.
+            train_indices- Optional array of pre-determined training indices
+            seed_obj- Numpy random state used for random processes. Can be specified for reproducubility or set by default.
+            train_ratio- decimal value ratio of features in training:testing sets
+    Output:
+            train_indices- Array of indices of training cells
+            test_indices- Array of indices of testing cells
+    '''
+
+    # If train indices aren't provided
+    if train_indices == None:
+
+        unique_labels = np.unique(y)
+        train_indices = []
+
+        for label in unique_labels:
+
+            # Find index of each unique label
+            label_indices = np.where(y == label)[0]
+
+            # Sample these indices according to train ratio
+            train_label_indices = seed_obj.choice(label_indices, int(len(label_indices) * train_ratio), replace = False)
+            train_indices.extend(train_label_indices)
+    else:
+        assert len(train_indices) <= len(y), 'More train indices than there are samples'
+
+    train_indices = np.array(train_indices)
+
+    # Test indices are the indices not in the train_indices
+    test_indices = np.setdiff1d(np.arange(len(y)), train_indices, assume_unique = True)
+
+    return train_indices, test_indices
+
+def sparse_var(X, axis = None):
+
+    '''
+    Function to calculate variance on a sparse matrix.
+    Input:
+        X- A scipy sparse or numpy array
+        axis- Determines which axis variance is calculated on. Same usage as Numpy
+            axis = 0 => column variances
+            axis = 1 => row variances
+            axis = None => total variance (calculated on all data)
+    Output:
+        var- Variance values calculated over the given axis
+    '''
+
+    # E[X^2] - E[X]^2
+    if scipy.sparse.issparse(X):
+        var = np.array((X.power(2).mean(axis = axis)) - np.square(X.mean(axis = axis)))
+    else:
+        var = np.var(X, axis = axis)
+    return var.ravel()
+
+def process_data(X_train, X_test = None, data_type = 'counts', return_dense = True):
+
+
+    '''
+    Function to preprocess data matrix according to type of data (counts- e.g. rna, or binary- atac)
+    Will process test data according to parameters calculated from test data
+
+    Input:
+        X_train- A scipy sparse or numpy array
+        X_train- A scipy sparse or numpy array
+        data_type- 'counts' or 'binary'.  Determines what preprocessing is applied to the data. 
+            Log transforms and standard scales counts data
+            TFIDF filters ATAC data to remove uninformative columns
+    Output:
+        X_train, X_test- Numpy arrays with the process train/test data respectively.
+    '''
+
+    # Remove features that have no variance in the training data (will be uniformative)
+    assert data_type in ['counts', 'binary'], 'Improper value given for data_type'
+
+    if X_test == None:
+            X_test = X_train[:1,:] # Creates dummy matrix to for the sake of calculation without increasing computational time
+            orig_test = None
+    else:
+        orig_test = 'given'
+
+    var = sparse_var(X_train, axis = 0)
+    variable_features = np.where(var > 1e-5)[0]
+
+    X_train = X_train[:,variable_features]
+    X_test = X_test[:, variable_features]
+
+    #Data processing according to data type
+    if data_type.lower() == 'counts':
+
+        if scipy.sparse.issparse(X_train):
+            X_train = X_train.log1p()
+            X_test = X_test.log1p()
+        else:
+            X_train = np.log1p(X_train)
+            X_test = np.log1p(X_test)
+            
+        #Center and scale count data
+        train_means = np.mean(X_train, 0)
+        train_sds = np.sqrt(var[variable_features])
+
+        X_train = (X_train - train_means) / train_sds
+        X_test = (X_test - train_means) / train_sds
+    
+    elif data_type.lower() == 'binary':
+
+        # TFIDF filter binary peaks
+        non_empty_row = np.where(np.sum(X_train, axis = 1) > 0)[0]
+
+        if scipy.sparse.issparse(X_train):
+            non_0_cols = tfidf_filter(X_train.toarray()[non_empty_row,:], mode= 'filter')
+        else:
+            non_0_cols = tfidf_filter(X_train[non_empty_row,:], mode = 'filter')
+
+        X_train = X_train[:, non_0_cols]
+        X_test = X_test[:, non_0_cols]
+
+    if return_dense and scipy.sparse.issparse(X_train):
+        X_train = X_train.toarray()
+        X_test = X_test.toarray()
+
+    if orig_test == None:
+        return X_train
+    else:
+        return X_train, X_test
+
+def create_adata(X, feature_names: np.ndarray, cell_labels: np.ndarray, group_dict: dict, data_type: str, split_data = None, D = 100, 
+                 remove_features = False, distance_metric = 'euclidean', kernel_type = 'Gaussian', random_state = 1):
+    
+    '''
+    Function to create an AnnData object to carry all relevant information going forward
+
+    Input:
+        X- A data matrix of cells by features can be a numpy array, scipy sparse array or pandas dataframe (sparse array recommended for large datasets)
+        feature_names- A numpy array of feature names corresponding with the features in X
+        cell_labels- A numpy array of cell phenotypes corresponding with the cells in X.  Must be binary
+        group_dict- Dictionary containing feature grouping information.
+                        Example: {geneset: np.array(gene_1, gene_2, ..., gene_n)}
+        data_type- 'counts' or 'binary'.  Determines what preprocessing is applied to the data. 
+            Log transforms and standard scales counts data
+            TFIDF filters binary data
+        split_data- Either numpy array of precalculated train/test split for the cells -or-
+                            None.  If None, the train test split will be calculated with balanced classes.
+        D- Number of Random Fourier Features used to calculate Z. Should be a positive integer.
+                Higher values of D will increase classification accuracy at the cost of computation time
+        remove_features- Bool whether to filter the features from the dataset.
+                Will remove features from X, feature_names not in group_dict and remove features from groupings not in feature_names
+        random_state- Integer random_state used to set the seed for reproducibilty.
+    Output:
+        AnnData object with: 
+            Data equal to the values in X- accessible with adata.X
+            Variable names equal to the values in feature_names- accessible with adata.var_names
+            Cell phenotypes equal to the values in cell_labels- accessible with adata.obs['labels']
+            Train/test split either as given or calculated in this function- accessible with adata.uns['train_indices'] and adata.uns['test_indices'] respectively
+            Grouping information equal to given group_dict- accessible with adata.uns['group_dict']
+            seed_obj with seed equal to 100 * random_state- accessible with adata.uns['seed_obj']
+            D- accessible with adata.uns['D']
+            Type of data to determine preprocessing steps- accessible with adata.uns['data_type']
+
+    '''
+
+    assert X.shape[0] == len(cell_labels), 'Different number of cells than labels'
+    assert X.shape[1] == len(feature_names), 'Different number of features in X than feature names'
+    assert len(np.unique(cell_labels)) == 2, 'cell_labels must contain 2 classes'
+    assert data_type in ['counts', 'binary'], 'data_type must be either "counts" or "binary"'
+    assert isinstance(D, int) and D > 0, 'D must be a positive integer'
+    assert kernel_type.lower() in ['gaussian', 'laplacian', 'cauchy'], 'Given kernel type not implemented. Gaussian, Laplacian, and Cauchy are the acceptable types.'
+
+    if remove_features:
+        X, feature_names, group_dict = filter_features(X, feature_names, group_dict)
+
+    adata = ad.AnnData(X)
+    adata.var_names = feature_names
+    adata.obs['labels'] = cell_labels
+    adata.uns['group_dict'] = group_dict
+    adata.uns['seed_obj'] = np.random.default_rng(100 * random_state)
+    adata.uns['data_type'] = data_type
+    adata.uns['D'] = D
+    adata.uns['kernel_type'] = kernel_type
+    adata.uns['distance_metric'] = distance_metric
+
+    if split_data == None:
+        train_indices, test_indices = train_test_split(cell_labels, seed_obj = adata.uns['seed_obj'])
+    else:
+        train_indices = np.where(split_data == 'train')[0]
+        test_indices = np.where(split_data == 'test')[0]
+
+    adata.uns['train_indices'] = train_indices
+    adata.uns['test_indices'] = test_indices
+
+
+    return adata
+
+
+

scmkl-0.1.0/scmkl/estimate_sigma.py

@@ -0,0 +1,47 @@
+import numpy as np
+import scipy
+
+from scmkl.data_processing import process_data
+
+
+def estimate_sigma(adata, n_features = 5000):
+    '''
+    Function to calculate approximate kernels widths to inform distribution for project of Fourier Features. Calculates one sigma per group of features
+    Input:
+            adata- Adata obj as created by `Create_Adata`
+            n_features- Number of random features to include when estimating sigma.  Will be scaled for the whole pathway set according to a heuristic. Used for scalability
+    Output:
+            adata object with sigma values.  Sigmas accessible by adata.uns['sigma']
+
+    '''
+ 
+    sigma_list = []
+
+    # Loop over every group in group_dict
+    for group_name, group_features in adata.uns['group_dict'].items():
+
+        # Select only features within that group and downsample for scalability
+        num_group_features = len(group_features)
+        group_features = adata.uns['seed_obj'].choice(np.array(list(group_features)), min([n_features, num_group_features]), replace = False) 
+
+        X_train = adata[adata.uns['train_indices'], group_features].X
+
+        X_train = process_data(X_train = X_train, data_type = adata.uns['data_type'], return_dense = True)
+        
+        # Sample cells because distance calculation are costly and can be approximated
+        distance_indices = adata.uns['seed_obj'].choice(np.arange(X_train.shape[0]), np.min((2000, X_train.shape[0])))
+
+        # Calculate Distance Matrix with specified metric
+        sigma = np.mean(scipy.spatial.distance.cdist(X_train[distance_indices,:], X_train[distance_indices,:], adata.uns['distance_metric']))
+
+        if sigma == 0:
+            sigma += 1e-5
+
+        if n_features < num_group_features:
+            sigma = sigma * num_group_features / n_features # Heuristic we calculated to account for fewer features used in distance calculation
+
+        sigma_list.append(sigma)
+    
+    adata.uns['sigma'] = np.array(sigma_list)
+        
+    return adata

scmkl-0.1.0/scmkl/multimodal_processing.py

@@ -0,0 +1,148 @@
+import numpy as np
+import anndata as ad
+import gc
+
+from scmkl.tfidf import tfidf_normalize
+from scmkl.estimate_sigma import estimate_sigma
+from scmkl.approx_kernels import calculate_z
+
+
+def combine_modalities(assay_1_name: str, assay_2_name: str,
+                       assay_1_adata, assay_2_adata,
+                       combination = 'concatenate'):
+    '''
+    Combines data sets for multimodal classification.  Combined group names are assay+group_name
+    Input:
+            Assay_#_name: Name of assay to be added to group_names as a string if overlap
+            Assay_#_adata: Anndata object containing Z matrices and annotations
+            combination: How to combine the matrices, either sum or concatenate
+    Output:
+            combined_adata: Adata object with the combined Z matrices and annotations.  Annotations must match
+    '''
+    assert assay_1_adata.shape[0] == assay_2_adata.shape[0], 'Cannot combine data with different number of cells.'
+    assert assay_1_name != assay_2_name, 'Assay names must be distinct'
+    assert combination.lower() in ['sum', 'concatenate']
+
+    assay1_groups = set(list(assay_1_adata.uns['group_dict'].keys()))
+    assay2_groups = set(list(assay_2_adata.uns['group_dict'].keys()))
+
+    if not np.all(assay_1_adata.uns['train_indices'] == assay_2_adata.uns['train_indices']):
+
+        assay_1_adata = ad.concat((assay_1_adata[assay_1_adata.uns['train_indices']], assay_1_adata[assay_1_adata.uns['test_indices']]), uns_merge = 'same')
+        assay_2_adata = ad.concat((assay_2_adata[assay_2_adata.uns['train_indices']], assay_2_adata[assay_2_adata.uns['test_indices']]), uns_merge = 'same')
+
+        assay_1_adata.uns['train_indices'] = np.arange(len(assay_1_adata.uns['train_indices']))
+        assay_1_adata.uns['test_indices'] = np.arange(len(assay_1_adata.uns['train_indices']), 
+                                                      len(assay_1_adata.uns['train_indices']) + len(assay_1_adata.uns['test_indices']))
+        
+        assay_2_adata.uns['train_indices'] = assay_1_adata.uns['train_indices'].copy()
+        assay_2_adata.uns['test_indices'] = assay_1_adata.uns['test_indices'].copy()
+
+    combined_adata = ad.concat((assay_1_adata, assay_2_adata), uns_merge = 'same', axis = 1, label = 'labels')
+    combined_adata.obs = assay_1_adata.obs
+
+    if 'Z_train' in assay_1_adata.uns and 'Z_train' in assay_2_adata.uns:
+        if combination == 'concatenate':
+            combined_adata.uns['Z_train'] = np.hstack((assay_1_adata.uns['Z_train'], assay_2_adata.uns['Z_train']))
+            combined_adata.uns['Z_test'] = np.hstack((assay_1_adata.uns['Z_test'], assay_2_adata.uns['Z_test']))
+
+        elif combination == 'sum':
+            assert assay_1_adata.uns['Z_train'].shape == assay_2_adata.uns['Z_train'].shape, 'Cannot sum Z matrices with different dimensions'
+            combined_adata.uns['Z_train'] = assay_1_adata.uns['Z_train'] + assay_2_adata.uns['Z_train']
+            combined_adata.uns['Z_test'] = assay_1_adata.uns['Z_test'] + assay_2_adata.uns['Z_test']
+
+    group_dict1 = assay_1_adata.uns['group_dict']
+    group_dict2 = assay_2_adata.uns['group_dict']
+
+    if len(assay1_groups.intersection(assay2_groups)) > 0:
+        new_dict = {}
+        for group, features in group_dict1.items():
+            new_dict[f'{assay_1_name}-{group}'] = features
+    
+        group_dict1 = new_dict
+
+        new_dict = {}
+        for group, features in group_dict2.items():
+            new_dict[f'{assay_2_name}-{group}'] = features
+    
+        group_dict2 = new_dict
+
+    group_dict = group_dict1 | group_dict2 #Combines the dictionaries
+    combined_adata.uns['group_dict'] = group_dict
+
+    if 'seed_obj' in assay_1_adata.uns_keys():
+        combined_adata.uns['seed_obj'] = assay_1_adata.uns['seed_obj']
+    else:
+        print('No random seed present in Adata, it is recommended for reproducibility.')
+
+    del assay_1_adata, assay_2_adata
+    gc.collect()
+
+    return combined_adata
+
+
+def multimodal_processing(assay1: str, assay2: str ,adata1, adata2, tfidf: list, z_calculation = False):
+    '''
+    Function to remove rows from both modalities when there is no signal present in at least 1.
+
+    Input:
+        assay<N>- Name of assay data contained in adata<N>
+        adata<N>- adata object created as above.
+        tfidf- list of boolean values whether to tfidf the respective matrices
+        z_calculation- Boolean value whether to calculate sigma and Z on the adata before combining
+                        Allows for individual kernel functions for each
+    Output:
+        adata- Concatenated adata objects with empty rows removed and matching order
+    '''
+
+    import warnings 
+    warnings.filterwarnings('ignore')
+
+    assert adata1.shape[0] == adata2.shape[0], 'Different number of cells present in each object'
+    assert np.all(adata1.uns['train_indices'] == adata2.uns['train_indices']), 'Different train indices'
+    assert np.all(adata1.uns['test_indices'] == adata2.uns['test_indices']), 'Different test indices'
+
+    non_empty_rows1 = np.where(np.sum(adata1.X, axis = 1) > 0)[0]
+    non_empty_rows2 = np.where(np.sum(adata2.X, axis = 1) > 0)[0]
+
+    train_test = np.repeat('train', adata1.shape[0])
+    train_test[adata1.uns['test_indices']] = 'test'
+
+    non_empty_rows = np.intersect1d(non_empty_rows1, non_empty_rows2)
+
+    train_test = train_test[non_empty_rows]
+    train_indices = np.where(train_test == 'train')[0]
+    test_indices = np.where(train_test == 'test')[0]
+
+    adata1.uns['train_indices'] = train_indices
+    adata2.uns['train_indices'] = train_indices
+    adata1.uns['test_indices'] = test_indices
+    adata2.uns['test_indices'] = test_indices
+
+    adata1 = adata1[non_empty_rows, :]
+    adata2 = adata2[non_empty_rows, :]
+
+    if tfidf[0]:
+        adata1 = tfidf_normalize(adata1, binarize= True)
+    if tfidf[1]:
+        adata2 = tfidf_normalize(adata2, binarize= True)
+
+    if z_calculation:
+        print('Estimating Sigma', flush = True)
+        adata1 = estimate_sigma(adata1, n_features= 200)
+        adata2 = estimate_sigma(adata2, n_features= 200)
+        
+        print('Calculating Z', flush = True)
+        adata1 = calculate_z(adata1, n_features = 5000)
+        adata2 = calculate_z(adata2, n_features= 5000)
+
+    if 'labels' in adata1.obs:
+        assert np.all(adata1.obs['labels'] == adata2.obs['labels']), 'Cell labels do not match between adata objects'
+
+    adata = combine_modalities(assay1, assay2, adata1, adata2, 'concatenate')
+
+    del adata1, adata2
+    gc.collect()
+
+    return adata    
+

scmkl-0.1.0/scmkl/optimize_alpha.py

@@ -0,0 +1,241 @@
+import numpy as np
+import gc
+import tracemalloc
+
+from scmkl.tfidf import tfidf_normalize
+from scmkl.estimate_sigma import estimate_sigma
+from scmkl.approx_kernels import calculate_z
+from scmkl.train import train_model
+from scmkl.test import calculate_auroc, find_selected_groups
+from scmkl.multimodal_processing import multimodal_processing
+
+
+def optimize_alpha(adata, group_size, tfidf = False, alpha_array = np.round(np.linspace(1.9,0.1, 10),2), k = 4):
+    '''
+    Iteratively train a grouplasso model and update alpha to find the parameter yielding the desired sparsity.
+    This function is meant to find a good starting point for your model, and the alpha may need further fine tuning.
+    Input:
+        adata- Anndata object with Z_train and Z_test calculated
+        group_size- Argument describing how the features are grouped. 
+            From Celer documentation:
+            "groupsint | list of ints | list of lists of ints.
+                Partition of features used in the penalty on w. 
+                    If an int is passed, groups are contiguous blocks of features, of size groups. 
+                    If a list of ints is passed, groups are assumed to be contiguous, group number g being of size groups[g]. 
+                    If a list of lists of ints is passed, groups[g] contains the feature indices of the group number g."
+            If 1, model will behave identically to Lasso Regression.
+        tfidf- Boolean value to determine if TFIDF normalization should be run at each fold. True means that it will be performed.
+        starting_alpha- The alpha value to start the search at.
+        alpha_array- Numpy array of all alpha values to be tested
+        k- number of folds to perform cross validation over
+            
+    Output:
+        sparsity_dict- Dictionary with tested alpha as keys and the number of selected pathways as the values
+        alpha- The alpha value yielding the number of selected groups closest to the target.
+    '''
+
+    assert isinstance(k, int) and k > 0, 'Must be a positive integer number of folds'
+
+    import warnings 
+    warnings.filterwarnings('ignore')
+
+    y = adata.obs['labels'].iloc[adata.uns['train_indices']].to_numpy()
+    
+    positive_indices = np.where(y == np.unique(y)[0])[0]
+    negative_indices = np.setdiff1d(np.arange(len(y)), positive_indices)
+
+    positive_annotations = np.arange(len(positive_indices)) % k
+    negative_annotations = np.arange(len(negative_indices)) % k
+
+    auc_array = np.zeros((len(alpha_array), k))
+
+    gc.collect()
+
+    for fold in np.arange(k):
+        
+        print(f'Fold {fold + 1}:\n Memory Usage: {[mem / 1e9 for mem in tracemalloc.get_traced_memory()]} GB')
+
+        cv_adata = adata[adata.uns['train_indices'],:]
+
+        fold_train = np.concatenate((positive_indices[np.where(positive_annotations != fold)[0]], negative_indices[np.where(negative_annotations != fold)[0]]))
+        fold_test = np.concatenate((positive_indices[np.where(positive_annotations == fold)[0]], negative_indices[np.where(negative_annotations == fold)[0]]))
+
+        cv_adata.uns['train_indices'] = fold_train
+        cv_adata.uns['test_indices'] = fold_test
+
+        if tfidf:
+            cv_adata = tfidf_normalize(cv_adata, binarize= True)
+
+        cv_adata = estimate_sigma(cv_adata, n_features = 200)
+        cv_adata = calculate_z(cv_adata, n_features= 5000)
+
+        gc.collect()
+
+        for i, alpha in enumerate(alpha_array):
+
+            
+            # print(f'  1. Memory Usage: {[mem / 1e9 for mem in tracemalloc.get_traced_memory()]} GB')
+            # print(f'   Adata size: {sys.getsizeof(cv_adata) / 1e9}')
+
+            cv_adata = train_model(cv_adata, group_size, alpha = alpha)
+
+            # print(f'  2. Memory Usage: {[mem / 1e9 for mem in tracemalloc.get_traced_memory()]} GB')
+            # print(f'   Adata size: {sys.getsizeof(cv_adata) / 1e9}')
+
+            auc_array[i, fold] = calculate_auroc(cv_adata)
+
+            # print(f'  3. Memory Usage: {[mem / 1e9 for mem in tracemalloc.get_traced_memory()]} GB')
+            # print(f'   Adata size: {sys.getsizeof(cv_adata) / 1e9}')
+            gc.collect()
+
+        del cv_adata
+        gc.collect()
+    # Take AUROC mean across the k folds
+    alpha_star = alpha_array[np.argmax(np.mean(auc_array, axis = 1))]
+    gc.collect()
+    
+
+    return alpha_star
+
+
+def optimize_sparsity(adata, group_size, starting_alpha = 1.9, increment = 0.2, target = 1, n_iter = 10):
+    '''
+    Iteratively train a grouplasso model and update alpha to find the parameter yielding the desired sparsity.
+    This function is meant to find a good starting point for your model, and the alpha may need further fine tuning.
+    Input:
+        adata- Anndata object with Z_train and Z_test calculated
+        group_size- Argument describing how the features are grouped. 
+            From Celer documentation:
+            "groupsint | list of ints | list of lists of ints.
+                Partition of features used in the penalty on w. 
+                    If an int is passed, groups are contiguous blocks of features, of size groups. 
+                    If a list of ints is passed, groups are assumed to be contiguous, group number g being of size groups[g]. 
+                    If a list of lists of ints is passed, groups[g] contains the feature indices of the group number g."
+            If 1, model will behave identically to Lasso Regression.
+        starting_alpha- The alpha value to start the search at.
+        increment- amount to adjust alpha by between iterations
+        target- The desired number of groups selected by the model.
+        n_iter- The maximum number of iterations to run
+            
+    Output:
+        sparsity_dict- Dictionary with tested alpha as keys and the number of selected pathways as the values
+        alpha- The alpha value yielding the number of selected groups closest to the target.
+    '''
+    assert increment > 0 and increment < starting_alpha, 'Choose a positive increment less than alpha'
+    assert target > 0 and isinstance(target, int), 'Choose an integer target number of groups that is greater than 0'
+    assert n_iter > 0 and isinstance(n_iter, int), 'Choose an integer number of iterations that is greater than 0'
+
+    y_train = adata.obs['labels'].iloc[adata.uns['train_indices']].to_numpy()
+    X_train = adata.uns['Z_train']
+
+    if isinstance(group_size, int):
+        num_groups = int(X_train.shape[1]/group_size)
+    else:
+        num_groups = len(group_size)
+
+    sparsity_dict = {}
+    alpha = starting_alpha
+
+    for i in np.arange(n_iter):
+        model = train_model(adata, group_size, alpha)
+        num_selected = len(find_selected_groups(adata))
+
+        sparsity_dict[np.round(alpha,4)] = num_selected
+
+        if num_selected < target:
+            #Decreasing alpha will increase the number of selected pathways
+            if alpha - increment in sparsity_dict.keys():
+                # Make increment smaller so the model can't go back and forth between alpha values
+                increment /= 2
+            alpha = np.max([alpha - increment, 1e-1]) #Ensures that alpha will never be negative
+        elif num_selected > target:
+            if alpha + increment in sparsity_dict.keys():
+                increment /= 2
+            alpha += increment
+        elif num_selected == target:
+            break
+
+    optimal_alpha = list(sparsity_dict.keys())[np.argmin([np.abs(selected - target) for selected in sparsity_dict.values()])]
+    return sparsity_dict, optimal_alpha
+
+
+def multimodal_optimize_alpha(adata1, adata2, group_size = 1, tfidf_list = [False, False], alpha_array = np.round(np.linspace(1.9,0.1, 10),2), k = 4):
+    '''
+    Iteratively train a grouplasso model and update alpha to find the parameter yielding the desired sparsity.
+    This function is meant to find a good starting point for your model, and the alpha may need further fine tuning.
+    Input:
+        adataX- Anndata objects with Z_train and Z_test calculated
+        group_size- Argument describing how the features are grouped. 
+            From Celer documentation:
+            "groupsint | list of ints | list of lists of ints.
+                Partition of features used in the penalty on w. 
+                    If an int is passed, groups are contiguous blocks of features, of size groups. 
+                    If a list of ints is passed, groups are assumed to be contiguous, group number g being of size groups[g]. 
+                    If a list of lists of ints is passed, groups[g] contains the feature indices of the group number g."
+            If 1, model will behave identically to Lasso Regression.
+        tifidf_list- a boolean mask where tfidf_list[0] and tfidf_list[1] are respective to adata1 and adata2
+            If True, tfidf normalization will be applied to the respective adata during cross validation
+        starting_alpha- The alpha value to start the search at.
+        alpha_array- Numpy array of all alpha values to be tested
+        k- number of folds to perform cross validation over
+            
+    Output:
+        sparsity_dict- Dictionary with tested alpha as keys and the number of selected pathways as the values
+        alpha- The alpha value yielding the number of selected groups closest to the target.
+    '''
+
+    assert isinstance(k, int) and k > 0, 'Must be a positive integer number of folds'
+
+    import warnings 
+    warnings.filterwarnings('ignore')
+
+    y = adata1.obs['labels'].iloc[adata1.uns['train_indices']].to_numpy()
+    
+    positive_indices = np.where(y == np.unique(y)[0])[0]
+    negative_indices = np.setdiff1d(np.arange(len(y)), positive_indices)
+
+    positive_annotations = np.arange(len(positive_indices)) % k
+    negative_annotations = np.arange(len(negative_indices)) % k
+
+    auc_array = np.zeros((len(alpha_array), k))
+
+    cv_adata1 = adata1[adata1.uns['train_indices'],:]
+    cv_adata2 = adata2[adata2.uns['train_indices'],:]
+
+    del adata1, adata2
+    gc.collect()
+
+    for fold in np.arange(k):
+        
+        print(f'Fold {fold + 1}:\n Memory Usage: {[mem / 1e9 for mem in tracemalloc.get_traced_memory()]} GB')
+
+        fold_train = np.concatenate((positive_indices[np.where(positive_annotations != fold)[0]], negative_indices[np.where(negative_annotations != fold)[0]]))
+        fold_test = np.concatenate((positive_indices[np.where(positive_annotations == fold)[0]], negative_indices[np.where(negative_annotations == fold)[0]]))
+
+        cv_adata1.uns['train_indices'] = fold_train
+        cv_adata1.uns['test_indices'] = fold_test
+        cv_adata2.uns['train_indices'] = fold_train
+        cv_adata2.uns['test_indices'] = fold_test
+
+        cv_adata = multimodal_processing('assay1', 'assay2', cv_adata1, cv_adata2, tfidf_list, z_calculation = True)
+        cv_adata.uns['seed_obj'] = cv_adata1.uns['seed_obj']
+
+        gc.collect()
+
+
+
+        for i, alpha in enumerate(alpha_array):
+
+            cv_adata = train_model(cv_adata, group_size, alpha = alpha)
+
+            auc_array[i, fold] = calculate_auroc(cv_adata)
+
+            # gc.collect()
+        del cv_adata
+        gc.collect()
+    # Take AUROC mean across the k folds
+    alpha_star = alpha_array[np.argmax(np.mean(auc_array, axis = 1))]
+    del cv_adata1, cv_adata2
+    gc.collect()
+    
+    return alpha_star

scmkl-0.1.0/scmkl/test.py

@@ -0,0 +1,114 @@
+import numpy as np
+import sklearn
+
+
+
+def predict(adata, metrics = None):
+    '''
+    Function to return predicted labels and calculate any of AUROC, Accuracy, F1 Score, Precision, Recall for a classification. 
+    Input:  
+            adata- adata object with trained model and Z matrices in uns
+            metrics- Which metrics to calculate on the predicted values
+
+    Output:
+            Values predicted by the model
+            Dictionary containing AUROC, Accuracy, F1 Score, Precision, and/or Recall depending on metrics argument
+
+    '''
+    y_test = adata.obs['labels'].iloc[adata.uns['test_indices']].to_numpy()
+    X_test = adata.uns['Z_test']
+    assert X_test.shape[0] == len(y_test), 'X and y must have the same number of samples'
+    assert all([metric in ['AUROC', 'Accuracy', 'F1-Score', 'Precision', 'Recall'] for metric in metrics]), 'Unknown metric provided.  Must be one or more of AUROC, Accuracy, F1-Score, Precision, Recall'
+
+    # Sigmoid function to force probabilities into [0,1]
+    probabilities = 1 / (1 + np.exp(-adata.uns['model'].predict(X_test)))
+
+    # Group Lasso requires 'continous' y values need to re-descritize it
+    y = np.zeros((len(y_test)))
+    y[y_test == np.unique(y_test)[0]] = 1
+
+    metric_dict = {}
+
+    #Convert numerical probabilities into binary phenotype
+    y_pred = np.array(np.repeat(np.unique(y_test)[1], len(y_test)), dtype = 'object')
+    y_pred[np.round(probabilities,0).astype(int) == 1] = np.unique(y_test)[0]
+
+    if metrics == None:
+        return y_pred
+
+    if 'AUROC' in metrics:
+        fpr, tpr, _ = sklearn.metrics.roc_curve(y, probabilities)
+        metric_dict['AUROC'] = sklearn.metrics.auc(fpr, tpr)
+    if 'Accuracy' in metrics:
+        metric_dict['Accuracy'] = np.mean(y_test == y_pred)
+    if 'F1-Score' in metrics:
+        metric_dict['F1-Score'] = sklearn.metrics.f1_score(y_test, y_pred, pos_label = np.unique(y_test)[0])
+    if 'Precision' in metrics:
+        metric_dict['Precision'] = sklearn.metrics.precision_score(y_test, y_pred, pos_label = np.unique(y_test)[0])
+    if 'Recall' in metrics:
+        metric_dict['Recall'] = sklearn.metrics.recall_score(y_test, y_pred, pos_label = np.unique(y_test)[0])
+
+    return y_pred, metric_dict
+
+
+def find_selected_groups(adata) -> np.ndarray:
+
+    '''
+    Function to find feature groups selected by the model during training.  If feature weight assigned by the model is non-0, then the group containing that feature is selected.
+    Inputs:
+        model- A trained celer.GroupLasso model.
+        group_names- An iterable object containing the group_names in the same order as the feature groupings from Data array.
+    Outpus:
+        Numpy array containing the names of the groups selected by the model.
+    '''
+
+    selected_groups = []
+    coefficients = adata.uns['model'].coef_
+    group_size = adata.uns['model'].get_params()['groups']
+    group_names = np.array(list(adata.uns['group_dict'].keys()))
+
+
+    for i, group in enumerate(group_names):
+        if not isinstance(group_size, (list, set, np.ndarray, tuple)):
+            group_norm = np.linalg.norm(coefficients[np.arange(i * group_size, (i+1) * group_size - 1)])
+        else: 
+            group_norm = np.linalg.norm(coefficients[group_size[i]])
+
+        if group_norm != 0:
+            selected_groups.append(group)
+
+    return np.array(selected_groups)
+
+
+def calculate_auroc(adata)-> float:
+    '''
+    Function to calculate the AUROC for a classification. 
+    Designed as a helper function.  Recommended to use Predict() for model evaluation.
+    Input:  
+            adata- adata object with trained model and Z matrices in uns
+    Output:
+            Calculated AUROC value
+    '''
+
+    y_test = adata.obs['labels'].iloc[adata.uns['test_indices']].to_numpy()
+    X_test = adata.uns['Z_test']
+
+    y_test = y_test.ravel()
+    assert X_test.shape[0] == len(y_test), f'X has {X_test.shape[0]} samples and y has {len(y_test)} samples.'
+
+    # Sigmoid function to force probabilities into [0,1]
+    probabilities = 1 / (1 + np.exp(-adata.uns['model'].predict(X_test)))
+    # Group Lasso requires 'continous' y values need to re-descritize it
+
+    y = np.zeros((len(y_test)))
+    y[y_test == np.unique(y_test)[0]] = 1
+    fpr, tpr, _ = sklearn.metrics.roc_curve(y, probabilities)
+    auc = sklearn.metrics.auc(fpr, tpr)
+    
+    return(auc)
+
+
+def extract_kernel_weights():
+    '''
+    '''
+    pass

scmkl-0.1.0/scmkl/tfidf.py

@@ -0,0 +1,94 @@
+import numpy as np
+import scipy
+
+
+def tfidf_filter(X, mode = 'filter'):
+    '''
+    Function to use Term Frequency Inverse Document Frequency filtering for atac data to find meaningful features. 
+    If input is pandas data frame or scipy sparse array, it will be converted to a numpy array.
+    Input:
+            x- Data matrix of cell x feature.  Must be a Numpy array or Scipy sparse array.
+            mode- Argument to determine what to return.  Must be filter or normalize
+    Output:
+            TFIDF- Output depends on given 'mode' parameter
+                'filter'- returns which column sums are non 0 i.e. which features are significant
+                'normalize'- returns TFIDF filtered data matrix of the same dimensions as x. Returns as scipy sparse matrix
+    '''
+
+    assert mode in ['filter', 'normalize'], 'mode must be "filter" or "normalize".'
+    
+    if scipy.sparse.issparse(X):
+        # row_sum = np.array(X.sum(axis=1)).flatten()
+        tf = scipy.sparse.csc_array(X)# / row_sum[:, np.newaxis])
+        doc_freq = np.array(np.sum(X > 0, axis=0)).flatten()
+    else:
+        # row_sum = np.sum(X, axis=1, keepdims=True)
+        tf = X# / row_sum    
+        doc_freq = np.sum(X > 0, axis=0)
+
+    idf = np.log1p((1 + X.shape[0]) / (1 + doc_freq))
+    tfidf = tf * idf
+
+    if mode == 'normalize':
+        if scipy.sparse.issparse(tfidf):
+            tfidf = scipy.sparse.csc_matrix(tfidf)
+        return tfidf
+    elif mode == 'filter':
+        significant_features = np.where(np.sum(tfidf, axis=0) > 0)[0]
+        return significant_features
+        
+
+def tfidf_normalize(adata, binarize = False):
+
+    '''
+    Function to TF IDF normalize the data in an adata object
+    If train/test indices are included in the object, it will calculate the normalization separately for the training and testing data
+        Otherwise it will calculate it on the entire dataset
+    If any rows are entirely 0, that row and its metadata will be removed from the object
+
+    Input:
+        adata- adata object with data in adata.X to be normalized
+            Can have train/test indices included or not
+        binarize- Boolean option to binarize the data
+    Output:
+        adata- adata object with same attributes as before, but the TF IDF normalized matrix in place of adata.X
+                    Will now have the train data stacked on test data, and the indices will be adjusted accordingly
+    '''
+
+    X = adata.X.copy()
+    row_sums = np.sum(X, axis = 1)
+    assert np.all(row_sums > 0), 'TFIDF requires all row sums be positive'
+
+    if binarize:
+        X[X>0] = 1
+
+    if 'train_indices' in adata.uns_keys():
+
+        train_indices = adata.uns['train_indices'].copy()
+        test_indices = adata.uns['test_indices'].copy()
+
+        tfidf_train = tfidf_filter(X[train_indices,:], mode = 'normalize')
+        tfidf_test = tfidf_filter(X, mode = 'normalize')[test_indices,:]
+
+        if scipy.sparse.issparse(X):
+            tfidf_norm = scipy.sparse.vstack((tfidf_train, tfidf_test))
+        else:
+            tfidf_norm = np.vstack((tfidf_train, tfidf_test))
+
+        ## I'm not sure why this reassignment is necessary, but without, the values will be saved as 0s in adata
+        adata.uns['train_indices'] = train_indices
+        adata.uns['test_indices'] = test_indices
+
+        combined_indices = np.concatenate((train_indices, test_indices))
+
+        adata_index = adata.obs_names[combined_indices].astype(int)
+        tfidf_norm = tfidf_norm[np.argsort(adata_index),:]
+
+    else:
+
+        tfidf_norm = tfidf_filter(X, mode = 'normalize')
+
+    adata.X = tfidf_norm.copy()
+    # adata = adata[adata.obs_names,:]
+
+    return adata

scmkl-0.1.0/scmkl/train.py

@@ -0,0 +1,52 @@
+import numpy as np
+import celer
+import gc
+import tracemalloc
+
+
+def train_model(adata, group_size = 1, alpha = 0.9):
+    '''
+    Function to fit a grouplasso model to the provided data.
+    Inputs:
+            Adata with Z matrices in adata.uns
+            group_size- Argument describing how the features are grouped. 
+                    From Celer documentation:
+                    "groupsint | list of ints | list of lists of ints.
+                        Partition of features used in the penalty on w. 
+                            If an int is passed, groups are contiguous blocks of features, of size groups. 
+                            If a list of ints is passed, groups are assumed to be contiguous, group number g being of size groups[g]. 
+                            If a list of lists of ints is passed, groups[g] contains the feature indices of the group number g."
+                    If 1, model will behave identically to Lasso Regression
+            alpha- Group Lasso regularization coefficient. alpha is a floating point value controlling model solution sparsity. Must be a positive float.
+                        The smaller the value, the more feature groups will be selected in the trained model.
+    Outputs:
+
+            adata object with trained model in uns accessible with- adata.uns['model']
+                Specifics of model:
+                    model- The trained Celer Group Lasso model.  Used in Find_Selected_Pathways() function for interpretability.
+                        For more information about attributes and methods see the Celer documentation at https://mathurinm.github.io/celer/generated/celer.GroupLasso.html.
+
+    '''
+    assert alpha > 0, 'Alpha must be positive'
+
+    y_train = adata.obs['labels'].iloc[adata.uns['train_indices']]
+    X_train = adata.uns['Z_train']
+
+    cell_labels = np.unique(y_train)
+
+    # This is a regression algorithm. We need to make the labels 'continuous' for classification, but they will remain binary.
+    # Casts training labels to array of -1,1
+    train_labels = np.ones(y_train.shape)
+    train_labels[y_train == cell_labels[1]] = -1
+
+    # Alphamax is a calculation to regularize the effect of alpha (a sparsity parameter) across different data sets
+    alphamax = np.max(np.abs(X_train.T.dot(train_labels))) / X_train.shape[0] * alpha
+
+    # Instantiate celer Group Lasso Regression Model Object
+    model = celer.GroupLasso(groups = group_size, alpha = alphamax)
+
+    # Fit model using training data
+    model.fit(X_train, train_labels.ravel())
+
+    adata.uns['model'] = model
+    return adata

scmkl-0.1.0/scmkl/utils.py

@@ -0,0 +1,97 @@
+import numpy as np
+import pandas as pd
+
+
+def find_overlap(start1, end1, start2, end2) -> bool:
+    '''
+    Function to determine whether two regions on the same chromosome overlap.
+    Input:
+        start1 : the start position for region 1
+        end1 : the end position for region 1
+        start2 : the start position for region 2
+        end2: the end postion for region 2
+    Output:
+        True if the regions overlap by 1bp
+        False if the regions do not overlap
+    '''
+    return max(start1,start2) <= min(end1, end2)
+
+
+def get_atac_groupings(gene_library : dict, feature_names : list | np.ndarray | pd.Series, gene_annotations : pd.DataFrame) -> dict:
+    '''
+    Function to create an ATAC region grouping for scMKL using genes in a gene set library.
+    Searches for regions in gene_annotations that overlap with assay features, then matches gene_names to genes in gene_library to create grouping.
+    Input:
+        gene_library : a dictionary with gene set names as keys and a set | list | np.ndarray of gene names
+        feature_names : an array of feature regions in scATAC assay
+        gene_annotations : a pd.DataFrame with columns [chr, start, stop, gene_name] where [chr, start, stop] for each row is the region of the gene_name gene body
+    Output:
+        ATAC_group_dict : a grouping dictionary with gene set names from gene_library as keys and an array of regions as values.
+    '''
+    assert ('chr' and 'start' and 'end' and 'gene_name') in gene_annotations.columns, "gene_annotations argument must be a dataframe with columns ['chr', 'start', 'end', 'gene_name']"
+
+    # Variables for region comparison and grouping creation
+    peak_gene_dict = {}
+    ga_regions = {}
+    feature_dict = {}
+    ATAC_grouping = {group : [] for group in gene_library.keys()}
+
+    # Creating a list of all gene names to filter gene annotations by, ensuring there are no NaN values in list
+    all_genes = [gene for group in gene_library.keys() for gene in gene_library[group] if type(gene) != float]
+
+    # Filtering gene_annotations by genes in the gene_library
+    gene_annotations = gene_annotations[np.isin(gene_annotations['gene_name'], all_genes)]
+
+    # Creating dictionaries from gene_annotations where:
+        # peak_gene_dict - (chr, start_location, end_location) : gene_name
+        # ga_regions - chr : np.ndarray([[start_location, end_location], [start_location, end_location], ...])
+    for i, anno in gene_annotations.iterrows():
+        peak_gene_dict[(anno['chr'], int(anno['start']), int(anno['end']))] = anno['gene_name']
+        if anno['chr'] in ga_regions.keys():
+            ga_regions[anno['chr']] = np.concatenate((ga_regions[anno['chr']], np.array([[anno['start'], anno['end']]], dtype = int)), axis = 0)
+        else:
+            ga_regions[anno['chr']] = np.array([[anno['start'], anno['end']]], dtype=int)
+
+    print("Gene Annotations Formatted", flush = True)
+
+    # Reformatting feature names to a list of lists where each element is a list of [chr, start_location, stop_location]
+    feature_names = [peak.split("-") for peak in feature_names]
+    # Creating a dictionary of features from assay where chr : np.ndarray([[start_location, end_location], [start_location, end_location], ...])
+    for peak_set in feature_names:
+        if peak_set[0] in feature_dict.keys():
+            feature_dict[peak_set[0]] = np.concatenate((feature_dict[peak_set[0]], np.array([[peak_set[1], peak_set[2]]], dtype = int)), axis = 0)
+        else:
+            feature_dict[peak_set[0]] = np.array([[peak_set[1], peak_set[2]]], dtype = int)
+
+    print("Assay Peaks Formatted", flush = True)
+
+    # This is where the regions in the assay and the regions in the annotations are compared then genes are matched between the gene_library and gene_annotation for the respective regions
+    # Iterating through all the chromosomes in the feature assay
+    print("Comparing Regions", flush = True)
+    for chrom in feature_dict.keys():
+        # Continuing if chromosom for iteration not in gene_annotations to reduce number of comparisons
+        if chrom not in ga_regions.keys():
+            continue
+        # Iterating through peaks in features for the given chromosome
+        for region in feature_dict[chrom]:
+            # Iteration through peaks in ga_regions (from gene_annotations) for the current chromosome during the iteration
+            for anno in ga_regions[chrom]:
+                # Checking if the current feature peak and ga_region peak overlap
+                if find_overlap(region[0], region[1], anno[0], anno[1]):
+                    gene = peak_gene_dict[(chrom, anno[0], anno[1])]
+                    # Iterating through all of the gene sets in gene_library to match gene for current ga_annotation peak to genes in gene sets
+                    for group in gene_library.keys():
+                        if gene in gene_library[group]:
+                            # Adding feature region to group in ATAC_grouping dict   
+                            ATAC_grouping[group].append("-".join([chrom, str(region[0]), str(region[1])]))
+
+        print(f'{chrom} Comparisons Complete', flush = True)
+
+    # Returning a dictionary with keys from gene_library keys and values are arrays of peaks from feature array that overlap with gene peaks from gene_annotations if respective genes are in gene_library[gene_set]
+    return ATAC_grouping
+
+
+def create_results_df():
+    '''
+    '''
+    pass

scmkl-0.1.0/scmkl.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: scmkl
+Version: 0.1.0
+Author: Sam Kupp, Ian VanGordon, Cigdem Ak
+Author-email: kupp@ohsu.edu, vangordi@ohsu.edu, ak@ohsu.edu
+Requires-Python: >3.11.1
+License-File: LICENSE
+Requires-Dist: wheel==0.41.2
+Requires-Dist: anndata==0.10.8
+Requires-Dist: celer==0.7.3
+Requires-Dist: numpy==1.26.0
+Requires-Dist: pandas==2.2.2
+Requires-Dist: scikit-learn==1.3.2
+Requires-Dist: scipy==1.14.1

scmkl-0.1.0/scmkl.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+scmkl/__init__.py
+scmkl/approx_kernels.py
+scmkl/data_processing.py
+scmkl/estimate_sigma.py
+scmkl/multimodal_processing.py
+scmkl/optimize_alpha.py
+scmkl/test.py
+scmkl/tfidf.py
+scmkl/train.py
+scmkl/utils.py
+scmkl.egg-info/PKG-INFO
+scmkl.egg-info/SOURCES.txt
+scmkl.egg-info/dependency_links.txt
+scmkl.egg-info/requires.txt
+scmkl.egg-info/top_level.txt

scmkl-0.1.0/scmkl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scmkl-0.1.0/scmkl.egg-info/requires.txt

@@ -0,0 +1,7 @@
+wheel==0.41.2
+anndata==0.10.8
+celer==0.7.3
+numpy==1.26.0
+pandas==2.2.2
+scikit-learn==1.3.2
+scipy==1.14.1

scmkl-0.1.0/scmkl.egg-info/top_level.txt

@@ -0,0 +1 @@
+scmkl

scmkl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scmkl-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='scmkl',
+    version='0.1.0',
+    author = 'Sam Kupp, Ian VanGordon, Cigdem Ak',
+    author_email = 'kupp@ohsu.edu, vangordi@ohsu.edu, ak@ohsu.edu',
+    packages=find_packages(),
+    python_requires='>3.11.1',
+    install_requires = [
+        'wheel==0.41.2',
+        'anndata==0.10.8',
+        'celer==0.7.3',
+        'numpy==1.26.0',
+        'pandas==2.2.2',
+        'scikit-learn==1.3.2',
+        'scipy==1.14.1'
+    ]
+)