inferx 0.2.3 → 0.2.4

data/lib/inferx.rb

@@ -2,20 +2,18 @@ require 'redis'
 
 require 'inferx/version'
 require 'inferx/categories'
-require 'inferx/complementary/categories'
 
 class Inferx
 
   # @param [Hash] options other options are passed to Redis#initialize in
   #   {https://github.com/redis/redis-rb redis}
   #
-  # @option options [Boolean] :complementary
+  # @option options [Boolean] :complementary use complementary Bayes classifier
   # @option options [String] :namespace namespace of keys to be used to Redis
   # @option options [Boolean] :manual whether manual save, defaults to false
   def initialize(options = {})
     @complementary = !!options[:complementary]
-    categories_class = @complementary ? Complementary::Categories : Categories
-    @categories = categories_class.new(Redis.new(options), options)
+    @categories = Categories.new(Redis.new(options), options)
   end
 
   attr_reader :categories

data/lib/inferx/categories.rb

@@ -1,25 +1,81 @@
-require 'inferx/adapter'
 require 'inferx/category'
+require 'inferx/category/complementary'
+require 'set'
 
 class Inferx
-  class Categories < Adapter
+  class Categories
     include Enumerable
 
+    # @param [Redis] redis an instance of Redis
+    # @param [Hash] options
+    # @option options [Boolean] :complementary use complementary Bayes
+    #   classifier
+    # @option options [String] :namespace namespace of keys to be used to Redis
+    # @option options [Boolean] :manual whether manual save, defaults to false
+    def initialize(redis, options = {})
+      @redis = redis
+      @category_class = options[:complementary] ? Category::Complementary : Category
+      parts = %w(inferx categories)
+      parts.insert(1, options[:namespace]) if options[:namespace]
+      @key = parts.join(':')
+      @manual = !!options[:manual]
+      @filter = nil
+      @except = Set.new
+    end
+
+    # Get key for access to categories on Redis.
+    #
+    # @attribute [r] key
+    # @return [String] the key
+    attr_reader :key
+
+    # Determine if manual save.
+    #
+    # @return [Boolean] whether manual save
+    def manual?
+      @manual
+    end
+
+    # Filter categories.
+    #
+    # @param [Array<String>] category_names category names
+    # @return [Inferx::Categories] categories filtered by the category names
+    def filter(*category_names)
+      category_names = category_names.map(&:to_s)
+
+      filtered do
+        @filter = @filter ? @filter & category_names : Set.new(category_names)
+      end
+    end
+
+    # Filter by excepting categories.
+    #
+    # @param [Array<String>] category_names category names
+    # @return [Inferx::Categories] categories filterd by the category names
+    def except(*category_names)
+      category_names = category_names.map(&:to_s)
+
+      filtered do
+        @except.merge(category_names)
+      end
+    end
+
     # Get all category names.
     #
     # @return [Array<String>] category names
     def all
-      hkeys || []
+      all_in_visible.to_a
     end
 
-    # Get a category according the name.
+    # Get category according the name.
     #
-    # @param [String] category_name a category name
-    # @return [Inferx::Category] a category
+    # @param [String] category_name the category name
+    # @return [Inferx::Category] the category
     def get(category_name)
-      size = hget(category_name)
+      size = @redis.hget(@key, category_name)
       raise ArgumentError, "#{category_name.inspect} is missing" unless size
-      spawn_category(category_name, size.to_i)
+      raise ArgumentError, "#{category_name.inspect} does not exist in filtered categories" unless all_in_visible.include?(category_name.to_s)
+      make_category(category_name, size.to_i)
     end
     alias [] get
 
@@ -28,7 +84,7 @@ class Inferx
     # @param [Array<String>] category_names category names
     def add(*category_names)
       @redis.pipelined do
-        category_names.each { |category_name| hsetnx(category_name, 0) }
+        category_names.each { |category_name| @redis.hsetnx(@key, category_name, 0) }
         @redis.save unless manual?
       end
     end
@@ -38,7 +94,7 @@ class Inferx
     # @param [Array<String>] category_names category names
     def remove(*category_names)
       @redis.pipelined do
-        category_names.each { |category_name| hdel(category_name) }
+        category_names.each { |category_name| @redis.hdel(@key, category_name) }
         @redis.del(*category_names.map(&method(:make_category_key)))
         @redis.save unless manual?
       end
@@ -46,26 +102,125 @@ class Inferx
 
     # Determine if the category is defined.
     #
-    # @param [String] category_name a category name
+    # @param [String] category_name the category name
     # @return whether the category is defined
     def exists?(category_name)
-      hexists(category_name)
+      all_in_visible.include?(category_name.to_s)
     end
 
     # Apply process for each category.
     #
-    # @yield a block to be called for every category
+    # @yield called for every category
     # @yieldparam [Inferx::Category] category a category
     def each
-      hgetall.each do |category_name, size|
-        yield spawn_category(category_name, size.to_i)
+      visible_category_names = all_in_visible
+
+      @redis.hgetall(@key).each do |category_name, size|
+        next unless visible_category_names.include?(category_name)
+        yield make_category(category_name, size.to_i)
       end
     end
 
-    protected
+    # Inject the words to the training data of the categories.
+    #
+    # @param [Array<String>] words an array of words
+    # @return [Hash<String, Integer>] increase for each category
+    def inject(words)
+      category_names = all
+      return {} if category_names.empty?
+      return associate(category_names, 0) if words.empty?
+
+      increase = words.size
+      words = collect(words)
+
+      associate(category_names, increase) do
+        @redis.pipelined do
+          category_names.each do |category_name|
+            category_key = make_category_key(category_name)
+            words.each { |word, count| @redis.zincrby(category_key, count, word) }
+            @redis.hincrby(@key, category_name, increase)
+          end
+
+          @redis.save unless manual?
+        end
+      end
+    end
+
+    # Eject the words from the training data of the categories.
+    #
+    # @param [Array<String>] words an array of words
+    # @return [Hash<String, Integer>] decrease for each category
+    def eject(words)
+      category_names = all
+      return {} if category_names.empty?
+      return associate(category_names, 0) if words.empty?
+
+      decrease = words.size
+      words = collect(words)
+
+      associate(category_names, decrease) do |fluctuation|
+        all_scores = @redis.pipelined do
+          category_names.each do |category_name|
+            category_key = make_category_key(category_name)
+            words.each { |word, count| @redis.zincrby(category_key, -count, word) }
+            @redis.zremrangebyscore(category_key, '-inf', 0)
+          end
+        end
+
+        length = words.size
+
+        category_names.each_with_index do |category_name, index|
+          scores = all_scores[index * (length + 1), length]
+          initial = fluctuation[category_name]
+
+          fluctuation[category_name] = scores.inject(initial) do |decrease, score|
+            score = score.to_i
+            score < 0 ? decrease + score : decrease
+          end
+        end
+
+        @redis.pipelined do
+          fluctuation.each do |category_name, decrease|
+            @redis.hincrby(@key, category_name, -decrease)
+          end
+
+          @redis.save unless manual?
+        end
+      end
+    end
+
+    private
+
+    def filtered(&block)
+      dup.tap { |filtered| filtered.instance_eval(&block) }
+    end
+
+    def all_in_visible
+      all = Set.new(@redis.hkeys(@key) || [])
+      all &= @filter if @filter
+      all - @except
+    end
+
+    def make_category_key(category_name)
+      "#{@key}:#{category_name}"
+    end
+
+    def make_category(*args)
+      @category_class.new(@redis, self, *args)
+    end
+
+    def collect(words)
+      words.inject({}) do |hash, word|
+        hash[word] ||= 0
+        hash[word] += 1
+        hash
+      end
+    end
 
-    def spawn_category(*args)
-      spawn(Category, *args)
+    def associate(keys, value, &block)
+      keys_and_values = Hash[keys.map { |key| [key, value] }]
+      yield *(block.arity.zero? ? [] : [keys_and_values]) if block_given?
+      keys_and_values
     end
   end
 end

data/lib/inferx/category.rb

@@ -1,7 +1,5 @@
-require 'inferx/adapter'
-
 class Inferx
-  class Category < Adapter
+  class Category
 
     def self.ready_for(method_name)
       define_method("ready_to_#{method_name}") do |&block|
@@ -12,51 +10,64 @@ class Inferx
     end
 
     # @param [Redis] redis an instance of Redis
+    # @param [Inferx::Categories] categories the categories
     # @param [String] name a category name
     # @param [Integer] size total of scores
-    # @param [Hash] options
-    # @option options [String] :namespace namespace of keys to be used to Redis
-    # @option options [Boolean] :manual whether manual save, defaults to false
-    def initialize(redis, name, size, options = {})
-      super(redis, options)
+    def initialize(redis, categories, name, size)
+      @redis = redis
+      @categories = categories
+      @key = "#{categories.key}:#{name}"
       @name = name.to_s
       @size = size
     end
 
-    # Get a category name.
+    # Get key for access to training data of the category on Redis.
+    #
+    # @attribute [r] key
+    # @return [String] the key
+    attr_reader :key
+
+    # Get name of the category.
     #
     # @attribute [r] name
-    # @return [String] a category name
+    # @return [String] the name
+    attr_reader :name
 
     # Get total of scores.
     #
     # @attribute [r] size
     # @return [Integer] total of scores
-    attr_reader :name, :size
+    attr_reader :size
 
     # Get words with scores in the category.
     #
     # @return [Hash<String, Integer>] words with scores
     def all
-      words_with_scores = zrevrange(0, -1, :withscores => true)
-      index = 1
-      size = words_with_scores.size
+      words_with_scores = @redis.zrevrange(@key, 0, -1, :withscores => true)
 
-      while index < size
-        words_with_scores[index] = words_with_scores[index].to_i
-        index += 2
-      end
+      if !words_with_scores.empty? and words_with_scores.first.is_a?(Array)
+        words_with_scores.each { |pair| pair[1] = pair[1].to_i }
+        Hash[words_with_scores]
+      else
+        index = 1
+        size = words_with_scores.size
 
-      Hash[*words_with_scores]
+        while index < size
+          words_with_scores[index] = words_with_scores[index].to_i
+          index += 2
+        end
+
+        Hash[*words_with_scores]
+      end
     end
 
-    # Get score of a word.
+    # Get score of the word.
     #
-    # @param [String] word a word
+    # @param [String] word the word
     # @return [Integer] when the word is member, score of the word
     # @return [nil] when the word is not member
     def get(word)
-      score = zscore(word)
+      score = @redis.zscore(@key, word)
       score ? score.to_i : nil
     end
     alias [] get
@@ -65,18 +76,8 @@ class Inferx
     #
     # @param [Array<String>] words an array of words
     def train(words)
-      return if words.empty?
-
-      increase = words.size
-      words = collect(words)
-
-      @redis.pipelined do
-        words.each { |word, count| zincrby(count, word) }
-        hincrby(name, increase)
-        @redis.save unless manual?
-      end
-
-      @size += increase
+      increases = @categories.filter(@name).inject(words)
+      @size += increases[@name]
     end
 
     # Prepare to enhance the training data. Use for high performance.
@@ -89,31 +90,8 @@ class Inferx
     #
     # @param [Array<String>] words an array of words
     def untrain(words)
-      return if words.empty?
-
-      decrease = words.size
-      words = collect(words)
-
-      scores = @redis.pipelined do
-        words.each { |word, count| zincrby(-count, word) }
-        zremrangebyscore('-inf', 0)
-      end
-
-      length = words.size
-
-      scores[0, length].each do |score|
-        score = score.to_i
-        decrease += score if score < 0
-      end
-
-      return unless decrease > 0
-
-      @redis.pipelined do
-        hincrby(name, -decrease)
-        @redis.save unless manual?
-      end
-
-      @size -= decrease
+      decreases = @categories.filter(@name).eject(words)
+      @size -= decreases[@name]
     end
 
     # Prepare to attenuate the training data giving words.
@@ -127,25 +105,11 @@ class Inferx
     # @param [Array<String>] words an array of words
     # @return [Array<Integer>] scores for each word
     def scores(words)
-      scores = @redis.pipelined { words.map(&method(:zscore)) }
-      scores.map { |score| score ? score.to_i : nil }
-    end
-
-    protected
-
-    %w(zrevrange zscore zincrby zremrangebyscore).each do |command|
-      define_method(command) do |*args|
-        @category_key ||= make_category_key(@name)
-        @redis.__send__(command, @category_key, *args)
+      scores = @redis.pipelined do
+        words.map { |word| @redis.zscore(@key, word) }
       end
-    end
 
-    def collect(words)
-      words.inject({}) do |hash, word|
-        hash[word] ||= 0
-        hash[word] += 1
-        hash
-      end
+      scores.map { |score| score ? score.to_i : nil }
     end
   end
 end

data/lib/inferx/category/complementary.rb

@@ -0,0 +1,48 @@
+require 'inferx/category'
+
+class Inferx
+  class Category
+    class Complementary < Category
+
+      # Inject the words to the training data of the category.
+      #
+      # @param [Array<String>] words an array of words
+      alias inject train
+
+      # Prepare to inject the words to the training data of the category. Use
+      # for high performance.
+      #
+      # @yield [train] process something
+      # @yieldparam [Proc] inject inject the words to the training data of the
+      #   category
+      ready_for :inject
+
+      # Eject the words from the training data of the category.
+      #
+      # @param [Array<String>] words an array of words
+      alias eject untrain
+
+      # Prepare to eject the words from the training data of the category. Use
+      # for high performance.
+      #
+      # @yield [train] process something
+      # @yieldparam [Proc] eject eject the words from the training data of the
+      #   category
+      ready_for :eject
+
+      # Enhance the training data of other categories giving words.
+      #
+      # @param [Array<String>] words an array of words
+      def train(words)
+        @categories.except(@name).inject(words)
+      end
+
+      # Attenuate the training data of other categories giving words.
+      #
+      # @param [Array<String>] words an array of words
+      def untrain(words)
+        @categories.except(@name).eject(words)
+      end
+    end
+  end
+end