NetAnalyzer 0.1.2 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 412854b58d2f6a2dbb1844cb943a90c9b96f7fd6
-  data.tar.gz: df275072cb0d1bb9b9d15099b089897471566eb8
+SHA256:
+  metadata.gz: 53e3a09e27675b6e10398c8c869e31314c8afccb440b5f7d3cf2f84bec554d24
+  data.tar.gz: 17b9a25ca6e45512f049097dad67f3f8a12ab4cf12b2f5706b2777ec301f436f
 SHA512:
-  metadata.gz: a6d3be799d9def07f7addef75dfad5a8d1c6b9d14c684d3dcb227b6be68ef22912ab069beb2e439d07a08b7dc2a6d7d0f38e873a1303a099c3c110c9cf6b075b
-  data.tar.gz: 561ad012584a397023897047b0e401a96246d39a67082f0c7cfd3ee6dc3cb8075d77d08bb75ae34a8174cbc13e5a8439f0348175f38133162f54ef9e6b55c07c
+  metadata.gz: 58d378216bdd2aaa7b374b43ce441500d0b08b2cf30e54a88cab9fec39c4ccad9dfe77554b7ef670d4a2874de9142c0046b5b2aa89be803c4a037d541816abf4
+  data.tar.gz: 5992bbed01102a8e59da389f872f24087e8d0f6f31aefe53518c49ba88e75730493fea725485686ab0c3b1c846c7d9afd2c4091163e97921670e5a6a8ddfac22

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--require spec_helper

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in NetAnalyzer.gemspec
 gemspec
+semtools_dev_path = File.expand_path('~/dev_gems/semtools')
+gem "semtools", github: "seoanezonjic/semtools", branch: "master" if Dir.exist?(semtools_dev_path)
+expcalc_dev_path = File.expand_path('~/dev_gems/expcalc')
+gem "expcalc", github: "seoanezonjic/expcalc", branch: "master" if Dir.exist?(expcalc_dev_path)

data/NetAnalyzer.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = "NetAnalyzer"
   spec.version       = NetAnalyzer::VERSION
   spec.authors       = ["Elena Rojano, Pedro Seoane"]
-  spec.email         = ["elenarojano@uma.es, seoanezonjic@uma.es"]
+  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}
@@ -19,9 +19,19 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_dependency "nmatrix"
-  spec.add_dependency "bigdecimal"
+  spec.add_development_dependency "rake", ">= 13.0.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "minitest"
+  spec.add_dependency "cmath", ">= 1.0.0"
+  spec.add_dependency "numo-linalg", ">= 0.1.5"
+  spec.add_dependency "numo-narray", ">= 0.9.1.9"
+  spec.add_dependency "pp", ">= 0.1.0"
+  spec.add_dependency "npy", ">= 0.2.0"
+  spec.add_dependency "bigdecimal", ">= 3.0.0"
+  spec.add_dependency "gv", ">= 0.1.0"
+  spec.add_dependency "semtools", ">= 0.1.1"
+  spec.add_dependency "expcalc"
+  spec.add_dependency "parallel" 
+  spec.add_dependency "rubystats"
+  spec.add_dependency "red-colors"
 end

data/README.md

@@ -1,28 +1,66 @@
 # NetAnalyzer
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/NetAnalyzer`. To experiment with that code, run `bin/console` for an interactive prompt.
+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.
 
-TODO: Delete this and the text above, and describe your gem
+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.
+
+[3] Alaimo et al. ncPred: ncRNA-Disease Association Prediction through Tripartite Network-Based Inference. Frontiers in Bioengineering and Biotechnology, 2:71, 2014.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Linux & MacOS:
+
+Please, check before your Ruby compiler (it has to be clang to install nmatrix) 
 
-```ruby
-gem 'NetAnalyzer'
+```
+ruby -rrbconfig -e 'puts RbConfig::MAKEFILE_CONFIG["CC"]'
 ```
 
-And then execute:
+If not, install RVM (https://rvm.io/), and then: 
 
-    $ bundle
+```
+rvm reinstall 2.4.1 --with-gcc=clang --with-cxx=clang++
+git clone https://github.com/SciRuby/nmatrix.git
+cd nmatrix
+gem install bundler
+bundle install
+bundle exec rake compile
+bundle exec rake spec
+```
 
-Or install it yourself as:
+Once nmatrix gem is installed:
 
-    $ gem install NetAnalyzer
+````ruby
+gem install 'NetAnalyzer'
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+The program NetAnalyzer.rb can analyse an unweighted network to calculate the association index between different nodes. 
+
+An example of use can be the following:
+
+    $ NetAnalyzer.rb NetAnalyzer.rb -i network.txt -l 'hpo,HP:;patients,[0-9]' -m hypergeometric -u 'hpo;patients' -a 'associations_file.txt'
+
+Where:
+
+```
+-i: Input file with the network to analyse. It must have two columns (separated by default by tabs) that represents the nodes that are related (NodeA\tNodeB). Please if you have doubts about the format, check the example providen.
+-l: Layers construction. Please consider that, depending on the n-partite network you provide, NetAnalyzer will transform it into a bipartite one to perform the analysis (excepting if the association method used is 'transference'). The layers must contain a identifier of the node, and a character or pattern to identify. In this example, the bipartite network has HPO terms (with 'HP:' string in each of them) and patients that have these HPO terms (they are given as numerical patient IDs). Both layers must be separated by ';'.
+-m: Association method. There are 8 different association methods to choose: 'jaccard', 'cosine', 'pcc', 'csi', 'hypergeometric', 'simpson', 'geometric' and 'transference'.
+-u: Set which layer will be the one that establish connections between nodes in the other layer. In this case, we will get with patient is associated to other patient because the HPO they share.
+-a: Associations output file name. Here you can find the associations between nodes in the network and the calculated association value, according to the chosen method.
+``` 
+
+Optional flags:
+
+```
+-s: Split character. Change if the layers of the network are not separated by tabs.
+-o: Output file name.
+
+```
 
 ## Development
 

data/Rakefile

@@ -1,6 +1,17 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "rake/testtask"
+require 'rdoc/task'
 
-RSpec::Core::RakeTask.new(:spec)
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
 
-task :default => :spec
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.doc"
+  rdoc.rdoc_files.include("README.md", "lib/*.rb", "lib/NetAnalyzer/*.rb")
+  rdoc.options << "--all"
+end
+
+task :default => :test

data/bin/NetAnalyzer.rb

@@ -1,28 +1,20 @@
 #! /usr/bin/env ruby
 
 ROOT_PATH = File.dirname(__FILE__)
-$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'NetAnalyzer'))
-
-require 'network'
+$LOAD_PATH.unshift(File.expand_path(File.join(ROOT_PATH, '..', 'lib')))
 require 'optparse'
+require 'benchmark'
+require 'NetAnalyzer'
 
-##############################
-# MAIN METHODS
-##############################
-
-def set_layer(layer_definitions, node_name)
-	layer = nil
-	if layer_definitions.length > 1
-		layer_definitions.each do |layer_name, regexp|
-			if node_name =~ regexp
-				layer = layer_name
-				break
-			end
-		end
-	else
-		layer = layer_definitions.first.first
-	end
-	return layer
+######################################
+## METHODS
+######################################
+def load_file(path)
+  data = []
+  File.open(path).each do |line|
+    data << line.chomp.split("\t")
+  end
+  return data
 end
 
 ##############################
@@ -38,11 +30,26 @@ OptionParser.new do |opts|
     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 STRING", "Character for splitting input file. Default: tab") do |split_char|
     options[:split_char] = split_char
   end
 
+  options[:use_pairs] = :conn
+  opts.on("-P", "--use_pairs STRING", "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' ") do |use_pairs|
+    options[:use_pairs] = use_pairs.to_sym
+  end
+
   options[:output_file] = "network2plot"
   opts.on("-o", "--output_file PATH", "Output file name") do |output_file|
     options[:output_file] = output_file
@@ -53,6 +60,11 @@ OptionParser.new do |opts|
     options[:assoc_file] = output_file
   end
 
+  options[:kernel_file] = "kernel_values"
+  opts.on("-K", "--kernel_file PATH", "Output file name for kernel values") do |output_file|
+    options[:kernel_file] = output_file
+  end
+
   options[:performance_file] = "perf_values.txt"
   opts.on("-p", "--performance_file PATH", "Output file name for performance values") do |output_file|
     options[:performance_file] = output_file
@@ -60,8 +72,8 @@ OptionParser.new do |opts|
 
   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}/]}
+  	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
 
@@ -80,35 +92,129 @@ OptionParser.new do |opts|
     options[:output_style] = output_style
   end
 
+  options[:ontologies] = []
+  opts.on("-O", "--ontology STRING", "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'") do |ontologies|
+    options[:ontologies] = ontologies.split(';').map{|pair| pair.split(':')}
+  end
+
   options[:meth] = nil
   opts.on("-m", "--association_method STRING", "Association method to use on network") do |meth|
     options[:meth] = meth.to_sym
   end
 
-  options[:no_autorelations] = FALSE
+  options[:kernel] = nil
+  opts.on("-k", "--kernel_method STRING", "Kernel operation to perform with the adjacency matrix") do |kernel|
+    options[:kernel] = kernel
+  end
+
+  options[:no_autorelations] = false
   opts.on("-N", "--no_autorelations", "Remove association values between nodes os same type") do
-    options[:no_autorelations] = TRUE
+    options[:no_autorelations] = true
+  end
+
+  options[:normalize_kernel] = false
+  opts.on("-z", "--normalize_kernel_values", "Apply cosine normalization to the obtained kernel") do
+    options[:normalize_kernel] = true
+  end
+
+  options[:graph_file] = nil
+  opts.on("-g", "--graph_file PATH", "Build a graphic representation of the network") do |item|
+    options[:graph_file] = item
+  end
+
+  options[:graph_options] = {method: 'el_grapho', layout: 'forcedir', steps: '30'}
+  opts.on("--graph_options STRING", "Set graph parameters as 'NAME1=value1,NAME2=value2,...") do |item|
+    options[:graph_options] = {}
+    item.split(',').each do |pair|
+      fields = pair.split('=')
+      options[:graph_options][fields.first.to_sym] = fields.last 
+    end
+  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
 
+  options[:reference_nodes] = []
+  opts.on("-r", "--reference_nodes STRING", "Node ids comma separared") do |item|
+    options[:reference_nodes] = item.split(',')
+  end
+
+  options[:group_nodes] = {}
+  opts.on("-G", "--group_nodes STRING", "File path or groups separated by ';' and group node ids comma separared") do |item|
+    if File.exists?(item)
+      File.open(item).each do |line|
+        groupID, nodeID = line.chomp.split("\t")
+        query = options[:group_nodes][groupID]
+        query.nil? ? options[:group_nodes][groupID] = [nodeID] : query << nodeID
+      end
+    else
+      item.split(';').each_with_index do |group, i| 
+        options[:group_nodes][i] = group.split(',')
+      end
+    end
+  end
+
+  options[:group_metrics] = false
+  opts.on("-M", "--group_metrics", "Perform group group_metrics") do 
+    options[:group_metrics] = true
+  end
+
+  options[:expand_clusters] = nil
+  opts.on("-x", "--expand_clusters STRING", "Method to expand clusters Available methods: sht_path") do |item|
+    options[:expand_clusters] = item
+  end
+
+  options[:get_attributes] = []
+  opts.on("-A", "--attributes STRING", "String separadted by commas with the name of network attribute") do |item|
+    options[:get_attributes] = item.split(',')
+  end
+
+  options[:delete_nodes] = []
+  opts.on("-d", "--delete PATH", "Remove nodes from file. If PATH;r then nodes not included in file are removed") do |item|
+    options[:delete_nodes] = item.split(';')
+  end
 end.parse!
 
 ##########################
 #MAIN
 ##########################
-
 fullNet = Network.new(options[:layers].map{|layer| layer.first})
+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"
-File.open(options[:input_file]).each("\n") do |line|
-	line.chomp!
-	pair = line.split(options[:splitChar])
-	node1 = pair[0]
-	node2 = pair[1]
-	fullNet.add_node(node1, set_layer(options[:layers], node1))
-	fullNet.add_node(node2, set_layer(options[:layers], node2))
-	fullNet.add_edge(node1, node2)	
+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
-#fullNet.plot(options[:output_file], options[:output_style])
 
+if !options[:delete_nodes].empty?
+  node_list = load_file(options[:delete_nodes].first).flatten
+  options[:delete_nodes].length > 1 ? mode = options[:delete_nodes][1] : 'd'
+  fullNet.delete_nodes(node_list, mode)
+end
+
+options[:ontologies].each do |layer_name, ontology_file_path|
+  fullNet.link_ontology(ontology_file_path, layer_name.to_sym)
+end
+
+if !options[:get_attributes].empty?
+  node_attributes = fullNet.get_node_attributes(options[:get_attributes])
+  File.open(File.join(File.dirname(options[:output_file]), 'node_attributes.txt'), 'w' ) do |f|
+    node_attributes.each do |attributes|
+      f.puts(attributes.join("\t"))
+    end
+  end
+end
 
 if !options[:meth].nil?
 	puts "Performing association method #{options[:meth]} on network"
@@ -121,35 +227,57 @@ if !options[:meth].nil?
 			:transference)
 	else
 		fullNet.get_association_values(
-			options[:use_layers][0], 
+			options[:use_layers][0],
 			options[:use_layers][1].first, 
 			options[:meth])
 	end
-	puts 'Clean autorelations'  if options[:no_autorelations]
-	fullNet.clean_autorelations_on_association_values if options[:no_autorelations]
 	File.open(options[:assoc_file], 'w') do |f|
 		fullNet.association_values[options[:meth]].each do |val|
 			f.puts val.join("\t")
 		end
 	end
+  if !options[:control_file].nil?
+  	puts "Doing validation on association values obtained from method #{options[:meth]}"
+  	control = []
+  	File.open(options[:control_file]).each("\n") do |line|
+  		line.chomp!
+  		control << line.split("\t")
+  	end
+  	fullNet.load_control(control)
+  	performance = fullNet.get_pred_rec(options[:meth])
+  	File.open(options[:performance_file], 'w') do |f|
+  		f.puts %w[cut prec rec meth].join("\t")
+  		performance.each do |item|
+  			item << options[:meth].to_s
+  			f.puts item.join("\t")
+  		end
+  	end
+  end
+  puts "End of analysis: #{options[:meth]}"
 end
 
-if !options[:meth].nil? && !options[:control_file].nil?
-	puts "Doing validation on association values obtained from method #{options[:meth]}"
-	control = []
-	File.open(options[:control_file]).each("\n") do |line|
-		line.chomp!
-		control << line.split("\t")
-	end
-	fullNet.load_control(control)
-	performance = fullNet.get_pred_rec(options[:meth])
-	File.open(options[:performance_file], 'w') do |f|
-		f.puts %w[cut prec rec meth].join("\t")
-		performance.each do |item|
-			item << options[:meth].to_s
-			f.puts item.join("\t")
-		end
-	end
+if !options[:kernel].nil?
+  layer2kernel = options[:use_layers].first # we use only a layer to perform the kernel, so only one item it is selected.
+  fullNet.get_kernel(layer2kernel, options[:kernel], options[:normalize_kernel])
+  fullNet.write_kernel(layer2kernel, options[:kernel_file])
+end
+
+if !options[:graph_file].nil?
+  options[:graph_options][:output_file] = options[:graph_file]
+  fullNet.plot_network(options[:graph_options]) 
 end
 
-puts "End of analysis: #{options[:meth]}"
+if options[:group_metrics]
+  fullNet.compute_group_metrics(File.join(File.dirname(options[:output_file]), 'group_metrics.txt'))
+end
+
+if !options[:expand_clusters].nil?
+  expanded_clusters = fullNet.expand_clusters(options[:expand_clusters])
+  File.open(File.join(File.dirname(options[:output_file]), 'expand_clusters.txt'), 'w' ) do |f|
+    expanded_clusters.each do |cl_id, nodes|
+      nodes.each do |node|
+        f.puts "#{cl_id}\t#{node}"
+      end
+    end
+  end
+end