NetAnalyzer 1.0.0__py3-none-any.whl

NetAnalyzer/__init__.py

@@ -0,0 +1,11 @@
+from NetAnalyzer.netanalyzer import NetAnalyzer
+from NetAnalyzer.net_parser import Net_parser
+from NetAnalyzer.adv_mat_calc import Adv_mat_calc
+from NetAnalyzer.graph2sim import Graph2sim
+from NetAnalyzer.net_plotter import Net_plotter
+from NetAnalyzer.ranker import Ranker
+from NetAnalyzer.performancer import Performancer
+from NetAnalyzer.integration import Kernels
+from NetAnalyzer.main_modules import *
+from NetAnalyzer.cli_manager import *
+from NetAnalyzer.seed_parser import SeedParser

NetAnalyzer/adv_mat_calc.py

@@ -0,0 +1,106 @@
+import sys 
+import numpy as np
+from scipy import linalg
+import scipy.stats as stats
+import umap
+from warnings import warn
+class Adv_mat_calc:
+
+	
+	@staticmethod
+	def data2umap(data, n_neighbors = 15, min_dist = 0.1, n_components = 2, metric = 'euclidean', random_seed = None): #2exp?
+	    reducer = umap.UMAP(n_neighbors=n_neighbors, min_dist=min_dist, n_components=n_components, metric=metric, random_state= random_seed)
+	    umap_coords = reducer.fit_transform(data)
+	    return umap_coords
+
+	# Alaimo 2014, doi: 10.3389/fbioe.2014.00071
+	@staticmethod
+	def tranference_resources(matrix1, matrix2, lambda_value1 = 0.5, lambda_value2 = 0.5): #2exp?
+		# TODO (Fede,19/12/22) An extension to n layers would be possible with an iterative process.
+		m1rowNumber, m1colNumber = matrix1.shape
+		m2rowNumber, m2colNumber = matrix2.shape
+		matrix1Weight = Adv_mat_calc.graphWeights(m1colNumber, m1rowNumber, matrix1.T, lambda_value1)
+		matrix2Weight = Adv_mat_calc.graphWeights(m2colNumber, m2rowNumber, matrix2.T, lambda_value2)
+		matrixWeightProduct = np.dot(matrix1Weight, np.dot(matrix2, matrix2Weight))
+		finalMatrix = np.dot(matrix1, matrixWeightProduct)
+		return finalMatrix
+
+	@staticmethod
+	def graphWeights(rowsNumber, colsNumber, inputMatrix, lambdaValue = 0.5): #2exp?
+	 	ky = np.diag((1.0 / inputMatrix.sum(0))) #sum cols
+	 	weigth = np.dot(inputMatrix, ky).T
+	 	weigth[np.isnan(weigth)] = 0 # if there is no neighbors, there is no weight
+	 	ky = None #free memory
+	 	weigth = np.dot(inputMatrix, weigth)
+
+	 	kx = inputMatrix.sum(1) #sum rows
+	 	
+	 	kx_lamb = kx ** lambdaValue
+	 	kx_lamb_mat = np.zeros((rowsNumber, rowsNumber))
+	 	for j in range(0,rowsNumber):
+	 		for i in range(0,rowsNumber):
+	 			kx_lamb_mat[j,i] = kx_lamb[i]
+	 	kx_lamb = None #free memory
+
+	 	kx_inv_lamb = kx ** (1 - lambdaValue)
+	 	kx_inv_lamb_mat = np.zeros((rowsNumber, rowsNumber))
+	 	for j in range(0,rowsNumber):
+	 		for i in range(0,rowsNumber):
+	 			kx_inv_lamb_mat[j,i] = kx_inv_lamb[i]
+	 	kx_inv_lamb = None #free memory
+
+	 	nx = 1.0/(kx_lamb_mat * kx_inv_lamb_mat) # inplace marks a matrix to be used by reference, not for value
+	 	nx[nx == np.inf] = 0 # if there is no neighbors, there is no weight
+	 	kx_lamb_mat = None #free memory
+	 	kx_inv_lamb_mat = None #free memory
+	 	weigth = weigth * nx
+	 	return weigth
+
+
+	@staticmethod
+	def disparity_filter_mat(matrix, rowIds, colIds, pval_threshold = 0.05): #2exp?
+	    pval_mat = Adv_mat_calc.get_disparity_backbone_pval(matrix)
+	    print(pval_mat)
+	    # Create edge list from that p value matrix
+	    result_mat = pval_mat < pval_threshold
+	    # adjacency matrix, obtained when p[i,j] OR p[j,i] match the criteria
+	    new_adj = result_mat.transpose() + result_mat
+	    print(new_adj)
+	    matrix[~new_adj] = 0
+
+	    # remove genes with no significance
+	    k = np.sum(new_adj, axis=0)
+
+	    final_adj_mat = matrix[:,k>0]
+	    final_adj_mat = final_adj_mat[k>0,:]
+	    final_rowIds = [node_id for node_id, is_good in zip(rowIds, list(k>0)) if is_good]
+	    final_colIds = [node_id for node_id, is_good in zip(colIds, list(k>0)) if is_good]
+
+	    return final_adj_mat, final_rowIds, final_colIds
+
+	@staticmethod
+	def filter_rowcols_by_whitelist(matrix, rowIds, colIds, whitelist, symmetric = False): #2exp?
+	    row_index = [ i for i, rowId in enumerate(rowIds) if rowId in whitelist ]
+	    if symmetric:
+	        col_index = row_index
+	    else:
+	        col_index = [ i for i, colId in enumerate(colIds) if colId in whitelist ]
+	    matrix = matrix[row_index]
+	    matrix = matrix[:,col_index]
+	    rowIds = [rowIds[i] for i in row_index]
+	    colIds = [colIds[i] for i in col_index]
+	    return matrix, rowIds, colIds
+
+
+	@staticmethod
+	def get_disparity_backbone_pval(matrix): #2exp?
+		# by the moment, implementetion square (?)
+		# TODO: Add a warning when not square matrix.
+		pval_mat = matrix
+		W = np.sum(pval_mat, axis=0) 
+		k = (pval_mat > 0).sum(0) 
+		# operacion vectorizada.
+		pval_mat = np.ones(matrix.shape)
+		for i in range(0,pval_mat.shape[1]):
+			pval_mat[:,i] = (1-(matrix[:,i]/W[i]))**(k[i]-1)
+		return pval_mat

NetAnalyzer/cli_manager.py

@@ -0,0 +1,331 @@
+import argparse
+import os
+from py_cmdtabs.cmdtabs import CmdTabs
+from NetAnalyzer.main_modules import *
+
+## TYPES 
+def based_0(string): return int(string) - 1
+
+def list_based_0(string): return CmdTabs.parse_column_indices(",", string)
+
+def single_split(string, sep = ","):
+    return string.strip().split(sep)
+
+def double_split(string, sep1=";", sep2=","):
+    return [sublst.split(sep2) for sublst in string.strip().split(sep1)]
+
+def loading_dic(string, sep1=";", sep2=","):
+    return {key: value for key, value in double_split(string, sep1=";", sep2=",")}
+
+def group_nodes_parse(string):
+	group_nodes = {}
+	if os.path.isfile(string):
+		with open(string) as file:
+			for line in file:
+				groupID, nodeID = line.strip().split("\t")
+				query = group_nodes.get(groupID)
+				if query is None:
+					group_nodes[groupID] = [nodeID]
+				else:
+					query.append(nodeID)
+	else:
+		for i, group in enumerate(string.split(";")):
+			group_nodes[i] = group.split(',')
+	
+	return group_nodes
+
+def graph_options_parse(string):
+    graph_options = {}
+    for pair in string.split(','):
+        fields = pair.split('=')
+        graph_options[fields[0]] = fields[1]
+    return graph_options
+
+## Common options
+##############################################
+
+def add_kernel_flags(parser, multiple = False):
+    if multiple:
+        type_parse = lambda x: single_split(x, sep=";")
+    else:
+        type_parse = lambda x: str(x)
+
+    parser.add_argument("-k", "--input_kernels", dest="kernel_files", default= None, type= lambda x: type_parse(x),
+                        help="The roots from each kernel to integrate")
+    parser.add_argument("-n", "--input_nodes", dest="node_files", default= None, type = lambda x: type_parse(x),
+                        help="The list of node for each kernel in lst format")
+
+def add_seed_flags(parser):
+    parser.add_argument("--seed_nodes", dest="seed_nodes", default=None,
+        help="The name of the nodes to use as seeds")
+    parser.add_argument("--seed_sep", dest="seed_sep", default=",",
+        help="Separator of seed genes. Only use when -s point to a file")
+
+def add_random_seed(parser, default_seed=None):
+    parser.add_argument("--seed", dest="seed", default= default_seed, type=int, 
+        help="Allows to set a seed for the randomization process. Set to a number. Otherwise results are not reproducible.")
+
+def add_output_flags(parser, default_opt={"output_file": "output_file"}):
+    parser.add_argument("-o","--output_file", dest="output_file", default=default_opt['output_file'],
+                        help="Output file name")
+
+def add_input_graph_flags(parser, multinet = False):
+    if multinet:
+        parser.add_argument("-i", "--input_file", dest="input_file", default= None, type = lambda string: loading_dic(string, sep1=";", sep2=","), 
+                    help="Input file to create networks for further analysis")
+        parser.add_argument("-n","--node_names_file", dest="node_files", default=None, type = lambda string: loading_dic(string, sep1=";", sep2=","),
+                    help="Files with node names corresponding to the input matrix, only use when -i is set to bin or matrix, could be two paths, indicating rows and cols, respectively. If just one path added, it is assumed to be for rows and cols")
+        # parser.add_argument("-l","--layers", dest="layers", default=[['layer', '-']], type= lambda x: double_split(x, sep1=";",sep2=","),
+        #                     help="Layer definition on network: layer1name,regexp1;layer2name,regexp2...")
+    else:
+        parser.add_argument("-i", "--input_file", dest="input_file", default= None, 
+                            help="Input file to create networks for further analysis")
+        parser.add_argument("-n","--node_names_file", dest="node_files", default=None, type = lambda x: single_split(x, sep=","),
+                            help="Files with node names corresponding to the input matrix, only use when -i is set to bin or matrix, could be two paths, indicating rows and cols, respectively. If just one path added, it is assumed to be for rows and cols")
+        parser.add_argument("-l","--layers", dest="layers", default=[['layer', '-']], type= lambda x: double_split(x, sep1=";",sep2=","),
+                            help="Layer definition on network: layer1name,regexp1;layer2name,regexp2...")
+    parser.add_argument("-s","--split_char", dest="split_char", default='\t',
+                        help = "Character for splitting input file. Default: tab")
+    parser.add_argument("-f","--input_format", dest="input_format", default='pair',
+                        help="Input file format: pair (default), bin, matrix")
+    parser.add_argument("--both_repre_formats", dest="load_both", default=False, action='store_true',
+                        help="If we need to load the adjacency matrixes and the graph object")
+
+def add_resources_flags(parser, default_opt={"threads": 1}):
+    parser.add_argument("-T", "--threads", dest="threads", default=default_opt["threads"], type=int,
+        help="Number of threads to use in computation.")
+
+
+def add_common_relations_process(parser):
+    parser.add_argument("-N","--no_autorelations", dest="no_autorelations", default=False, action='store_true',
+                        help="No processing autorelations")
+
+##############################################
+
+def integrate_kernels(args=None):
+    parser = argparse.ArgumentParser(description='Integrate kernels or embedding in matrix format')
+    add_kernel_flags(parser, multiple = True)
+    add_output_flags(parser, default_opt={"output_file": "general_matrix"})
+    parser.add_argument("-f","--format_kernel",dest= "input_format", default="bin", 
+                        help= "The format of the kernels to integrate")
+    parser.add_argument("-I", "--kernel_ids", dest="kernel_ids", default= None, type = lambda x: single_split(x, sep=";"),
+                        help="The names of each kernel")
+    # Integration conf
+    parser.add_argument("-i","--integration_type",dest= "integration_type", default=None, 
+                        help= "It specifies how to integrate the kernels")
+    parser.add_argument("--raw_values", dest="raw_values", default=False, action='store_true',help="Select this option to use the negatives and positives values, without translation")
+    parser.add_argument("--asym",dest= "symmetric", default=True, action='store_false',
+                        help= "It specifies if the kernel matrixes are or not symmetric")
+
+    # Resources
+    add_resources_flags(parser=parser, default_opt={"threads": 8})  
+    opts = parser.parse_args(args)
+    main_integrate_kernels(opts)
+
+def netanalyzer(args=None):
+    parser = argparse.ArgumentParser(description='Perform Network analysis from NetAnalyzer package')
+    add_common_relations_process(parser)
+    add_input_graph_flags(parser)
+    add_output_flags(parser, default_opt={"output_file": "output_file"})
+    add_random_seed(parser, default_seed=None)
+    parser.add_argument("-O", "--ontology", dest="ontologies", default=[], type=lambda x: double_split(x, sep1=";",sep2=","),
+                        help="String that define which ontologies must be used with each layer. String definition:'layer_name1,path_to_obo_file1;layer_name2,path_to_obo_file2'")
+    # Assoc
+    parser.add_argument("-P","--use_pairs", dest="use_pairs", default='conn',
+    help="Which pairs must be computed. 'all' means all posible pair node combinations and 'conn' means the pair are truly connected in the network. Default 'conn' ")
+    parser.add_argument("-m","--association_method", dest="meth", default=None,
+    help="select association method to perform the projections: counts, jaccard, simpson, geometric, cosine, pcc, hypergeometric, hypergeometric_bf, hypergeometric_bh, csi, transference, correlation, umap, pca, bicm")
+    parser.add_argument("-a","--assoc_file", dest="assoc_file", default='assoc_values.txt',
+    help="Output file name for association values")
+    parser.add_argument("-p","--performance_file", dest="performance_file", default='perf_values.txt',
+    help="Output file name for performance values")
+    parser.add_argument("-u","--use_layers", dest="use_layers", default=[], type= lambda x: double_split(x, sep1=";",sep2=","),
+    help="Set which layers must be used on association methods: layer1,layer2;layerA,layerB")
+    parser.add_argument("-c","--control_file", dest="control_file", default=None,
+    help="Control file name")
+    # Kernel 
+    parser.add_argument("-k","--kernel_method", dest="kernel", default=None,
+    help="Kernel operation to perform with the adjacency matrix")
+    parser.add_argument("--embedding_add_options", dest="embedding_add_options", default="",
+    help="Additional options for embedding kernel methods. It must be defines as '\"opt_name1\" : value1, \"opt_name2\" : value2,...' ")
+    parser.add_argument("-z","--normalize_kernel_values", dest="normalize_kernel", default=False, action='store_true',
+    help="Apply cosine normalization to the obtained kernel")
+    parser.add_argument("--coords2sim_type", dest="coords2sim_type", default="dotProduct", help= "Select the type of transformation from coords to similarity: dotProduct, normalizedScaling, infinity and int or float numbers")
+    parser.add_argument("-K","--kernel_file", dest="kernel_file", default='kernel_file',
+    help="Output file name for kernel values")
+    # Plotting
+    parser.add_argument("-g", "--graph_file", dest="graph_file", default=None,
+    help="Build a graphic representation of the network")
+    parser.add_argument("--graph_options", dest="graph_options", default={'method': 'elgrapho', 'layout': 'forcedir', 'steps': '30'}, type= graph_options_parse,
+    help="Set graph parameters as 'NAME1=value1,NAME2=value2,...")
+    # Nodes states
+    parser.add_argument("-r","--reference_nodes", dest="reference_nodes", default=[], type= lambda x: single_split(x, sep=","),
+    help="Node ids comma separared")
+    parser.add_argument("-G","--group_nodes", dest="group_nodes", default={}, type= group_nodes_parse,
+    help="File path or groups separated by ';' and group node ids comma separared")
+    parser.add_argument("-d","--delete", dest="delete_nodes", default=[], type= lambda x: single_split(x, sep=";"),
+    help="Remove nodes from file. If PATH;r then nodes not included in file are removed")
+    # Compare cluster
+    parser.add_argument("--overlapping_communities", dest ="overlapping_communities", default=False, action="store_true",
+        help=" This is needed to activate overlapping sensitive operations in communities analysis")
+    parser.add_argument("-R","--compare_clusters_reference", dest="compare_clusters_reference", default=None, type= group_nodes_parse,
+    help="File path or groups separated by ';' and group node ids comma separared")
+    parser.add_argument("--compare_clusters_join", dest="compare_clusters_join", default=None, 
+        help="Join strategy on comparing two types of clusters: union")
+    # Build cluster
+    parser.add_argument("-b", "--build_clusters_alg", dest="build_cluster_alg", default=None,
+    help="Type of cluster algorithm")
+    parser.add_argument("-B", "--build_clusters_add_options", dest="build_clusters_add_options", default="",
+    help="Additional options for clustering methods. It must be defines as '\"opt_name1\" : value1, \"opt_name2\" : value2,...'")
+    parser.add_argument("--output_build_clusters", dest="output_build_clusters", default=None, help= "output name for discovered clusters")
+    # Expand cluster
+    parser.add_argument("-x","--expand_clusters", dest="expand_clusters", default=None,
+    help="Method to expand clusters Available methods: sht_path")
+    parser.add_argument("--one_sht_pairs", dest="one_sht_pairs", default=False, action='store_true',
+    help="add this flag if expand cluster needed with just one of the shortest paths")
+    parser.add_argument("--output_expand_clusters", dest= "output_expand_clusters", default="expand_clusters.txt", help="outputname fopr expand clusters file")
+    # Cluster metrics
+    parser.add_argument("-M", "--group_metrics", dest="group_metrics", default=None, type= lambda x: single_split(x, sep=";"),
+    help="Perform group group_metrics")
+    parser.add_argument("--output_metrics_by_cluster", dest="output_metrics_by_cluster", default='group_metrics.txt', help= "output name for metrics by cluster file")
+    parser.add_argument("-S", "--summarize_metrics", dest="summarize_metrics", default=None, type= lambda x: single_split(x, sep=";"),
+    help="Summarize metrics from groups")
+    parser.add_argument("--output_summarized_metrics", dest="output_summarized_metrics", default='group_metrics_summarized.txt', help= "output name for summarized metrics file")
+    # Graph metrics by net or node
+    parser.add_argument("-A", "--attributes", dest="get_attributes", default=[], type =lambda x: single_split(x, sep=","),
+    help="String separated by commas with the name of node attribute")
+    parser.add_argument("--graph_attributes", dest="get_graph_attributes", default=[], type =lambda x: single_split(x, sep=","),
+    help="String separated by commas with the name of network attribute")
+    parser.add_argument("--attributes_summarize", dest="attributes_summarize", default= False, action = "store_true", help="If the attribtes needs to be obtained summarized") 
+    # DSL section
+    parser.add_argument("--dsl_script", dest="dsl_script", default=None,
+    help="Path to dsl script to perform complex analysis")
+    # Resources
+    add_resources_flags(parser=parser, default_opt={"threads": 2})
+
+    opts = parser.parse_args(args)
+    main_netanalyzer(opts)
+	
+def randomize_clustering(args=None):
+    parser = argparse.ArgumentParser(description='Perform clusters randomization')
+    add_output_flags(parser, default_opt={"output_file": "random_clusters.txt"})
+    parser.add_argument("-i", "--input_file", dest="input_file", default= None, 
+    help="Input file to create networks for further analysis")
+    parser.add_argument("-S", "--split_char", dest="column_sep", default = "\t", 
+    help="Character for splitting input file. Default: tab")
+    parser.add_argument("-a", "--aggregate_sep", dest="aggregate_sep", default = None, 
+    help="This option activates aggregation in output. Separator character must be provided")
+    parser.add_argument("-N", "--node_column", dest="node_index", default= 1, type=based_0, 
+    help="Number of the nodes column")
+    parser.add_argument("-C", "--cluster_column", dest="cluster_index", default= 0, type=based_0, 
+    help="Number of the clusters column")
+    parser.add_argument("-s", "--node_sep", dest="node_sep", default = None, 
+    help="Node split character. This option must to be used when input file is aggregated")
+    # random conf
+    parser.add_argument("-r", "--random_type", dest="random_type", default = ["hard_fixed"], type = lambda x: single_split(x,sep=":"), 
+    help="""Indicate random mode. First, the not custom randomization, where cluster size is the same: 
+    'hard_fixed' (fixing the number of communities a node belongs), 
+    'soft_fixed' (soft finxing the number of communities a node belongs by binomial model), 
+    'not_fixed' (just a sampling with replacement). 
+    Secondly, the custom size can be used with the format 'custom:n:s:r|nr' for generate 'n' clusters of 's' nodes and
+     r|nr for replacement or not, respectively. Default = 'hard_fixed'""")
+    add_random_seed(parser,  default_seed=123)
+    opts = parser.parse_args(args)
+    main_randomize_clustering(opts)
+
+def randomize_network(args=None):
+    parser = argparse.ArgumentParser(description='Perform Network analysis from NetAnalyzer package')
+    add_input_graph_flags(parser)
+    add_output_flags(parser, default_opt={"output_file": None})
+    add_random_seed(parser, default_seed=None)
+    # random conf
+    parser.add_argument("-r", "--type_random", dest="type_random", default= None, 
+            help="Randomized basis. 'nodes' Node-baseds randomize or 'links' Links-baseds randomize")
+    opts = parser.parse_args(args)
+    main_randomize_network(opts)
+
+def ranker(args=None):
+    parser = argparse.ArgumentParser(description='Get the ranks from a matrix similarity score and a list of seeds')
+    add_seed_flags(parser)
+    add_output_flags(parser, default_opt={"output_file": "ranked_genes"})
+    add_kernel_flags(parser, multiple = False)
+
+    # Output ranking
+    parser.add_argument("--seed_presence", dest="seed_presence", default=None,
+    help="Seed presence on list: 'remove', when seed is not added on the ranker calculation; 'annotate', when just tag on output is needed, and calculation is obtained inclusing the seeds: new, seed.")
+    parser.add_argument("--header", dest="header", default=False, 
+    action='store_true', help="Select this option if header needed")
+    # filtering
+    parser.add_argument("-f", "--filter", dest="filter", default=None,
+    help="PATH to file with seed_name and genes to keep in output")
+    parser.add_argument("--whitelist", dest="whitelist", default=None, type = open_whitelist, help= "File Path with the whitelist of nodes to take into account in the ranker process")
+    parser.add_argument("--minimum_size", dest="minimum_size", default=1, type=int)
+    # Options in ranker alg
+    parser.add_argument("-N","--normalize_matrix", dest="normalize_matrix", default= None,
+    help="Select the type of normalization, options are: None, by_column, by_row, by_row_col")
+    parser.add_argument("-p", "--propagate", dest="propagate", default = False, action = "store_true")
+    parser.add_argument("--propagate_options", dest="propagate_options", default =  '"tolerance": 1e-5, "iteration_limit": 100, "with_restart": 0',
+    help="Additional options for propagation methods. It must be defines as '\"opt_name1\" : value1, \"opt_name2\" : value2,...'")
+    # Benchmarking mode
+    parser.add_argument("-l", "--cross_validation", dest="cross_validation", default=False, 
+    action='store_true', help="To activate cross validation")
+    parser.add_argument("-K", "--k_fold", dest="k_fold", default=None, type=int, 
+    help="Indicate the number of itrations needed, not used for leave one out cross validation (loocv)")
+    # Select tops
+    parser.add_argument("-t", "--top_n", dest="top_n", default=None, type=int,
+    help="Top N genes to print in output")
+    parser.add_argument("--output_top", dest="output_top", default=None,
+    help="File to save Top N genes")
+    parser.add_argument("--add_tags", dest="add_tags", default=None, help="Adding node attribute by seed: format seed\\tnode\\tattr")
+    parser.add_argument("--representation_seed_metric", dest = "representation_seed_metric", default = "mean", 
+        help = "select the type of representation on seed, default mean, options: mean and max")
+    # Resources
+    add_resources_flags(parser=parser, default_opt={"threads": 1})
+    opts = parser.parse_args(args)
+    main_ranker(opts)
+
+def text2binary_matrix(args=None):
+    parser = argparse.ArgumentParser(description="Transforming matrix format and obtaining statistics")
+    add_output_flags(parser, default_opt={"output_file": None})
+    parser.add_argument('-i', '--input_file', dest="input_file", default=None,
+    help="input file")
+    parser.add_argument('-b', '--byte_format', dest="byte_format", default="float64",
+    help='Format of the numeric values stored in matrix. Default: float64, warning set this to less precission can modify computation results using this matrix.')
+    parser.add_argument('-t', '--input_type', dest="input_type", default='pair',
+    help='Set input format file. "pair", "matrix" or "bin"')
+    parser.add_argument('-O', '--output_type', dest="output_type", default='bin',
+    help='Set output format file. "bin" for binary (default) or "mat" for tabulated text file matrix')
+    # Process matrix
+    parser.add_argument('-d', '--set_diagonal', dest="set_diagonal", default=False, action='store_true',
+    help='Set to 1.0 the main diagonal')
+    parser.add_argument('-B', '--binarize', dest="binarize", default=None, type = float,
+    help='Binarize matrix changin x >= thr to one and any other to zero into matrix given')
+    parser.add_argument('-c', '--cutoff', dest="cutoff", default=None, type = float,
+    help='Cutoff matrix values keeping just x >= and setting any other to zero into matrix given')
+    # Get stats
+    parser.add_argument('-s', '--get_stats', dest="stats", default=None,
+    help='Get stats from the processed matrix')
+    
+    opts = parser.parse_args(args)
+    main_text2binary_matrix(opts)
+
+def net_explorer(args=None, test=False):
+    parser = argparse.ArgumentParser(description="Transforming matrix format and obtaining statistics")
+    add_common_relations_process(parser) # Common relations options
+    add_input_graph_flags(parser, multinet = True) # Input graph
+    add_seed_flags(parser) # Adding seeds
+    add_output_flags(parser, default_opt={"output_file": "output_file"})
+    # layer processing
+    parser.add_argument('-c', '--layer_cutoff', dest="layer_cutoff", default={}, type = lambda string: loading_dic(string, sep1=";", sep2=","),
+    help='Cutoff to apply to every layer in the multiplexed one')
+    # Analysis options
+    parser.add_argument("-l", "--neigh_level", dest="neigh_level", default={}, type = lambda string: loading_dic(string, sep1=";", sep2=","),
+    help="Defining the level of neighbourhood on the initial set of nodes")
+    parser.add_argument("--plot_network_method", dest="plot_network_method", default="pyvis",
+    help="Defining the plot method used on report")
+    parser.add_argument("--embedding_proj", dest="embedding_proj", default=None,
+    help="Select different projections methods: umap")
+    parser.add_argument("--compare_nets", dest="compare_nets", default=False, action="store_true")
+    opts = parser.parse_args(args)
+    to_test = main_net_explorer(opts, test)
+    if test: return to_test

NetAnalyzer/graph2sim.py

@@ -0,0 +1,106 @@
+import sys 
+import numpy as np
+from scipy import linalg
+from warnings import warn
+import networkx as nx
+#from NetAnalyzer.adv_mat_calc import Adv_mat_calc
+import py_exp_calc.exp_calc as pxc
+from pecanpy import pecanpy
+from gensim.models import Word2Vec
+
+class Graph2sim:
+
+	allowed_embeddings = ['node2vec', 'deepwalk']
+	allowed_kernels = ['el', 'ct', 'rf', 'me', 'vn', 'rl', 'ka', 'md']
+
+	def get_embedding(adj_mat, embedding_nodes, embedding = "node2vec", dimensions = 64, walk_length=30, num_walks = 200, p = 1, q = 1, workers = 16, window = 10, min_count=1, seed = None, quiet=False, batch_words=4):
+
+		emb_coords = None
+		if embedding in ['node2vec', 'deepwalk']: # TODO 'metapath2vec',
+			if embedding == 'node2vec' or embedding == "deepwalk":
+				if embedding == "deepwalk":
+					p = 1
+					q = 1 
+				verbose = not quiet
+				g = pecanpy.DenseOTF(p=p, q=q, workers=workers, verbose= verbose)
+				g = g.from_mat(adj_mat=adj_mat, node_ids=embedding_nodes)
+				walks = g.simulate_walks(num_walks=num_walks, walk_length=walk_length)
+				# use random walks to train embeddings
+				model = Word2Vec(walks, vector_size=dimensions, window=window, min_count=min_count, workers=workers) # point to extend
+				list_arrays=[model.wv.get_vector(str(n)) for n in embedding_nodes]
+				n_cols=list_arrays[0].shape[0] # Number of col
+				n_rows=len(list_arrays)# Number of rows
+				emb_coords = np.concatenate(list_arrays).reshape([n_rows,n_cols]) # Concat all the arrays at one.
+		else:
+			print('Warning: The embedding method was not specified or not exists.')                                                                                                      
+			sys.exit(0)
+
+		return emb_coords
+
+	def emb_coords2kernel(emb_coords, normalization = False, sim_type= "dotProduct"):
+		kernel = pxc.coords2sim(emb_coords, sim = sim_type)
+		if normalization: kernel = pxc.cosine_normalization(kernel)
+		return kernel
+
+	def get_kernel(matrix, kernel, normalization=False): #2exp?
+		#I = identity matrix
+		#D = Diagonal matrix
+		#A = adjacency matrix
+		#L = laplacian matrix = D − A
+		matrix_result = None
+		dimension_elements = np.shape(matrix)[1]
+		# In scuba code, the diagonal values of A is set to 0. In weighted matrix the kernel result is the same with or without this operation. Maybe increases the computing performance?
+		# In the md kernel this operation affects the values of the final kernel
+		#dimension_elements.times do |n|
+		#	matrix[n,n] = 0.0
+		#end
+		if kernel in ['el', 'ct', 'rf', 'me'] or 'vn' in kernel or 'rl' in kernel:
+			diagonal_matrix = np.zeros((dimension_elements,dimension_elements))
+			np.fill_diagonal(diagonal_matrix,matrix.sum(axis=1))	# get the total sum for each row, for this reason the sum method takes the 1 value. If sum colums is desired, use 0
+													# Make a matrix whose diagonal is row_sum
+			matrix_L = diagonal_matrix - matrix
+			if kernel == 'el': #Exponential Laplacian diffusion kernel(active). F Fouss 2012 | doi: 10.1016/j.neunet.2012.03.001
+				beta = 0.02
+				beta_product = matrix_L * -beta
+				#matrix_result = beta_product.expm
+				matrix_result = linalg.expm(beta_product)
+			elif kernel == 'ct': # Commute time kernel (active). J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+				matrix_result = np.linalg.pinv(matrix_L, hermitian=True) # Hermitian parameter added to ensure convergence, just for real symmetric matrixes.
+				# Anibal saids that this kernel was normalized. Why?. Paper do not seem to describe this operation for ct, it describes for Kvn or for all kernels, it is not clear.
+			elif kernel == 'rf': # Random forest kernel. J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+				matrix_result = np.linalg.inv(np.eye(dimension_elements) + matrix_L) #Krf = (I +L ) ^ −1
+			elif 'vn' in kernel: # von Neumann diffusion kernel. J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+				alpha = float(kernel.replace('vn', '')) * max(np.linalg.eigvals(matrix)) ** -1  # alpha = impact_of_penalization (1, 0.5 or 0.1) * spectral radius of A. spectral radius of A = absolute value of max eigenvalue of A 
+				# TODO: The expresion max(np.linalg.eigvals(matrix)) obtain the max eigen computing all but in ruby was used a power series to compute directly this value. Implement this
+				matrix_result = np.linalg.inv(np.eye(dimension_elements) - matrix * alpha ) #  (I -alphaA ) ^ −1
+			elif 'rl' in kernel: # Regularized Laplacian kernel matrix (active)
+				alpha = float(kernel.replace('rl', '')) * max(np.linalg.eigvals(matrix)) ** -1  # alpha = impact_of_penalization (1, 0.5 or 0.1) * spectral radius of A. spectral radius of A = absolute value of max eigenvalue of A
+				matrix_result = np.linalg.inv(np.eye(dimension_elements) + matrix_L * alpha ) #  (I + alphaL ) ^ −1
+			elif kernel == 'me': # Markov exponential diffusion kernel (active). G Zampieri 2018 | doi.org/10.1186/s12859-018-2025-5 . Taken from compute_kernel script
+				beta=0.04
+				#(beta/N)*(N*I - D + A)
+				id_mat = np.eye(dimension_elements)
+				m_matrix = (id_mat * dimension_elements - diagonal_matrix + matrix ) * (beta/dimension_elements)
+				#matrix_result = m_matrix.expm
+				matrix_result = linalg.expm(m_matrix)
+		elif kernel == 'ka': # Kernelized adjacency matrix (active). J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+			lambda_value = min(np.linalg.eigvals(matrix)) # TODO implent as power series as shown in ruby equivalent
+			matrix_result = matrix + np.eye(dimension_elements) * abs(lambda_value) # Ka = A + lambda*I # lambda = the absolute value of the smallest eigenvalue of A
+		elif 'md' in kernel: # Markov diffusion kernel matrix. G Zampieri 2018 | doi.org/10.1186/s12859-018-2025-5 . Taken from compute_kernel script
+			t = int(kernel.replace('md', ''))
+			#TODO: check implementation
+			col_sum = matrix.sum(axis=1)
+			p_mat = np.divide(matrix.T,col_sum).T
+			p_temp_mat = p_mat.copy()
+			zt_mat = p_mat.copy()
+			for i in range(0, t-1):
+				p_temp_mat = np.dot(p_temp_mat,p_mat)
+				zt_mat = zt_mat + p_temp_mat
+			zt_mat = zt_mat * (1.0/t)
+			matrix_result = np.dot(zt_mat, zt_mat.T)
+		else:
+			matrix_result = matrix
+			warn('Warning: The kernel method was not specified or not exists. The adjacency matrix will be given as result')
+			# This allows process a previous kernel and perform the normalization in a separated step.
+		if normalization: matrix_result = pxc.cosine_normalization(matrix_result)  #TODO: check implementation with Numo::array
+		return matrix_result