find_communities 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f4baabfdcee6316ce51e6f68b4535e15ce0ecba2
+  data.tar.gz: 160f7bbd40b8bbde535ff26d11df977cf5c34f55
+SHA512:
+  metadata.gz: bd8a31638591661e62877c976c3c4be5835efa0781582897c7df3352f91e33c48c936e7b2fd0357a9d6d09cf5a1a35e41be9169d2eb93a978d1ed8c437317683
+  data.tar.gz: 507a858459bc54620e901390dd892069ea838f81159f073483565af48f2824b36244c8b27fda1adaa8985f3bfa31d8ba8782a0ff33997f00ef4dd46630690212

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+script: rspec
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec'
+gem 'rspec-retry'
+gem 'pry'
+gem 'pry-nav'

data/README.md

@@ -0,0 +1,82 @@
+# find_communities-ruby
+
+Ruby implementation of [Louvain community detection method](https://sites.google.com/site/findcommunities/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'find_communities-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install find_communities-ruby
+
+## Usage
+
+    $ community -l -1 karate.bin
+    0 2
+    1 0
+    2 0
+    3 0
+    4 0
+    5 1
+    6 3
+    7 3
+    8 0
+    9 5
+    10 0
+    11 1
+    12 0
+    13 0
+    14 0
+    15 2
+    16 2
+    17 3
+    18 0
+    19 2
+    20 0
+    21 2
+    22 0
+    23 2
+    24 2
+    25 4
+    26 4
+    27 2
+    28 2
+    29 4
+    30 2
+    31 5
+    32 4
+    33 2
+    0 0
+    1 1
+    2 3
+    3 1
+    4 2
+    5 3
+    0 0
+    1 1
+    2 2
+    3 3
+    0.426969
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## CI
+
+[![Build Status](https://secure.travis-ci.org/gkop/find_communities-ruby.png?branch=master)](http://travis-ci.org/gkop/find_communities-ruby)
+
+## License
+
+Released under the [GNU General Public License](https://www.gnu.org/licenses/gpl-3.0-standalone.html).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/community

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require File.dirname(__FILE__)+"/../lib/find_communities"
+
+class CommunityMain < Thor
+  method_option :level, :aliases => "-l", :desc => "displays the graph of level k rather than the hierachical structure.  if k=-1 then displays the hierarchical structure rather than the graph at a given level"
+  method_option :verbose, :aliases => "-v", :desc => "verbose mode: gives computation time, information about the hierarchy and modularity."
+
+  desc "community", "Decompose graph into communities"
+  argument :filename
+  def community
+    t0 = Time.now
+    verbose = options[:verbose]
+    puts "Begin: #{t0}" if verbose
+    precision = 0.000001
+    c = FindCommunities::Community.new(filename, -1, precision)
+    display_level = options[:level].to_i
+    level = 0
+    g = nil
+    improvement = true
+    mod = c.modularity
+
+    while improvement do
+      if verbose
+        puts "level #{level}:"
+        puts "  start computation #{Time.now}"
+        puts "  network size: #{c.g.nb_nodes} nodes, #{c.g.nb_links} links, #{c.g.total_weight} weight."
+      end
+      improvement = c.one_level
+      new_mod = c.modularity
+      level += 1
+      g.display if level == display_level && g
+      c.display_partition if display_level == -1
+      g = c.partition2graph_binary
+      c = FindCommunities::Community.new(g, -1, precision)
+
+      if verbose
+        puts "  modularity increased from #{"%.6f" % mod} to #{"%.6f" % new_mod}"
+        puts "  end computation #{Time.now}"
+      end
+      mod = new_mod
+      improvement = true if level == 1
+    end
+
+    if verbose
+      puts "End: #{Time.now}"
+      puts "Total duration: #{Time.now - t0} sec."
+    end
+    puts "%.6f" % new_mod
+  end
+
+  default_task :community
+end
+
+CommunityMain.start

data/find_communities.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'find_communities/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "find_communities"
+  gem.version       = FindCommunities::VERSION
+  gem.authors       = ["Gabe Kopley"]
+  gem.email         = ["gabe@coshx.com"]
+  gem.description   = %q{Ruby implementation of Louvain community detection method}
+  gem.summary       = %q{Ruby implementation of Louvain community detection method}
+  gem.homepage      = "https://github.com/gkop/find_communities-ruby"
+  gem.license       = "GPL"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency "bindata"
+  gem.add_dependency "thor"
+end

data/lib/find_communities.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/find_communities/*.rb'].each {|f| require f }

data/lib/find_communities/binary_graph.rb

@@ -0,0 +1,72 @@
+module FindCommunities
+  class BinaryGraph
+    attr_accessor :degrees, :nb_nodes, :nb_links, :total_weight
+    attr_reader :links, :weights
+
+    def initialize(filename=nil, type=nil)
+      if filename
+        @record = BinaryGraphRecord.read(open(filename, "rb"))
+        @nb_nodes = @record["nb_nodes"]
+        @degrees = @record["degrees"]
+        @links = @record["links"]
+        @nb_links = @links.count
+      else
+        @nb_nodes = 0
+        @nb_links = 0
+        @links = []
+      end
+      @weights = []
+      @total_weight = nb_nodes.times.inject(0.0) {|sum, node|
+        sum + weighted_degree(node)
+      }
+    end
+
+    def nb_neighbors(node)
+      check_node(node)
+      node == 0 ? degrees[0] : degrees[node] - degrees[node-1]
+    end
+
+    def nb_selfloops(node)
+      check_node(node)
+      p = neighbors(node)
+      nb_neighbors(node).times do |i|
+        if p.first[i] == node
+          return weights.any? ? p.last[i] : 1.0
+        end
+      end
+      0.0
+    end
+
+    def neighbors(node)
+      check_node(node)
+      if node == 0
+        [links, weights]
+      elsif weights.length > 0
+        [links[degrees[node-1], links.length],
+         weights[degrees[node-1], weights.length]]
+      else
+        [links[degrees[node-1], links.length], weights]
+      end
+    end
+
+    def weighted_degree(node)
+      check_node(node)
+      if weights.length == 0
+        nb_neighbors(node)
+      else
+        p = neighbors(node)
+        nb_neighbors(node).times.inject(0.0) { |sum, neighbor|
+          sum + p.last[neighbor]
+        }
+      end
+    end
+
+    private
+    def check_node(node)
+      if node < 0 || node >= nb_nodes
+        raise ArgumentError.new("Node index out of bounds: #{node}")
+      end
+    end
+
+  end
+end

data/lib/find_communities/binary_graph_record.rb

@@ -0,0 +1,18 @@
+require 'bindata'
+
+# binary file format is
+# 4 bytes for the number of nodes in the graph
+# 8*(nb_nodes) bytes for the cumulative degree for each node:
+#    deg(0)=degrees[0]
+#    deg(k)=degrees[k]-degrees[k-1]
+# 4*(sum_degrees) bytes for the links
+# IF WEIGHTED 4*(sum_degrees) bytes for the weights in a separate file
+
+module FindCommunities
+  class BinaryGraphRecord < BinData::Record
+    endian :little
+    uint32 :nb_nodes
+    array  :degrees, :type => :uint64, :initial_length => :nb_nodes
+    array  :links, :type => :uint32, :initial_length => lambda { degrees.last }
+  end
+end

data/lib/find_communities/community.rb

@@ -0,0 +1,240 @@
+require "securerandom"
+
+module FindCommunities
+  class Community
+    attr_accessor :neigh_weight, :neigh_pos, :neigh_last
+
+    attr_accessor :g    # network to compute communities for
+    attr_accessor :size # nummber of nodes in the network and size of all vectors
+    attr_accessor :n2c  # community to which each node belongs
+    attr_accessor :in_graph, :tot # used to compute the modularity participation
+                                  # of each community
+
+    # a new pass is computed if the last one has generated an increase
+    # greater than min_modularity
+    # if 0. even a minor increase is enough to go for one more pass
+    attr_accessor :min_modularity
+
+    def initialize(source, nbp=nil, minm=nil)
+      @g = source.is_a?(BinaryGraph) ? source : BinaryGraph.new(source)
+      @size = g.nb_nodes
+      @neigh_last = 0
+
+      @neigh_weight = size.times.map { -1 }
+      @neigh_pos = size.times.map { 0 }
+      @n2c = []
+      @in_graph = []
+      @tot = []
+      size.times do |i|
+        n2c[i] = i
+        tot[i] = g.weighted_degree(i)
+        in_graph[i] = g.nb_selfloops(i)
+      end
+      @min_modularity = minm
+    end
+
+    def one_level
+      improvement = false
+      nb_pass_done = 0
+      new_mod = modularity
+      cur_mod = new_mod
+      random_order = size.times.map { |i| i }
+      (size-1).times do |i|
+        rand_pos = SecureRandom.random_number(size-i) + i
+        tmp = random_order[i]
+        random_order[i] = random_order[rand_pos]
+        random_order[rand_pos] = tmp
+      end
+
+      begin
+        cur_mod = new_mod
+        nb_moves = 0
+        nb_pass_done += 1
+
+        size.times do |node_tmp|
+          node = random_order[node_tmp]
+          node_comm = n2c[node]
+          w_degree = g.weighted_degree(node)
+
+          # computation of all neighboring communities of current node
+          compute_neigh_comm(node)
+          # remove node from its current community
+          remove(node, node_comm, neigh_weight[node_comm])
+
+          # compute the nearest community for node
+          # default choice for future insertion is the former community
+          best_comm = node_comm
+          best_nblinks = 0.0
+          best_increase = 0.0
+
+          neigh_last.times do |i|
+            increase = modularity_gain(node, neigh_pos[i],
+                                       neigh_weight[neigh_pos[i]], w_degree)
+            if increase > best_increase
+              best_comm = neigh_pos[i]
+              best_nblinks = neigh_weight[neigh_pos[i]]
+              best_increase = increase
+            end
+          end
+
+          # insert node in the nearest community
+          insert(node, best_comm, best_nblinks)
+
+          nb_moves += 1 if best_comm != node_comm
+        end
+
+        new_mod = modularity
+        improvement = true if nb_moves > 0
+      end while nb_moves > 0 && (new_mod - cur_mod > min_modularity)
+
+      improvement
+    end
+
+    def display_partition
+      renumber = size.times.map { -1 }
+      size.times do |node|
+        renumber[n2c[node]] += 1
+      end
+
+      final = 0
+      size.times do |i|
+        if renumber[i] != -1
+          renumber[i] = final
+          final += 1
+        end
+      end
+
+      size.times do |i|
+        puts "#{i} #{renumber[n2c[i]]}"
+      end
+    end
+
+    def partition2graph_binary
+      renumber = size.times.map { -1 }
+      size.times do |node|
+        renumber[n2c[node]] += 1
+      end
+
+      final = 0
+      size.times do |i|
+        if renumber[i] != -1
+          renumber[i] = final
+          final += 1
+        end
+      end
+
+      # Compute communities
+      comm_nodes = final.times.map { [] }
+      size.times do |node|
+        comm_nodes[renumber[n2c[node]]].push(node)
+      end
+
+      # Compute weighted graph
+      g2 = BinaryGraph.new
+      g2.nb_nodes = comm_nodes.size
+      g2.degrees = comm_nodes.size.times.map { 0 }
+
+      comm_nodes.size.times do |comm|
+        m = {}
+
+        comm_size = comm_nodes[comm].size
+        comm_size.times do |node|
+          p = g.neighbors(comm_nodes[comm][node])
+          deg = g.nb_neighbors(comm_nodes[comm][node])
+          deg.times do |i|
+            neigh = p.first[i]
+            neigh_comm = renumber[n2c[neigh]]
+            local_neigh_weight = (g.weights.size == 0 ? 1.0 : p.last[i])
+
+            if m[neigh_comm]
+              m[neigh_comm][1] += local_neigh_weight
+            else
+              m[neigh_comm] = [neigh_comm, local_neigh_weight]
+            end
+          end
+        end
+        g2.degrees[comm] = m.to_a.size + (comm == 0 ? 0 : g2.degrees[comm - 1])
+        g2.nb_links += m.to_a.size
+
+        m.each do |key, value|
+          g2.total_weight += value[1]
+          g2.links.push(value[0])
+          g2.weights.push(value[1])
+        end
+      end
+      g2
+    end
+
+    def modularity
+      q = 0.0
+      m2 = g.total_weight
+      size.times do |i|
+        if tot[i] > 0
+          q += (in_graph[i] / m2 - (tot[i] / m2)**2)
+        end
+      end
+
+      q
+    end
+
+private
+    def check_node(node)
+      if node < 0 || node >= size
+        raise ArgumentError.new("Node index out of bounds: #{node}")
+      end
+    end
+
+    def insert(node, comm, dnodecomm)
+      check_node(node)
+
+      tot[comm] += g.weighted_degree(node)
+      in_graph[comm] += 2 * dnodecomm + g.nb_selfloops(node)
+      n2c[node] = comm
+    end
+
+    def modularity_gain(node, comm, dnodecomm, w_degree)
+      check_node(node)
+
+      totc = tot[comm]
+      degc = w_degree
+      m2 = g.total_weight
+
+      dnodecomm - ((totc.to_f * degc) / m2)
+    end
+
+    def compute_neigh_comm(node)
+      neigh_last.times { |i| neigh_weight[neigh_pos[i]] = -1 }
+
+      p = g.neighbors(node)
+
+      deg = g.nb_neighbors(node)
+
+      neigh_pos[0] = n2c[node]
+      neigh_weight[neigh_pos[0]] = 0
+      self.neigh_last = 1
+
+      deg.times do |i|
+        neigh = p.first[i]
+        neigh_comm = n2c[neigh]
+        neigh_w = (g.weights.size == 0 ? 1.0 : p.last[i])
+
+        if neigh != node
+          if neigh_weight[neigh_comm] == -1
+            neigh_weight[neigh_comm] = 0.0
+            neigh_pos[neigh_last] = neigh_comm
+            self.neigh_last += 1
+          end
+          neigh_weight[neigh_comm] += neigh_w
+        end
+      end
+    end
+
+    def remove(node, comm, dnodecomm)
+      check_node(node)
+
+      tot[comm] -= g.weighted_degree(node)
+      in_graph[comm] -= 2 * dnodecomm + g.nb_selfloops(node)
+      n2c[node] = -1
+    end
+  end
+end

data/lib/find_communities/graph.rb

@@ -0,0 +1,22 @@
+module FindCommunities
+  class Graph
+    def initialize(file, type=nil)
+      weight = 1.0
+      links = []
+
+      nb_links = file.count
+      file.each do |line|
+        pieces = line.split
+        src = pieces[0].to_i
+        dest = pieces[1].to_i
+        weight = pieces[2].to_f if type == :weighted
+        links[src] ||= []
+        links[src] << [dest, weight]
+        if src != dest
+          links[dest] ||= []
+          links[dest] ||= [src, weight]
+        end
+      end
+    end
+  end
+end

data/lib/find_communities/version.rb

@@ -0,0 +1,3 @@
+module FindCommunities
+  VERSION = "0.0.1"
+end

data/spec/bin/community_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "community (executable)" do
+  it "outputs a hierarchy", :retry => 3 do
+    filename = File.dirname(__FILE__) + "/../data/karate.bin"
+    run "community -l -1 #{filename}"
+    relevant_lines = out.split("\n").last(4)
+    relevant_lines[0].should == "1 1"
+    relevant_lines[1].should == "2 2"
+    relevant_lines[2].should == "3 3"
+    relevant_lines[3].to_f.round(1).should == 0.4
+  end
+end

data/spec/data/karate.tree

@@ -0,0 +1,44 @@
+0 5
+1 1
+2 1
+3 1
+4 1
+5 0
+6 2
+7 2
+8 1
+9 5
+10 5
+11 0
+12 1
+13 1
+14 1
+15 5
+16 5
+17 2
+18 1
+19 5
+20 1
+21 5
+22 1
+23 5
+24 4
+25 3
+26 3
+27 4
+28 4
+29 3
+30 4
+31 5
+32 3
+33 5
+0 1
+1 0
+2 1
+3 2
+4 3
+5 3
+0 0
+1 1
+2 2
+3 3

data/spec/helpers.rb

@@ -0,0 +1,9 @@
+module Spec
+  module Helpers
+    attr_reader :out
+
+    def run(command)
+      @out = `#{File.dirname(__FILE__)}/../bin/#{command}`
+    end
+  end
+end

data/spec/lib/binary_graph_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+include FindCommunities
+
+describe BinaryGraph do
+  it "can read a file" do
+    filename = File.dirname(__FILE__) + "/../data/karate.bin"
+    bg = BinaryGraph.new(filename)
+  end
+end

data/spec/lib/community_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+include FindCommunities
+
+describe Community do
+  it "can be initialized from a filename" do
+    filename = File.dirname(__FILE__) + "/../data/karate.bin"
+    c = Community.new(filename)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'find_communities'
+require 'pry'
+require 'pry-nav'
+require 'helpers'
+require 'rspec/retry'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+  config.include Spec::Helpers
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: find_communities
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gabe Kopley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby implementation of Louvain community detection method
+email:
+- gabe@coshx.com
+executables:
+- community
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bin/community
+- find_communities.gemspec
+- lib/find_communities.rb
+- lib/find_communities/binary_graph.rb
+- lib/find_communities/binary_graph_record.rb
+- lib/find_communities/community.rb
+- lib/find_communities/graph.rb
+- lib/find_communities/version.rb
+- spec/bin/community_spec.rb
+- spec/data/karate.bin
+- spec/data/karate.tree
+- spec/helpers.rb
+- spec/lib/binary_graph_spec.rb
+- spec/lib/community_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gkop/find_communities-ruby
+licenses:
+- GPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of Louvain community detection method
+test_files:
+- spec/bin/community_spec.rb
+- spec/data/karate.bin
+- spec/data/karate.tree
+- spec/helpers.rb
+- spec/lib/binary_graph_spec.rb
+- spec/lib/community_spec.rb
+- spec/spec_helper.rb