NetAnalyzer 1.0.0__tar.gz → 1.1.2__tar.gz

{netanalyzer-1.0.0 → netanalyzer-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: NetAnalyzer
-Version: 1.0.0
+Version: 1.1.2
 Summary: Python package for network analysis, operations and priorization.
 Home-page: https://github.com/seoanezonjic/NetAnalyzer/
 Author: seoanezonjic
@@ -15,7 +15,7 @@ License-File: LICENSE.txt
 Requires-Dist: importlib-metadata; python_version < "3.8"
 Requires-Dist: NetworkX
 Requires-Dist: numpy
-Requires-Dist: scipy==1.10.1
+Requires-Dist: scipy
 Requires-Dist: statsmodels
 Requires-Dist: graphviz
 Requires-Dist: mako
@@ -25,15 +25,20 @@ Requires-Dist: scikit-learn
 Requires-Dist: py_semtools
 Requires-Dist: umap-learn
 Requires-Dist: py_report_html
+Requires-Dist: gensim
 Requires-Dist: pecanpy
 Requires-Dist: typing_extensions
 Requires-Dist: py_cmdtabs
 Requires-Dist: py_exp_calc
 Requires-Dist: clusim
+Requires-Dist: nodevectors
+Requires-Dist: torch
+Requires-Dist: bicm
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
+Dynamic: license-file
 
 .. These are examples of badges you might want to add to your README:
    please update the URLs accordingly
@@ -84,3 +89,5 @@ This package is designed to perform various steps in network analysis and proces
 * Net plotting: Provides several tools for graphing networks from different net plotter packages (igraph, cytoscape, graphviz).
 
 Please, cite this library as: Rojano E., Seoane-Zonjic P., Bueno-Amorós A., Perkins JR., and Ranea JAG. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, DOI: 10.1007/978-3-319-56148-6_17.
+
+See https://github.com/seoanezonjic/NetAnalyzer

{netanalyzer-1.0.0 → netanalyzer-1.1.2}/README.rst

@@ -46,4 +46,6 @@ This package is designed to perform various steps in network analysis and proces
 * Prioritization: Applies propagation algorithms to prioritize nodes based on similarity metrics, such as the adjacency matrix, and a set of seed nodes.
 * Net plotting: Provides several tools for graphing networks from different net plotter packages (igraph, cytoscape, graphviz).
 
-Please, cite this library as: Rojano E., Seoane-Zonjic P., Bueno-Amorós A., Perkins JR., and Ranea JAG. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, DOI: 10.1007/978-3-319-56148-6_17.
+Please, cite this library as: Rojano E., Seoane-Zonjic P., Bueno-Amorós A., Perkins JR., and Ranea JAG. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, DOI: 10.1007/978-3-319-56148-6_17.
+
+See https://github.com/seoanezonjic/NetAnalyzer

{netanalyzer-1.0.0 → netanalyzer-1.1.2}/setup.cfg

@@ -25,7 +25,7 @@ install_requires =
 	importlib-metadata; python_version<"3.8"
 	NetworkX
 	numpy
-	scipy==1.10.1
+	scipy #==1.13.1 Version specified to be compatible with gensim (it allows a version lower than 1.14)
 	statsmodels
 	graphviz
 	mako
@@ -35,11 +35,15 @@ install_requires =
 	py_semtools
 	umap-learn
 	py_report_html
+	gensim #==4.3.3 Forcing to this version because it solves "triu" function importing error (it allows to be imported both from numpy and scipy)
 	pecanpy
 	typing_extensions
 	py_cmdtabs
 	py_exp_calc
 	clusim
+	nodevectors
+	torch
+	bicm
 
 [options.packages.find]
 where = src
@@ -55,7 +59,7 @@ testing =
 [options.entry_points]
 console_scripts = 
 	netanalyzer = NetAnalyzer.cli_manager:netanalyzer
-	integrate_kernels = NetAnalyzer.cli_manager:integrate_kernels
+	embedding_integrator = NetAnalyzer.cli_manager:embedding_integrator
 	randomize_clustering = NetAnalyzer.cli_manager:randomize_clustering
 	randomize_network = NetAnalyzer.cli_manager:randomize_network
 	ranker = NetAnalyzer.cli_manager:ranker

netanalyzer-1.1.2/src/NetAnalyzer/__init__.py

@@ -0,0 +1,16 @@
+import sys
+
+if sys.version_info[:2] >= (3, 8):
+    # TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
+    from importlib.metadata import PackageNotFoundError, version  # pragma: no cover
+else:
+    from importlib_metadata import PackageNotFoundError, version  # pragma: no cover
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = __name__
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

netanalyzer-1.1.2/src/NetAnalyzer/adv_mat_calc.py

@@ -0,0 +1,99 @@
+import warnings
+
+import numpy as np
+class Adv_mat_calc:
+
+	# 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)
+		result_mat = pval_mat < pval_threshold
+		new_adj = result_mat.transpose() + result_mat # adjacency matrix, obtained when p[i,j] OR p[j,i] match the criteria
+		matrix[~new_adj] = 0
+
+		# remove nodes with no significance
+		k = np.sum(result_mat, axis=1)
+		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.
+		if np.any(matrix < 0):
+			warnings.warn("Negative values detected in matrix. Passing to positive values by subtracting the minimum.")
+			matrix = matrix - np.min(matrix)
+		
+		# row_maxs = np.max(matrix, axis=1, keepdims=True)
+    	# # Avoid division by zero if a row is all zeros
+		# row_maxs[row_maxs == 0] = 1.0 
+		# matrix = matrix / row_maxs
+		W = np.sum(matrix, axis=0)
+		k = (matrix > 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-1.0.0 → netanalyzer-1.1.2}/src/NetAnalyzer/cli_manager.py

@@ -1,12 +1,12 @@
-import argparse
-import os
-from py_cmdtabs.cmdtabs import CmdTabs
+import argparse, os
 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 list_based_0(string): 
+    from py_cmdtabs.cmdtabs import CmdTabs
+    return CmdTabs.parse_column_indices(",", string)
 
 def single_split(string, sep = ","):
     return string.strip().split(sep)
@@ -34,6 +34,33 @@ def group_nodes_parse(string):
 	
 	return group_nodes
 
+def reference_nodes_parse(string):
+    references_nodes = []
+    if os.path.isfile(string):
+        with open(string) as file:
+            for line in file:
+                node = line.strip()
+                references_nodes.append(node)
+    else:
+        references_nodes = single_split(string, sep=",")
+    return references_nodes
+
+
+def external_cluster_metadata(string):
+	metadata = loading_dic(string)
+	if metadata.get("sim"): 
+		parsed_sim = {} 
+		with open(metadata["sim"]) as file:
+			for line in file:
+				line = line.strip().split("\t")
+				parsed_sim[(line[0],line[1])] = float(line[2])
+				parsed_sim[(line[1],line[0])] =	float(line[2])
+		metadata["sim"] = parsed_sim
+	if metadata.get("metadata_classify"): 
+		metadata["metadata_classify"] = group_nodes_parse(metadata["metadata_classify"])
+	return metadata
+
+
 def graph_options_parse(string):
     graph_options = {}
     for pair in string.split(','):
@@ -72,7 +99,7 @@ def add_output_flags(parser, default_opt={"output_file": "output_file"}):
 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")
+                    help="Input file to create networks for further analysis, specify NULL if no network needed")
         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=","),
@@ -91,6 +118,14 @@ def add_input_graph_flags(parser, multinet = False):
     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_cluster_flags(parser):
+    parser.add_argument("-G","--group_nodes", dest="group_nodes", default=None,
+    help="File path or groups separated by ';' and group node ids comma separared")
+    parser.add_argument("--group_node_column", dest="group_node_index", default= 1, type=based_0, 
+    help="Number of the nodes column")
+    parser.add_argument("--group_cluster_column", dest="group_cluster_index", default= 0, type=based_0, 
+    help="Number of the clusters column")
+
 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.")
@@ -99,10 +134,16 @@ def add_resources_flags(parser, default_opt={"threads": 1}):
 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 add_plotting_options(parser, default_opt={"graph_file": None}):
+    parser.add_argument("-g", "--graph_file", dest="graph_file", default=default_opt["graph_file"],
+        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,...")
 
 ##############################################
 
-def integrate_kernels(args=None):
+def embedding_integrator(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"})
@@ -120,7 +161,7 @@ def integrate_kernels(args=None):
     # Resources
     add_resources_flags(parser=parser, default_opt={"threads": 8})  
     opts = parser.parse_args(args)
-    main_integrate_kernels(opts)
+    main_embedding_integrator(opts)
 
 def netanalyzer(args=None):
     parser = argparse.ArgumentParser(description='Perform Network analysis from NetAnalyzer package')
@@ -128,8 +169,12 @@ def netanalyzer(args=None):
     add_input_graph_flags(parser)
     add_output_flags(parser, default_opt={"output_file": "output_file"})
     add_random_seed(parser, default_seed=None)
+    add_cluster_flags(parser)
     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'")
+    # Filters
+    parser.add_argument("--filter_connected_components", dest="filter_connected_components", default=None, type= lambda x: int(x),
+        help= "Specify the minimim size of the connected component to be taken into account")
     # 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' ")
@@ -137,34 +182,40 @@ def netanalyzer(args=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=","),
+    parser.add_argument("-u","--use_layers", dest="use_layers", default=[['layer']], 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("--cluster_embedding", dest="cluster_embedding", default="", help="Generate clustering from network embedding")
+    parser.add_argument("--cluster_embedding_add_options", dest="cluster_embedding_add_options", default="", help="Select specific parameters for the clustering")
     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("--embedding_coords", dest= "embedding_coords", default=False, action="store_true", help="Use this flag in case of obtaining the coordinates of the system")
     parser.add_argument("-K","--kernel_file", dest="kernel_file", default='kernel_file',
     help="Output file name for kernel values")
+    parser.add_argument("--external_embedding", dest="external_embedding", default=None, type = lambda x: single_split(x, sep=","),
+        help="Use this flag when an external embedding is needed for posterior analysis. Format: matrix_path,row_path,col_path. col_path just for kernel format")
     # 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,...")
+    add_plotting_options(parser)
     # 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("-r","--reference_nodes", dest="reference_nodes", default=[], type= lambda x: reference_nodes_parse(x),
+    help="Files to a column of nodes or node ids comma separared format in terminal")
+    parser.add_argument("--split_groups", dest="split_groups", default=False, action= "store_true",  
+        help="Split groups in subgroups based on clustering methods")
     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")
+    # Extract subgraph
+    parser.add_argument("--extract_subgraphs", dest="extract_subgraphs", default=False, action="store_true",
+                        help="Add this flag in case you want to create subgraphs from different communities")
+    # parittion metric
+    parser.add_argument("--external_metadata_cluster", dest="external_metadata_cluster", default = None, type = lambda x: external_cluster_metadata(x),
+    	help="Adding external metadata cluster to evaluate with external metrics. You can add similarity between nodes 'sim' or node classification 'metadata_classify' in a two level format with ; and ,")
+    parser.add_argument("--partition_metrics", dest="partition_metrics", default=False, action='store_true',
+    	help="Select this option to obatin global partition metrics")
     # 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")
@@ -177,7 +228,7 @@ def netanalyzer(args=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")
+    parser.add_argument("--output_build_clusters", dest="output_build_clusters", default="discovered_clusters.txt", 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")
@@ -187,7 +238,7 @@ def netanalyzer(args=None):
     # 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("--output_metrics_by_cluster", dest="output_metrics_by_cluster", default='group_metrics.txt', help= "output name for metrics by cluster file, by default: group_metrics.txt")
     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")
@@ -200,27 +251,21 @@ def netanalyzer(args=None):
     # DSL section
     parser.add_argument("--dsl_script", dest="dsl_script", default=None,
     help="Path to dsl script to perform complex analysis")
+    # output network
+    parser.add_argument("--output_network", dest="output_network", default=None,
+        help="Output of the network modified during process")
     # 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")
+    add_cluster_flags(parser)
     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: 
@@ -278,7 +323,12 @@ def ranker(args=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")
+        help = "select the type of representation on seed, default mean, options: mean, max, bayesian, stouffer, fisher")
+    parser.add_argument("--score2pvalue", dest="score2pvalue", default=None, help="""Passing score matrix to pvalue matrix to use as new scores
+        , the modes to pass to pvalues are: znormalization, quantile, logistic. When using logistic systems would train a logistic regression model.""",)
+    parser.add_argument("--training_dataset", dest="training_dataset", default=None, help="""Path to training 
+        dataset must be specified, where the format is: node1\\tnode2\\tP (Positive) or N (Negative)""")
+    parser.add_argument("--adj_matrix", dest="adj_matrix", default=None, help="""Path to the original adjacency matrix""")
     # Resources
     add_resources_flags(parser=parser, default_opt={"threads": 1})
     opts = parser.parse_args(args)
@@ -289,42 +339,67 @@ def text2binary_matrix(args=None):
     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("-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('-t', '--input_type', dest="input_type", default='pair',
-    help='Set input format file. "pair", "matrix" or "bin"')
+            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')
+            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')
+            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')
+            help='Binarize matrix changing 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')
+            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')
-    
+            help='Get stats from the processed matrix')
+    parser.add_argument('--non_symmetric', dest="symmetric", default=True, action='store_false',
+            help='Set to use non symmetric matrix. By default is symmetric')    
+    parser.add_argument('--coords2kernel', dest="coords2kernel",help="passing coordinates to kernel",default=None)
+    parser.add_argument('--umap', dest='umap', help="projects coords in umap",default=False, action="store_true")
+    parser.add_argument('--sparse_type', dest="sparse_type", default=None, help="""The type of sparse matrix for the output, this option is useful when output type is 
+         set to bin. The options are: bsr, coo, csc, csr, dia, dok, lil""")
+    parser.add_argument("--round", dest="round", default=None, type=int, help="choose this to round in the i-th digit for all the values in the matrix or relations")
+    parser.add_argument("--filter_by_nodes", dest="filter_by_nodes", default=None, 
+                        help= "File with the list of nodes to take into account in the output matrix, if not set all nodes are included")
+    # normalize matrix
+    parser.add_argument("--normalize_by", dest="normalize_by", default=None, type=str, help="Type of normalization for matrix: cosine, rows_cols, min_max")
+    # order
+    parser.add_argument('--matrix_row_index', dest="rowids_index", default=None,
+            help='File with ROW names to use as index to build the matrix. Order is take into account')
+    parser.add_argument('--matrix_col_index', dest="colids_index", default=None,
+            help='File with COLUMN names to use as index to build the matrix. Order is take into account')
+    parser.add_argument('--loading_matrix_format', dest="loading_matrix_format", default="dense",
+            help="""Select this to specify which is the matrix type during the INITIALIZATION of the matrix.
+              Possible values: dense or an sparse type of scipy (bsr, coo, csc, csr, dia, dok, lil).""")
+    parser.add_argument('--output_matrix_format', dest="output_matrix_format", default="dense",
+            help='Select this to specify which is the matrix type during the MANIPULATION of the matrix.' \
+            ' Possible values: dense or an sparse type of scipy (bsr, coo, csc, csr, dia, dok, lil).')
+    parser.add_argument('--write_matrix_format', dest="write_matrix_format", default="dense",
+            help="""Select this to specify which is the matrix type during the WRITING of the matrix.
+              Possible values: dense or an sparse type of scipy (bsr, coo, csc, csr, dia, dok, lil).""")
     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")
+    parser = argparse.ArgumentParser(description="Exploring different networks attributes")
     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"})
+    add_cluster_flags(parser)
+    add_plotting_options(parser, default_opt={"graph_file": "output_file"})
+    add_resources_flags(parser)
+    add_random_seed(parser)
     # 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')
+        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("--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("--embedding_proj", dest="embedding_proj", default=None,
-    help="Select different projections methods: umap")
+        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)