NetAnalyzer 0.1.5 → 0.6.3

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

@@ -0,0 +1,308 @@
+#! /usr/bin/env ruby
+
+require 'benchmark'
+require 'optparse'
+#require 'nmatrix'
+require 'numo/narray'
+require 'numo/linalg'
+require 'npy'
+require 'expcalc'
+
+#require 'pp'
+#############################################################################
+## METHODS
+##############################################################################
+
+def load_matrix_file(input_file, splitChar = "\t")
+	matrix = nil
+	counter = 0
+	File.open(input_file).each do |line|
+	    	line.chomp!
+    		row = line.split(splitChar).map{|c| c.to_f }
+    		if matrix.nil?
+    			matrix = Numo::DFloat.zeros(row.length, row.length)
+    		end
+    		row.each_with_index do |val, i|
+    			matrix[counter, i] = val 
+    		end
+    		counter += 1
+	end
+	return matrix
+end
+
+def load_pair_file(source, byte_format = :float32)
+	connections = {}
+	source.each do |line|
+		node_a, node_b, weight = line.chomp.split("\t")
+		weight.nil? ? weight = 1.0 : weight = weight.to_f
+		add_pair(node_a, node_b, weight, connections)
+		add_pair(node_b, node_a, weight, connections)
+	end
+	matrix, names = connections.to_wmatrix
+	return matrix, names
+end
+
+def add_pair(node_a, node_b, weight, connections)
+	query = connections[node_a]
+	if !query.nil?
+		query[node_b] = weight
+	else
+		subhash = Hash.new(0.0)
+		subhash[node_b] = weight
+		connections[node_a] = subhash
+	end
+end
+
+def get_stats(matrix)
+	stats = []
+	#TODO: trnasform to Numo::Array operations
+	primary_stats = get_primary_stats(matrix)
+	#stats << ['Matrix - Symmetric?', matrix.symmetric?]
+	stats << ['Matrix - Dimensions', matrix.shape.join('x')]
+	stats << ['Matrix - Elements', primary_stats[:count]]
+	stats << ['Matrix - Elements Non Zero', primary_stats[:countNonZero]]
+	stats << ['Matrix - Non Zero Density', primary_stats[:countNonZero].fdiv(primary_stats[:count])]
+	stats << ['Weigth - Max', primary_stats[:max]]
+	stats << ['Weigth - Min', primary_stats[:min]]
+	stats << ['Weigth - Average', primary_stats[:average]]
+	stats << ['Weigth - Variance', primary_stats[:variance]]
+	stats << ['Weigth - Standard Deviation', primary_stats[:standardDeviation]]
+	stats << ['Weigth - Q1', primary_stats[:q1]]
+	stats << ['Weigth - Median', primary_stats[:median]]
+	stats << ['Weigth - Q3', primary_stats[:q3]]
+	stats << ['Weigth - Min Non Zero', primary_stats[:minNonZero]]
+	stats << ['Weigth - Average Non Zero', primary_stats[:averageNonZero]]
+	stats << ['Weigth - Variance Non Zero', primary_stats[:varianceNonZero]]
+	stats << ['Weigth - Standard Deviation Non Zero', primary_stats[:standardDeviationNonZero]]
+	stats << ['Weigth - Q1 Non Zero', primary_stats[:q1NonZero]]
+	stats << ['Weigth - Median Non Zero', primary_stats[:medianNonZero]]
+	stats << ['Weigth - Q3 Non Zero', primary_stats[:q3NonZero]]
+	connections = get_connection_number(matrix)
+	connection_stats = get_primary_stats(connections)
+	stats << ['Node - Elements', connection_stats[:count]]
+	stats << ['Node - Elements Non Zero', connection_stats[:countNonZero]]
+	stats << ['Node - Non Zero Density', connection_stats[:countNonZero].fdiv(connection_stats[:count])]
+	stats << ['Edges - Max', connection_stats[:max]]
+	stats << ['Edges - Min', connection_stats[:min]]
+	stats << ['Edges - Average', connection_stats[:average]]
+	stats << ['Edges - Variance', connection_stats[:variance]]
+	stats << ['Edges - Standard Deviation', connection_stats[:standardDeviation]]
+	stats << ['Edges - Q1', connection_stats[:q1]]
+	stats << ['Edges - Median', connection_stats[:median]]
+	stats << ['Edges - Q3', connection_stats[:q3]]
+	stats << ['Edges - Min Non Zero', primary_stats[:minNonZero]]
+	stats << ['Edges - Average Non Zero', connection_stats[:averageNonZero]]
+	stats << ['Edges - Variance Non Zero', connection_stats[:varianceNonZero]]
+	stats << ['Edges - Standard Deviation Non Zero', connection_stats[:standardDeviationNonZero]]
+	stats << ['Edges - Q1 Non Zero', connection_stats[:q1NonZero]]
+	stats << ['Edges - Median Non Zero', connection_stats[:medianNonZero]]
+	stats << ['Edges - Q3 Non Zero', connection_stats[:q3NonZero]]	
+	return stats
+end
+
+def get_connection_number(matrix)
+	rows, cols = matrix.shape
+	connections = Numo::DFloat.zeros(1, cols)
+	cols.times do |i|
+		column = matrix[true, i] 
+		count = 0
+		column.each do |value|
+			count += 1 if value != 0
+		end
+		connections[0, i] = count - 1 # the connection with self is removed
+	end
+	return connections
+end
+
+def transform_keys(hash)
+	new_hash = {}
+	hash.each do |key, val|
+		new_key = yield(key)
+		new_hash[new_key] = val
+	end
+	return new_hash
+end
+
+def get_primary_stats(matrix)
+	stats = Hash.new(0)
+	max = matrix[0, 0] # Initialize max value
+	min = matrix[0, 0] # Initialize min value
+	min_non_zero = matrix[0, 0] # Initialize min value
+	matrix.each do |value|
+		stats[:count] += 1
+		stats[:countNonZero] += 1 if value != 0
+		stats[:sum] += value
+		max = value if value > max
+		min = value if value < min
+		min_non_zero = value if value != 0 && value < min
+	end
+	stats[:max] = max
+	stats[:min] = min
+	stats[:minNonZero] = min_non_zero
+	values = matrix.to_a
+	values.flatten! if values.first.class == Array
+	values.sort!
+	quartile_stats = get_quartiles(values, stats[:count])
+	stats.merge!(transform_keys(quartile_stats){|k| k.to_sym})
+	values.select!{|v| v != 0}
+	quartile_stats_non_zero = get_quartiles(values, stats[:countNonZero])
+	stats.merge!(transform_keys(quartile_stats_non_zero){|k| (k + 'NonZero').to_sym})
+	get_composed_stats(stats, matrix)
+	return stats
+end
+
+def get_quartiles(values, n_items)
+	stats = {}
+	q1_coor = n_items * 0.25 - 1
+	median = n_items * 0.5 - 1
+	q3_coor = n_items * 0.75 - 1
+	if n_items % 2 == 0
+		stats['q1'] = (values[q1_coor.to_i] + values[q1_coor.to_i + 1]).fdiv(2)
+		stats['median'] = (values[median.to_i] + values[median.to_i + 1]).fdiv(2)
+		stats['q3'] = (values[q3_coor.to_i] + values[q3_coor.to_i + 1]).fdiv(2)		
+	else
+		stats['q1'] = values[q1_coor.ceil]
+		stats['median'] = values[median.ceil]
+		stats['q3'] = values[q3_coor.ceil]
+	end
+	return stats
+end
+
+def get_composed_stats(stats, matrix)
+	average = stats[:sum].fdiv(stats[:count])
+	average_non_zero = stats[:sum].fdiv(stats[:countNonZero])
+	stats[:average] = average
+	stats[:averageNonZero] = average_non_zero
+	matrix.each do |value|
+		stats[:sumDevs] = (value - average) ** 2
+		stats[:sumDevsNonZero] = (value - average_non_zero) ** 2 if value != 0
+	end
+	stats[:variance] = stats[:sumDevs].fdiv(stats[:count])
+	stats[:varianceNonZero] = stats[:sumDevsNonZero].fdiv(stats[:countNonZero])
+	stats[:standardDeviation] = stats[:variance] ** 0.5
+	stats[:standardDeviationNonZero] = stats[:varianceNonZero] ** 0.5
+end
+
+
+#############################################################################
+## OPTPARSE
+##############################################################################
+options = {}
+
+optparse = OptionParser.new do |opts|
+    options[:input_file] = nil
+    opts.on( '-i', '--input_file PATH', 'Input file' ) do |opt|
+        options[:input_file] = opt
+    end
+
+    options[:output_matrix_file] = nil
+    opts.on( '-o', '--output_matrix_file PATH', 'Output matrix file' ) do |opt|
+        options[:output_matrix_file] = opt
+    end
+
+    options[:byte_format] = :float64
+    opts.on( '-b', '--byte_format STRING', 'Format of the numeric values stored in matrix. Default: float64, warning set this to less precission can modify computation results using this matrix.' ) do |opt|
+        options[:byte_format] = opt.to_sym
+    end
+
+    options[:input_type] = 'pair'
+    opts.on( '-t', '--input_type STRING', 'Set input format file. "pair" or "matrix"' ) do |opt|
+        options[:input_type] = opt
+    end
+
+    options[:set_diagonal] = false
+    opts.on( '-d', '--set_diagonal', 'Set to 1.0 the main diagonal' ) do 
+        options[:set_diagonal] = true
+    end
+
+    options[:binarize] = nil
+    opts.on( '-B', '--binarize FLOAT', 'Binarize matrix changin x >= thr to one and any other to zero into matrix given' ) do |opt|
+        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
+    end
+
+    options[:output_type] = 'bin'
+    opts.on( '-O', '--output_type STRING', 'Set output format file. "bin" for binary (default) or "mat" for tabulated text file matrix' ) do |opt|
+        options[:output_type] = opt
+    end
+
+   opts.banner = "Usage: #{File.basename(__FILE__)} [options] \n\n"
+
+    opts.on( '-h', '--help', 'Display this screen' ) do
+            puts opts
+            exit
+    end
+end
+
+optparse.parse!
+
+################################################################################
+## MAIN
+###############################################################################
+if options[:input_file] == '-'
+	source = STDIN
+else
+	source = File.open(options[:input_file])
+end
+
+if options[:input_type] == 'bin'
+	matrix = Npy.load(options[:input_file])
+	#matrix = Marshal.load(File.binread(options[:input_file])) # the method needs a path not a IO object 
+elsif options[:input_type] == 'matrix'
+	matrix = load_matrix_file(source)
+elsif options[:input_type] == 'pair'
+	matrix, names = load_pair_file(source, options[:byte_format])
+	File.open(options[:output_matrix_file]+'.lst', 'w'){|f| f.print names.join("\n")}
+end
+
+if options[:set_diagonal]
+	elements = matrix.shape.last
+	elements.times do |n|
+		matrix[n, n] = 1.0
+	end
+end
+
+if !options[:binarize].nil? && options[:cutoff].nil?
+	elements = matrix.shape.last
+	elements.times do |i|
+		elements.times do |j|
+			matrix[i,j] = matrix[i,j] >= options[:binarize] ? 1 : 0
+		end
+	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|
+		puts stat.join("\t")
+	end
+end
+
+if options[:output_type] == 'bin'	
+	#File.binwrite(options[:output_matrix_file], Marshal.dump(matrix))
+	Npy.save(options[:output_matrix_file], matrix)
+elsif options[:output_type] == 'mat'
+	File.open(options[:output_matrix_file], 'w') do |f|
+		matrix.each_over_axis(0) do |r|
+			f.puts r.to_a.join("\t")
+		end
+	end
+end

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