NetAnalyzer 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53e3a09e27675b6e10398c8c869e31314c8afccb440b5f7d3cf2f84bec554d24
-  data.tar.gz: 17b9a25ca6e45512f049097dad67f3f8a12ab4cf12b2f5706b2777ec301f436f
+  metadata.gz: 1c71fe9b15d48d8ce8c76d2aec32a60ef2ede83686f49d18b09a8dc7204f07a9
+  data.tar.gz: 697edf91abebe9cbf600b65838dbaa9f0761342bb6f89bcbfadfab270e4ad1ce
 SHA512:
-  metadata.gz: 58d378216bdd2aaa7b374b43ce441500d0b08b2cf30e54a88cab9fec39c4ccad9dfe77554b7ef670d4a2874de9142c0046b5b2aa89be803c4a037d541816abf4
-  data.tar.gz: 5992bbed01102a8e59da389f872f24087e8d0f6f31aefe53518c49ba88e75730493fea725485686ab0c3b1c846c7d9afd2c4091163e97921670e5a6a8ddfac22
+  metadata.gz: eee16b18357c98e62ea4d1799991efb878ad8f8385d50a45a5f89154e3a36829e03768e560b8821dc0e0b7d10b64c2efee3bf3dadf13efb6adc7177f96e41e82
+  data.tar.gz: 1b2b19082a15a60df2585a99d6e3253eef98682398d6969aaa3e584ed8c425147f2389a668be3439474562b2da5100ec4d91f2790b9bce11b9bbbbf868251fb0

data/NetAnalyzer.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["elenarojano@uma.es, seoanezonjic@hotmail.com"]
 
   spec.summary       = %q{Network analysis tool that calculate and validate different association indices.}
-  spec.description   = %q{NetAnalyzer is a useful network analysis tool developed in Ruby that can 1) analyse any type of unweighted network, regardless of the number of layers, 2) calculate the relationship between different layers, using various association indices (Jaccard, Simpson, PCC, geometric, cosine and hypergeometric) and 3) validate the results}
+  spec.description   = %q{DEPRECATED PROJECT. MIGRATED TO PYTHON: https://github.com/seoanezonjic/NetAnalyzer. NetAnalyzer is a useful network analysis tool developed in Ruby that can 1) analyse any type of unweighted network, regardless of the number of layers, 2) calculate the relationship between different layers, using various association indices (Jaccard, Simpson, PCC, geometric, cosine and hypergeometric) and 3) validate the results}
   spec.homepage      = "https://github.com/ElenaRojano/NetAnalyzer"
   spec.license       = "MIT"
 

data/README.md

@@ -1,7 +1,9 @@
 # NetAnalyzer
 
+DEPRECATED PROJECT. MIGRATED TO [python semtools](https://github.com/seoanezonjic/NetAnalyzer)
+ 
 NetAnalyzer is a network analysis tool that can be used to calculate the associations between nodes in unweighted n-partite networks [1]. The calculation of the association between nodes is based on similarity indices (Jaccard, Simpson, geometric and cosine), statistic-based (Pearson correlation coefficient, CSI and  hypergeometric) [2] and a special metric designed only for tripartite networks (here called as 'transference' method [3]). The user can choose the association index method according to the network to analyse. The tool gives a table of results, with all the associations between nodes and the association value calculated.
-
+ 
 If you use this tool, please cite us: [1] E. Rojano, P. Seoane, A. Bueno, J. R. Perkins & J. A. G. Ranea. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, Vol 10208, 197-207 (2017).
 
 [2] Fuxman-Bass et al. Using networks to measure similarity between genes: association index selection. Nature Methods, 10(12):1169-76. 2013.

data/bin/NetAnalyzer.rb

@@ -176,26 +176,15 @@ OptionParser.new do |opts|
     options[:delete_nodes] = item.split(';')
   end
 end.parse!
-
 ##########################
 #MAIN
 ##########################
-fullNet = Network.new(options[:layers].map{|layer| layer.first})
+puts "Loading network data"
+fullNet = Net_parser.load(options)
 fullNet.reference_nodes = options[:reference_nodes]
 fullNet.threads = options[:threads]
 fullNet.group_nodes = options[:group_nodes]
 fullNet.set_compute_pairs(options[:use_pairs], !options[:no_autorelations])
-#puts options[:layers].map{|layer| layer.first}.inspect
-puts "Loading network data"
-if options[:input_format] == 'pair'
-  fullNet.load_network_by_pairs(options[:input_file], options[:layers], options[:split_char])
-elsif options[:input_format] == 'bin'
-  fullNet.load_network_by_bin_matrix(options[:input_file], options[:node_file], options[:layers])
-elsif options[:input_format] == 'matrix'
-  fullNet.load_network_by_plain_matrix(options[:input_file], options[:node_file], options[:layers], options[:splitChar])
-else
-  raise("ERROR: The format #{options[:input_format]} is not defined")
-end
 
 if !options[:delete_nodes].empty?
   node_list = load_file(options[:delete_nodes].first).flatten
@@ -243,8 +232,9 @@ if !options[:meth].nil?
   		line.chomp!
   		control << line.split("\t")
   	end
-  	fullNet.load_control(control)
-  	performance = fullNet.get_pred_rec(options[:meth])
+  	Performancer.load_control(control)
+    predictions = fullNet.association_values[options[:meth]]
+  	performance = Performancer.get_pred_rec(predictions)
   	File.open(options[:performance_file], 'w') do |f|
   		f.puts %w[cut prec rec meth].join("\t")
   		performance.each do |item|

data/bin/randomize_clustering.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+##############################
+#FUNCTIONS
+##############################
+
+
+def load_clusters(options)
+	clusters = {}
+	File.open(options[:input_file]).each do |line|
+		line = line.chomp.split(options[:column_sep])
+		cluster = line[options[:cluster_index]]
+		clusters[cluster] = [] if clusters[cluster].nil?
+		node = line[options[:node_index]]
+		node = node.split(options[:node_sep]) if !options[:node_sep].nil?
+		clusters[cluster] << node
+		clusters[cluster].flatten!
+	end
+	return clusters
+end
+
+
+def random_sample(nodes, replacement, all_sizes, seed)
+	random_clusters = {}
+	nodes_list = nodes.dup
+	all_sizes.each_with_index do |cluster_size, counter|
+		abort("Not enough nodes to generate clusters. Please activate replacement or change random mode") if cluster_size > nodes_list.size
+		random_nodes = nodes_list.uniq.sample(cluster_size, random: Random.new(seed))
+		if !replacement 
+			nodes_list = nodes_list - random_nodes
+		end
+		random_clusters["#{counter}_random"] = random_nodes
+		seed += 1
+	end
+	return random_clusters
+end
+
+def write_clusters(clusters, output_file, sep)
+	File.open(output_file, 'w') do |outfile|
+		clusters.each do |cluster, nodes|
+			nodes = [nodes.join(sep)] if !sep.nil?
+			nodes.each do |node|
+				outfile.puts [cluster, node].flatten.join("\t")
+			end
+		end		
+	end	
+end
+
+##############################
+#OPTPARSE
+##############################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file") do |input_file|
+    options[:input_file] = input_file
+  end
+
+  options[:node_index] = 1
+  opts.on("-N", "--node_column INTEGER", "Number of the nodes column. Default = #{options[:node_index]}") do |node_i|
+    options[:node_index] = node_i.to_i - 1
+  end
+
+  options[:cluster_index] = 0
+  opts.on("-C", "--cluster_column INTEGER", "Number of the clusters column. Default = #{options[:cluster_index]}" ) do |cluster_i|
+    options[:cluster_index] = cluster_i.to_i - 1
+  end
+
+  options[:column_sep] = "\t"
+  opts.on("-S", "--split_char CHARACTER", "Character for splitting input file. Default: tab") do |split_char|
+    options[:column_sep] = split_char
+  end
+
+  options[:node_sep] = nil
+  opts.on("-s", "--node_sep CHARACTER", "Node split character. This option must to be used when input file is aggregated.") do |split_char|
+    options[:node_sep] = split_char
+  end
+
+  options[:random_type] = ["size"]
+  opts.on("-r", "--random_type STRING", "Indicate random mode. 'size' for radomize clusters with the same size as input clusters. 'full_size' same as 'size' but all nodes are repaeted as same as input. 'fixed:n:s' for generate 'n' clusters of 's' nodes. Default = #{options[:output_file]}") do |random_type|
+    options[:random_type] = random_type.split(":")
+  end
+
+  options[:replacement] = false
+  opts.on("-R", "--replacement", "Boolean. Activates ramdom sampling with replacement. Sampling witout replacement will be executed instead.") do 
+    options[:replacement] = true
+  end
+
+  options[:output_file] = "./random_clusters.txt"
+  opts.on("-o", "--output_file FILEPATH", "Output file") do |output_file|
+    options[:output_file] = output_file
+  end
+
+  options[:aggregate_sep] = nil
+  opts.on("-a", "--aggregate_sep CHARACTER", "This option activates aggregation in output. Separator character must be provided") do |split_char|
+    options[:aggregate_sep] = split_char
+  end
+
+end.parse!
+##########################
+#MAIN
+##########################
+
+clusters = load_clusters(options)
+
+nodes = clusters.values.flatten
+nodes = nodes.uniq if !options[:random_type][0] == "full_size"
+
+if options[:random_type][0].include?("size") && options[:random_type].size == 1
+	all_sizes = clusters.map{|cluster, nodes| nodes.size}
+elsif options[:random_type][0] == "fixed" && options[:random_type].size == 3
+	all_sizes = Array.new(options[:random_type][1].to_i, options[:random_type][2].to_i)
+end
+
+random_clusters = random_sample(nodes, options[:replacement], all_sizes, 123)
+write_clusters(random_clusters, options[:output_file], options[:aggregate_sep])

data/bin/randomize_network.rb

@@ -0,0 +1,89 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+$LOAD_PATH.unshift(File.expand_path(File.join(ROOT_PATH, '..', 'lib')))
+require 'optparse'
+require 'benchmark'
+require 'NetAnalyzer'
+
+
+
+##############################
+#OPTPARSE
+##############################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file") do |input_file|
+    options[:input_file] = input_file
+  end
+
+  options[:node_file] = nil
+  opts.on("-n", "--node_names_file PATH", "File with node names corresponding to the input matrix, only use when -i is set to bin or matrix.") do |node_file|
+    options[:node_file] = node_file
+  end
+
+  options[:input_format] = 'pair'
+  opts.on("-f", "--input_format STRING", "Input file format: pair (default), bin, matrix") do |input_format|
+    options[:input_format] = input_format
+  end
+
+  options[:split_char] = "\t"
+  opts.on("-s", "--split_char CHARACTER", "Character for splitting input file. Default: tab") do |split_char|
+    options[:split_char] = split_char
+  end
+
+  options[:layers] = [:layer, '-']
+  opts.on("-l", "--layers STRING", "Layer definition on network: layer1name,regexp1;layer2name,regexp2...") do |layers|
+  	layers_definition = layers.split(";").map{|layer_attr| layer_attr.split(',')}
+	  layers_definition.map!{|layer_attr| [layer_attr.first.to_sym, /#{layer_attr.last}/]}
+    options[:layers] = layers_definition
+  end
+
+  options[:type_random] = nil
+  opts.on("-r", "--type_random network", "Randomized basis. 'nodes' Node-baseds randomize or 'links' Links-baseds randomize") do |type_random|
+    options[:type_random] = type_random
+  end
+
+  options[:output_file] = nil
+  opts.on("-o", "--output_file FILEPATH", "Output file") do |output_file|
+    options[:output_file] = output_file
+  end
+
+end.parse!
+
+
+##########################
+#MAIN
+##########################
+fullNet = Network.new(options[:layers].map{|layer| layer.first})
+puts "Loading network data"
+
+if options[:layers].length == 1
+  layerA = layerB = options[:layers][0].first
+elsif  options[:layers].length == 2
+  layerA = options[:layers][0].first
+  layerB = options[:layers][1].first
+end
+
+if options[:input_format] == 'pair'
+  fullNet.load_network_by_pairs(options[:input_file], options[:layers], options[:split_char])
+elsif options[:input_format] == 'bin' && !options[:node_file].nil?
+  fullNet.load_network_by_bin_matrix(options[:input_file], options[:node_file], options[:layers])
+elsif options[:input_format] == 'matrix' && !options[:node_file].nil?
+  fullNet.load_network_by_plain_matrix(options[:input_file], options[:node_file], options[:layers], options[:splitChar])
+else
+  raise("ERROR: The format #{options[:input_format]} is not defined")
+  exit
+end
+
+
+fullNet.randomize_network(options[:type_random])
+
+
+#fullNet.save_adjacency_matrix(layerA, layerB, options[:output_file])
+
+

data/bin/ranker_gene.rb

@@ -0,0 +1,121 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+$LOAD_PATH.unshift(File.expand_path(File.join(ROOT_PATH, '..', 'lib')))
+
+require 'optparse'
+require 'npy'
+require 'parallel'
+require 'NetAnalyzer'
+
+
+########################### METHODS ########################
+#############################################################
+
+def write_ranking(file, ranking_list)
+  File.open(file ,'w') do |f|
+    ranking_list.each do |seed_name, ranking|
+      ranking.each do |ranked_gene| 
+        f.puts "#{ranked_gene.join("\t")}\t#{seed_name}"
+      end
+    end
+  end
+end
+
+
+########################### OPTPARSE ########################
+#############################################################
+
+options = {}
+OptionParser.new do  |opts|
+
+  options[:kernel_file] = nil
+  opts.on("-k","--input_kernels KER", "The roots from each kernel to integrate") do |ker|
+    options[:kernel_file] = ker
+  end
+
+  options[:node_file] = nil
+  opts.on("-n","--input_nodes NODE", "The list of node for each kernel in lst format") do |node_file|
+    options[:node_file] = node_file
+  end
+
+  options[:genes_seed] = nil
+  opts.on("-s","--genes_seed SEED", "The name of the gene to look for backups") do |genes_seed|
+    options[:genes_seed] = genes_seed
+  end
+
+  options[:seed_genes_sep] = ","
+  opts.on("-S","--genes_seed_sep SEP", "Separator of seed genes. Only use when -s point to a file") do |genes_seed|
+    options[:genes_seed] = genes_seed
+  end
+
+  options[:filter] = nil   
+  opts.on("-f","--filter NAME", "PATH to file with seed_name and genes to keep in output") do |file|
+    options[:filter] = file
+  end
+
+  options[:leave_one_out] = false 
+  opts.on("-l","--leave_one_out", "Perform leave one out from a seed genes group") do 
+    options[:leave_one_out] = true
+  end
+ 
+  options[:top_n] = nil   
+  opts.on("-t","--top_n INT", "Top N genes to print in output") do |str|
+    options[:top_n] = str.to_i
+  end
+
+  options[:output_top] = nil   
+  opts.on("--output_top PATH", "File to save Top N genes") do |path|
+    options[:output_top] = path
+  end
+
+  options[:output_name] = "ranked_genes"
+  opts.on("-o","--output_name NAME", "The name of the ranked file") do |output_name|
+    options[:output_name] = output_name
+  end
+
+  options[:threads] = 0
+  opts.on( '-T', '--threads INTEGER', 'Number of threads to use in computation, one thread will be reserved as manager.' ) do |opt|
+      options[:threads] = opt.to_i - 1
+  end
+end.parse!
+
+########################### MAIN ############################
+#############################################################
+
+ranker = Ranker.new()
+ranker.matrix = Npy.load(options[:kernel_file])
+ranker.load_nodes_from_file(options[:node_file])
+ranker.load_seeds(options[:genes_seed], sep: options[:seed_genes_sep])
+ranker.load_references(options[:filter], sep: ",") if !options[:filter].nil?
+ranker.do_ranking(leave_one_out: options[:leave_one_out], threads: options[:threads])
+rankings = ranker.ranking
+
+discarded_seeds = rankings.select{|seed_name, ranks| ranks.empty?}.keys
+if !discarded_seeds.empty?
+  File.open("#{options[:output_name]}_discarded",'w') do |f|
+    discarded_seeds.each do |seed_name|
+      f.puts "#{seed_name}\t#{ranker.seeds[seed_name].join(options[:seed_genes_sep])}"
+    end
+  end
+end
+
+if !options[:top_n].nil?
+  top_n = ranker.get_top(options[:top_n])
+  if options[:output_top].nil?
+    rankings = top_n
+  else
+    write_ranking(options[:output_top], top_n)
+  end
+end
+
+if !options[:filter].nil?
+  rankings = ranker.get_reference_ranks
+end
+
+if !rankings.empty?
+  write_ranking("#{options[:output_name]}_all_candidates", rankings)
+end
+
+
+

data/bin/text2binary_matrix.rb

@@ -220,6 +220,11 @@ optparse = OptionParser.new do |opts|
         options[:binarize] = opt.to_f
     end
 
+    options[:cutoff] = nil
+    opts.on( '-c', '--cutoff FLOAT', 'Cutoff matrix values keeping just x >= and setting any other to zero into matrix given' ) do |opt|
+        options[:cutoff] = opt.to_f
+    end
+
     options[:stats] = false
     opts.on( '-s', '--get_stats', 'Get stats from the processed matrix' ) do
         options[:stats] = true
@@ -266,7 +271,7 @@ if options[:set_diagonal]
 	end
 end
 
-if !options[:binarize].nil?
+if !options[:binarize].nil? && options[:cutoff].nil?
 	elements = matrix.shape.last
 	elements.times do |i|
 		elements.times do |j|
@@ -275,6 +280,15 @@ if !options[:binarize].nil?
 	end
 end
 
+if !options[:cutoff].nil? && options[:binarize].nil?
+	elements = matrix.shape.last
+	elements.times do |i|
+		elements.times do |j|
+			matrix[i,j] = matrix[i,j] >= options[:cutoff] ? matrix[i,j] : 0
+		end
+	end
+end
+
 if options[:stats]
 	stats = get_stats(matrix)
 	stats.each do |stat|

data/lib/NetAnalyzer/adv_mat_calc.rb

@@ -0,0 +1,117 @@
+require 'numo/narray'
+require 'numo/linalg'
+
+class Adv_mat_calc # Advanced matrix calculations
+	## KERNEL METHODS
+	#######################################################################################
+	def self.get_kernel(matrix, node_names, kernel, normalization=false)
+		#I = identity matrix
+		#D = Diagonal matrix
+		#A = adjacency matrix
+		#L = laplacian matrix = D − A
+		matrix_result = nil
+		dimension_elements = matrix.shape.last
+		# 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 == 'el' || kernel == 'ct' || kernel == 'rf' || 
+			kernel.include?('vn') || kernel.include?('rl') || kernel == 'me'
+			diagonal_matrix = matrix.sum(1).diag 	# 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 = Numo::Linalg.expm(beta_product, 14)
+			elsif kernel == 'ct' # Commute time kernel (active). J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+			    matrix_result = Numo::Linalg.pinv(matrix_L) # 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.
+			elsif kernel == 'rf' # Random forest kernel. J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+			    matrix_result = Numo::Linalg.inv(Numo::DFloat.eye(dimension_elements) + matrix_L) #Krf = (I +L ) ^ −1
+			elsif kernel.include?('vn') # von Neumann diffusion kernel. J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+			    alpha = kernel.gsub('vn', '').to_f * matrix.max_eigenvalue ** -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 = Numo::Linalg.inv(Numo::DFloat.eye(dimension_elements) - matrix * alpha ) #  (I -alphaA ) ^ −1
+			elsif kernel.include?('rl') # Regularized Laplacian kernel matrix (active)
+			    alpha = kernel.gsub('rl', '').to_f * matrix.max_eigenvalue ** -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 = Numo::Linalg.inv(Numo::DFloat.eye(dimension_elements) + matrix_L * alpha ) #  (I + alphaL ) ^ −1
+			elsif 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 = Numo::DFloat.eye(dimension_elements)
+				m_matrix = (id_mat * dimension_elements - diagonal_matrix + matrix ) * (beta/dimension_elements)
+				#matrix_result = m_matrix.expm
+			    matrix_result = Numo::Linalg.expm(m_matrix, 16)
+			end
+		elsif kernel == 'ka' # Kernelized adjacency matrix (active). J.-K. Heriche 2014 | doi: 10.1091/mbc.E13-04-0221
+			lambda_value = matrix.min_eigenvalue
+			matrix_result = matrix + Numo::DFloat.eye(dimension_elements) * lambda_value.abs # Ka = A + lambda*I # lambda = the absolute value of the smallest eigenvalue of A
+		elsif kernel.include?('md') # Markov diffusion kernel matrix. G Zampieri 2018 | doi.org/10.1186/s12859-018-2025-5 . Taken from compute_kernel script
+			t = kernel.gsub('md', '').to_i
+			#TODO: check implementation with Numo::array
+			col_sum = matrix.sum(1)
+			p_mat = matrix.div_by_vector(col_sum)
+			p_temp_mat = p_mat.clone
+			zt_mat = p_mat.clone
+			(t-1).times do
+				p_temp_mat = p_temp_mat.dot(p_mat)
+				zt_mat = zt_mat + p_temp_mat
+			end
+			zt_mat = zt_mat * (1.0/t)
+			matrix_result = zt_mat.dot(zt_mat.transpose)
+		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.
+		end
+		matrix_result = matrix_result.cosine_normalization if normalization #TODO: check implementation with Numo::array
+		return matrix_result
+	end
+
+	# Alaimo 2014, doi: 10.3389/fbioe.2014.00071
+	def self.tranference_resources(matrix1, matrix2, lambda_value1 = 0.5, lambda_value2 = 0.5)
+		m1rowNumber, m1colNumber = matrix1.shape
+		m2rowNumber, m2colNumber = matrix2.shape
+		#puts m1rowNumber, m1colNumber, m2rowNumber, m2colNumber
+		matrix1Weight = self.graphWeights(m1colNumber, m1rowNumber, matrix1.transpose, lambda_value1)
+		matrix2Weight = self.graphWeights(m2colNumber, m2rowNumber, matrix2.transpose, lambda_value2)
+		matrixWeightProduct = Numo::Linalg.dot(matrix1Weight, Numo::Linalg.dot(matrix2, matrix2Weight))
+		finalMatrix = Numo::Linalg.dot(matrix1, matrixWeightProduct)
+		return finalMatrix
+	end
+
+	def self.graphWeights(rowsNumber, colsNumber, inputMatrix, lambdaValue = 0.5)
+	 	ky = (1.0 / inputMatrix.sum(0)).diag #sum cols
+	 	weigth = Numo::Linalg.dot(inputMatrix, ky).transpose
+	 	ky = nil #free memory
+	 	weigth = Numo::Linalg.dot(inputMatrix, weigth)
+
+	 	kx = inputMatrix.sum(1) #sum rows
+	 	
+	 	kx_lamb = kx ** lambdaValue
+	 	kx_lamb_mat = Numo::DFloat.zeros(rowsNumber, rowsNumber)
+	 	rowsNumber.times do |j|
+	 		rowsNumber.times do |i|	 			
+	 			kx_lamb_mat[j,i] = kx_lamb[i]
+	 		end
+	 	end
+	 	kx_lamb = nil #free memory
+
+	 	kx_inv_lamb = kx ** (1 - lambdaValue)
+	 	kx_inv_lamb_mat = Numo::DFloat.zeros(rowsNumber, rowsNumber)
+	 	rowsNumber.times do |j|
+	 		rowsNumber.times do |i|
+	 			kx_inv_lamb_mat[i, j] = kx_inv_lamb[i]
+	 		end
+	 	end
+	 	kx_inv_lamb = nil #free memory
+
+	 	nx = 1.0/(kx_lamb_mat.inplace * kx_inv_lamb_mat).inplace # inplace marks a matrix to be used by reference, not for value
+	 	kx_lamb_mat = nil #free memory
+	 	kx_inv_lamb_mat = nil #free memory
+	 	weigth.inplace * nx
+	 	return weigth
+	end
+
+end

data/lib/NetAnalyzer/net_parser.rb

@@ -0,0 +1,50 @@
+require 'expcalc'
+
+class Net_parser
+	def self.load(options)
+		net = nil
+		if options[:input_format] == 'pair'
+		  net = load_network_by_pairs(options[:input_file], options[:layers], options[:split_char])
+		elsif options[:input_format] == 'bin'
+		  net = load_network_by_bin_matrix(options[:input_file], options[:node_file], options[:layers])
+		elsif options[:input_format] == 'matrix'
+		  net = load_network_by_plain_matrix(options[:input_file], options[:node_file], options[:layers], options[:splitChar])
+		else
+		  raise("ERROR: The format #{options[:input_format]} is not defined")
+		end
+		return net
+	end
+
+	def self.load_network_by_pairs(file, layers, split_character="\t")
+		net = Network.new(layers.map{|layer| layer.first})
+		File.open(file).each do |line|
+			line.chomp!
+			pair = line.split(split_character)
+			node1 = pair[0]
+			node2 = pair[1]
+			net.add_node(node1, net.set_layer(layers, node1))
+			net.add_node(node2, net.set_layer(layers, node2))
+			net.add_edge(node1, node2)	
+		end
+		return net
+	end
+
+	def self.load_network_by_bin_matrix(input_file, node_file, layers)
+		net = Network.new(layers.map{|layer| layer.first})
+		node_names = load_input_list(node_file)
+		net.adjacency_matrices[layers.map{|l| l.first}] = [Numo::NArray.load(input_file, type='npy'), node_names, node_names]
+		return net
+	end
+
+	def self.load_network_by_plain_matrix(input_file, node_file, layers, splitChar="\t")
+		net = Network.new(layers.map{|layer| layer.first})
+		node_names = load_input_list(node_file)
+		net.adjacency_matrices[layers.map{|l| l.first}] = [Numo::NArray.load(input_file, type='txt', splitChar=splitChar), node_names, node_names]
+		return net
+	end
+
+	private
+	def self.load_input_list(file)
+		return File.open(file).readlines.map!{|line| line.chomp}
+	end
+end