rumale 0.14.5 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53beac1d67735cd6f03714c82bbd149379df845f
-  data.tar.gz: 303720c35bc1b14b720379abb6464812778398a2
+  metadata.gz: d8823e97350be198c39b1896dc88978a47b526f1
+  data.tar.gz: d65a2d3274d104eae9aa20dd97078159614783e1
 SHA512:
-  metadata.gz: 44e7893da77fcb9bcc245d096b69553b87bb740c160f879f7a1d8f00d30f1fc39f59831b17db6ff267772634cf356bceac5c5aa9f91792f0a6998938c60e2cb3
-  data.tar.gz: 21b3c761487805a31fc61d3570582892d02b97c3c14c01bf0813dd9893b79797a9092f1a9c8ecc47434fbff079a495897a8bf81109e026ac0c2a212615df7831
+  metadata.gz: 5f06921658636e7765edc7a71aa9df28bf6a5cd4b36706671b2bf3a75c55755d190e8ab4dc9801cf94a4034b04429a6f14d8978c0323a9a2a6bf5d34456aa2e5
+  data.tar.gz: 74dfe7a75358e9e26da392dae39e71c1441a56c63ad51236db3bedfda4156f8cd86a1b69c40574e34b2db46fb8bdb9f22da60bde0a9423afa6849b11551a9494

data/.travis.yml

@@ -6,6 +6,7 @@ rvm:
   - '2.4'
   - '2.5'
   - '2.6'
+  - '2.7'
 
 addons:
   apt:

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.15.0
+- Add feature extractor classes:
+  - [HashVectorizer](https://yoshoku.github.io/rumale/doc/Rumale/FeatureExtraction/HashVectorizer.html)
+  - [FeatureHasher](https://yoshoku.github.io/rumale/doc/Rumale/FeatureExtraction/FeatureHasher.html)
+
 # 0.14.5
 - Fix to suppress deprecation warning about keyword argument in Ruby 2.7.
 

data/lib/rumale.rb

@@ -77,6 +77,8 @@ require 'rumale/manifold/mds'
 require 'rumale/neural_network/base_mlp'
 require 'rumale/neural_network/mlp_regressor'
 require 'rumale/neural_network/mlp_classifier'
+require 'rumale/feature_extraction/hash_vectorizer'
+require 'rumale/feature_extraction/feature_hasher'
 require 'rumale/preprocessing/l2_normalizer'
 require 'rumale/preprocessing/min_max_scaler'
 require 'rumale/preprocessing/max_abs_scaler'

data/lib/rumale/feature_extraction/feature_hasher.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module FeatureExtraction
+    # Encode array of feature-value hash to vectors with feature hashing (hashing trick).
+    # This encoder turns array of mappings (Array<Hash>) with pairs of feature names and values into Numo::NArray.
+    # This encoder employs signed 32-bit Murmurhash3 as the hash function.
+    #
+    # @example
+    #   encoder = Rumale::FeatureExtraction::FeatureHasher.new(n_features: 10)
+    #   x = encoder.transform([
+    #     { dog: 1, cat: 2, elephant: 4 },
+    #     { dog: 2, run: 5 }
+    #   ])
+    #   # > pp x
+    #   # Numo::DFloat#shape=[2,10]
+    #   # [[0, 0, -4, -1, 0, 0, 0, 0, 0, 2],
+    #   #  [0, 0, 0, -2, -5, 0, 0, 0, 0, 0]]
+    class FeatureHasher
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Create a new encoder for converting array of hash consisting of feature names and values to vectors
+      # with feature hashing algorith.
+      #
+      # @param n_features [Integer] The number of features of encoded samples.
+      # @param alternate_sign [Boolean] The flag indicating whether to reflect the sign of the hash value to the feature value.
+      def initialize(n_features: 1024, alternate_sign: true)
+        check_params_numeric(n_features: n_features)
+        check_params_boolean(alternate_sign: alternate_sign)
+        @params = {}
+        @params[:n_features] = n_features
+        @params[:alternate_sign] = alternate_sign
+      end
+
+      # This method does not do anything. The encoder does not require training.
+      #
+      # @overload fit(x) -> FeatureHasher
+      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
+      #   @return [FeatureHasher]
+      def fit(_x = nil, _y = nil)
+        self
+      end
+
+      # Encode given the array of feature-value hash.
+      # This method has the same output as the transform method
+      # because the encoder does not require training.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
+      #   @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
+      def fit_transform(x, _y = nil)
+        fit(x).transform(x)
+      end
+
+      # Encode given the array of feature-value hash.
+      #
+      # @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
+      def transform(x)
+        x = [x] unless x.is_a?(Array)
+        n_samples = x.size
+
+        z = Numo::DFloat.zeros(n_samples, n_features)
+
+        x.each_with_index do |f, i|
+          f.each do |k, v|
+            k = "#{k}=#{v}" if v.is_a?(String)
+            val = v.is_a?(String) ? 1 : v
+            next if val.zero?
+
+            h = murmur_hash(k.to_s)
+            fid = h.abs % n_features
+            val *= h >= 0 ? 1 : -1 if alternate_sign?
+            z[i, fid] = val
+          end
+        end
+
+        z
+      end
+
+      private
+
+      def n_features
+        @params[:n_features]
+      end
+
+      def alternate_sign?
+        @params[:alternate_sign]
+      end
+
+      # MurmurHash3_32
+      # References:
+      # - https://en.wikipedia.org/wiki/MurmurHash
+      # - https://github.com/aappleby/smhasher
+      def murmur_hash(key_str, seed = 0)
+        keyb = key_str.bytes
+        key_len = keyb.size
+        n_blocks = key_len / 4
+
+        h = seed
+        (0...n_blocks * 4).step(4) do |bstart|
+          k = keyb[bstart + 3] << 24 | keyb[bstart + 2] << 16 | keyb[bstart + 1] << 8 | keyb[bstart + 0]
+          h ^= murmur_scramble(k)
+          h = murmur_rotl(h, 13)
+          h = (h * 5 + 0xe6546b64) & 0xFFFFFFFF
+        end
+
+        tail_id = n_blocks * 4
+        tail_sz = key_len & 3
+
+        k = 0
+        k ^= keyb[tail_id + 2] << 16 if tail_sz >= 3
+        k ^= keyb[tail_id + 1] << 8 if tail_sz >= 2
+        k ^= keyb[tail_id + 0] if tail_sz >= 1
+        h ^= murmur_scramble(k) if tail_sz.positive?
+
+        h = murmur_fmix(h ^ key_len)
+
+        if (h & 0x80000000).zero?
+          h
+        else
+          -((h ^ 0xFFFFFFFF) + 1)
+        end
+      end
+
+      def murmur_rotl(x, r)
+        (x << r | x >> (32 - r)) & 0xFFFFFFFF
+      end
+
+      def murmur_scramble(k)
+        k = (k * 0xcc9e2d51) & 0xFFFFFFFF
+        k = murmur_rotl(k, 15)
+        (k * 0x1b873593) & 0xFFFFFFFF
+      end
+
+      def murmur_fmix(h)
+        h ^= h >> 16
+        h = (h * 0x85ebca6b) & 0xFFFFFFFF
+        h ^= h >> 13
+        h = (h * 0xc2b2ae35) & 0xFFFFFFFF
+        h ^ (h >> 16)
+      end
+    end
+  end
+end

data/lib/rumale/feature_extraction/hash_vectorizer.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  # This module consists of the classes that extract features from raw data.
+  module FeatureExtraction
+    # Encode array of feature-value hash to vectors.
+    # This encoder turns array of mappings (Array<Hash>) with pairs of feature names and values into Numo::NArray.
+    #
+    # @example
+    #   encoder = Rumale::FeatureExtraction::HashVectorizer.new
+    #   x = encoder.fit_transform([
+    #     { foo: 1, bar: 2 },
+    #     { foo: 3, baz: 1 }
+    #   ])
+    #   # > pp x
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[2, 0, 1],
+    #   #  [0, 1, 3]]
+    #
+    #   x = encoder.fit_transform([
+    #     { city: 'Dubai',  temperature: 33 },
+    #     { city: 'London', temperature: 12 },
+    #     { city: 'San Francisco', temperature: 18 }
+    #   ])
+    #   # > pp x
+    #   # Numo::DFloat#shape=[3,4]
+    #   # [[1, 0, 0, 33],
+    #   #  [0, 1, 0, 12],
+    #   #  [0, 0, 1, 18]]
+    #   # > pp encoder.inverse_transform(x)
+    #   # [{:city=>"Dubai", :temperature=>33.0},
+    #   #  {:city=>"London", :temperature=>12.0},
+    #   #  {:city=>"San Francisco", :temperature=>18.0}]
+    class HashVectorizer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the list of feature names.
+      # @return [Array] (size: [n_features])
+      attr_reader :feature_names
+
+      # Return the hash consisting of pairs of feature names and indices.
+      # @return [Hash] (size: [n_features])
+      attr_reader :vocabulary
+
+      # Create a new encoder for converting array of hash consisting of feature names and values to vectors.
+      #
+      # @param separator [String] The separator string used for constructing new feature names for categorical feature.
+      # @param sort [Boolean] The flag indicating whether to sort feature names.
+      def initialize(separator: '=', sort: true)
+        check_params_string(separator: separator)
+        check_params_boolean(sort: sort)
+        @params = {}
+        @params[:separator] = separator
+        @params[:sort] = sort
+      end
+
+      # Fit the encoder with given training data.
+      #
+      # @overload fit(x) -> HashVectorizer
+      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
+      #   @return [HashVectorizer]
+      def fit(x, _y = nil)
+        @feature_names = []
+        @vocabulary = {}
+
+        x.each do |f|
+          f.each do |k, v|
+            k = "#{k}#{separator}#{v}".to_sym if v.is_a?(String)
+            next if @vocabulary.key?(k)
+            @feature_names.push(k)
+            @vocabulary[k] = @vocabulary.size
+          end
+        end
+
+        if sort_feature?
+          @feature_names.sort!
+          @feature_names.each_with_index { |k, i| @vocabulary[k] = i }
+        end
+
+        self
+      end
+
+      # Fit the encoder with given training data, then return encoded data.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
+      #   @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
+      def fit_transform(x, _y = nil)
+        fit(x).transform(x)
+      end
+
+      # Encode given the array of feature-value hash.
+      #
+      # @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
+      def transform(x)
+        x = [x] unless x.is_a?(Array)
+        n_samples = x.size
+        n_features = @vocabulary.size
+        z = Numo::DFloat.zeros(n_samples, n_features)
+
+        x.each_with_index do |f, i|
+          f.each do |k, v|
+            if v.is_a?(String)
+              k = "#{k}#{separator}#{v}".to_sym
+              v = 1
+            end
+            z[i, @vocabulary[k]] = v if @vocabulary.key?(k)
+          end
+        end
+
+        z
+      end
+
+      # Decode sample matirx to the array of feature-value hash.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
+      # @return [Array<Hash>] The array of hash consisting of feature names and values.
+      def inverse_transform(x)
+        n_samples = x.shape[0]
+        reconst = []
+
+        n_samples.times do |i|
+          f = {}
+          x[i, true].each_with_index do |el, j|
+            feature_key_val(@feature_names[j], el).tap { |k, v| f[k.to_sym] = v } unless el.zero?
+          end
+          reconst.push(f)
+        end
+
+        reconst
+      end
+
+      private
+
+      def feature_key_val(fname, fval)
+        f = fname.to_s.split(separator)
+        f.size == 2 ? f : [fname, fval]
+      end
+
+      def separator
+        @params[:separator]
+      end
+
+      def sort_feature?
+        @params[:sort]
+      end
+    end
+  end
+end

data/lib/rumale/version.rb

@@ -3,5 +3,5 @@
 # Rumale is a machine learning library in Ruby.
 module Rumale
   # The version of Rumale you are using.
-  VERSION = '0.14.5'
+  VERSION = '0.15.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.14.5
+  version: 0.15.0
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-28 00:00:00.000000000 Z
+date: 2020-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -207,6 +207,8 @@ files:
 - lib/rumale/evaluation_measure/recall.rb
 - lib/rumale/evaluation_measure/roc_auc.rb
 - lib/rumale/evaluation_measure/silhouette_score.rb
+- lib/rumale/feature_extraction/feature_hasher.rb
+- lib/rumale/feature_extraction/hash_vectorizer.rb
 - lib/rumale/kernel_approximation/rbf.rb
 - lib/rumale/kernel_machine/kernel_pca.rb
 - lib/rumale/kernel_machine/kernel_ridge.rb