rumale 0.13.1 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce88d7170fd676377227427a0be90f8bdb1a9c97
-  data.tar.gz: 04f0d07e6d098768eda726fc82f864420678e427
+  metadata.gz: 948ea0c8e1c7d41704f0259ecd75dc2c4dd3e10f
+  data.tar.gz: 66adfaeb23d85aafc8cdea65bdda628ed1b481a8
 SHA512:
-  metadata.gz: 203444f0e7d833946f67c2ee922e02a48b7174c20eac84480e190f8749e150e0c5ed18e3d7b7d30480e565483b5a5b51d1990cced7e09b5db027d8c508fa4313
-  data.tar.gz: e608c97fc0d29c018c778f9cc96cd53b0edff927c5631bd3b0cb606ee93f4e8c647ed2c76e7835b49f1933c0e5aeccb1ffbda4fe9aec59a2689f7bde4a28e103
+  metadata.gz: c424d21b6c49e55606e26d946ea6df05fd5f860914ba016a8c32da82a63865e74be24ce1f82e14cb787352979960aedaae953093854756df81c6ef57079f7ed5
+  data.tar.gz: 04ba83211d4a296fda4f109f92439b76e494ee2ac9321a9d46cf1c5cd4d07a5736e86c9217d180438ea360b0f48564ef03d4dfad5caa8e2c9586e096d703adbc

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.13.2
+- Add preprocessing class for label binarization.
+- Fix to use LabelBinarizer instead of OneHotEncoder.
+- Fix bug that OneHotEncoder leaves elements related to values that do not occur in training data.
+
 # 0.13.1
 - Add class for Shared Neareset Neighbor clustering.
 - Add function for calculation of manhattan distance to Rumale::PairwiseMetric.

data/README.md

@@ -6,7 +6,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/yoshoku/rumale/badge.svg?branch=master)](https://coveralls.io/github/yoshoku/rumale?branch=master)
 [![Gem Version](https://badge.fury.io/rb/rumale.svg)](https://badge.fury.io/rb/rumale)
 [![BSD 2-Clause License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/master/LICENSE.txt)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rumale/0.13.1)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://yoshoku.github.io/rumale/doc/)
 
 Rumale (**Ru**by **ma**chine **le**arning) is a machine learning library in Ruby.
 Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.

data/lib/rumale.rb

@@ -71,6 +71,7 @@ require 'rumale/preprocessing/min_max_scaler'
 require 'rumale/preprocessing/max_abs_scaler'
 require 'rumale/preprocessing/standard_scaler'
 require 'rumale/preprocessing/bin_discretizer'
+require 'rumale/preprocessing/label_binarizer'
 require 'rumale/preprocessing/label_encoder'
 require 'rumale/preprocessing/one_hot_encoder'
 require 'rumale/preprocessing/ordinal_encoder'

data/lib/rumale/clustering/gaussian_mixture.rb

@@ -2,6 +2,7 @@
 
 require 'rumale/base/base_estimator'
 require 'rumale/base/cluster_analyzer'
+require 'rumale/preprocessing/label_binarizer'
 require 'rumale/pairwise_metric'
 
 module Rumale
@@ -136,8 +137,8 @@ module Rumale
           n_clusters: @params[:n_clusters], init: @params[:init], max_iter: 0, random_seed: @params[:random_seed]
         )
         cluster_ids = kmeans.fit_predict(x)
-        encoder = Rumale::Preprocessing::OneHotEncoder.new
-        encoder.fit_transform(cluster_ids)
+        encoder = Rumale::Preprocessing::LabelBinarizer.new
+        Numo::DFloat.cast(encoder.fit_transform(cluster_ids))
       end
 
       def calc_memberships(x, weights, means, diag_cov)

data/lib/rumale/evaluation_measure/log_loss.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'rumale/base/evaluator'
-require 'rumale/preprocessing/one_hot_encoder'
+require 'rumale/preprocessing/label_binarizer'
 
 module Rumale
   module EvaluationMeasure
@@ -33,8 +33,8 @@ module Rumale
                      bin_y_true = Numo::DFloat.cast(y_true.ne(negative_label))
                      -(bin_y_true * Numo::NMath.log(clipped_p) + (1 - bin_y_true) * Numo::NMath.log(1 - clipped_p))
                    else
-                     encoder = Rumale::Preprocessing::OneHotEncoder.new
-                     encoded_y_true = encoder.fit_transform(y_true)
+                     encoder = Rumale::Preprocessing::LabelBinarizer.new
+                     encoded_y_true = Numo::DFloat.cast(encoder.fit_transform(y_true))
                      clipped_p /= clipped_p.sum(1).expand_dims(1)
                      -(encoded_y_true * Numo::NMath.log(clipped_p)).sum(1)
                    end

data/lib/rumale/preprocessing/label_binarizer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Encode labels to binary labels with one-vs-all scheme.
+    #
+    # @example
+    #   encoder = Rumale::Preprocessing::LabelBinarizer.new
+    #   label = [0, -1, 3, 3, 1, 1]
+    #   p encoder.fit_transform(label)
+    #   # Numo::Int32#shape=[6,4]
+    #   # [[0, 1, 0, 0],
+    #   #  [1, 0, 0, 0],
+    #   #  [0, 0, 0, 1],
+    #   #  [0, 0, 0, 1],
+    #   #  [0, 0, 1, 0],
+    #   #  [0, 0, 1, 0]]
+    class LabelBinarizer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the class labels.
+      # @return [Array] (size: [n_classes])
+      attr_reader :classes
+
+      # Create a new encoder for binarizing labels with one-vs-all scheme.
+      #
+      # @param neg_label [Integer] The value represents negative label.
+      # @param pos_label [Integer] The value represents positive label.
+      def initialize(neg_label: 0, pos_label: 1)
+        check_params_integer(neg_label: neg_label, pos_label: pos_label)
+        @params = {}
+        @params[:neg_label] = neg_label
+        @params[:pos_label] = pos_label
+        @classes = nil
+      end
+
+      # Fit encoder to labels.
+      #
+      # @overload fit(y) -> LabelBinarizer
+      #   @param y [Numo::NArray/Array] (shape: [n_samples]) The labels to fit encoder.
+      # @return [LabelBinarizer]
+      def fit(y, _not_used = nil)
+        y = y.to_a if y.is_a?(Numo::NArray)
+        check_params_type(Array, y: y)
+        @classes = y.uniq.sort
+        self
+      end
+
+      # Fit encoder to labels, then return binarized labels.
+      #
+      # @overload fit_transform(y) -> Numo::DFloat
+      #   @param y [Numo::NArray/Array] (shape: [n_samples]) The labels to fit encoder.
+      # @return [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels.
+      def fit_transform(y, _not_used = nil)
+        y = y.to_a if y.is_a?(Numo::NArray)
+        check_params_type(Array, y: y)
+        fit(y).transform(y)
+      end
+
+      # Encode labels.
+      #
+      # @param y [Array] (shape: [n_samples]) The labels to be encoded.
+      # @return [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels.
+      def transform(y)
+        y = y.to_a if y.is_a?(Numo::NArray)
+        check_params_type(Array, y: y)
+        n_classes = @classes.size
+        n_samples = y.size
+        codes = Numo::Int32.zeros(n_samples, n_classes) + @params[:neg_label]
+        n_samples.times { |n| codes[n, @classes.index(y[n])] = @params[:pos_label] }
+        codes
+      end
+
+      # Decode binarized labels.
+      #
+      # @param x [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels to be decoded.
+      # @return [Array] (shape: [n_samples]) The decoded labels.
+      def inverse_transform(x)
+        check_params_type(Numo::Int32, x: x)
+        n_samples = x.shape[0]
+        Array.new(n_samples) { |n| @classes[x[n, true].ne(@params[:neg_label]).where[0]] }
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about LabelBinarizer.
+      def marshal_dump
+        { params: @params,
+          classes: @classes }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @classes = obj[:classes]
+        nil
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/one_hot_encoder.rb

@@ -27,6 +27,10 @@ module Rumale
       # @return [Numo::Int32] (shape: [n_features])
       attr_reader :n_values
 
+      # Return the indices for feature values that actually occur in the training set.
+      # @return [Nimo::Int32]
+      attr_reader :active_features
+
       # Return the indices to feature ranges.
       # @return [Numo::Int32] (shape: [n_features + 1])
       attr_reader :feature_indices
@@ -35,19 +39,21 @@ module Rumale
       def initialize
         @params = {}
         @n_values = nil
+        @active_features = nil
         @feature_indices = nil
       end
 
       # Fit one-hot-encoder to samples.
       #
       # @overload fit(x) -> OneHotEncoder
-      #
-      # @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to fit one-hot-encoder.
+      #   @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to fit one-hot-encoder.
       # @return [OneHotEncoder]
       def fit(x, _y = nil)
         check_params_type(Numo::Int32, x: x)
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         @n_values = x.max(0) + 1
         @feature_indices = Numo::Int32.hstack([[0], @n_values]).cumsum
+        @active_features = encode(x, @feature_indices).sum(0).ne(0).where
         self
       end
 
@@ -59,6 +65,7 @@ module Rumale
       # @return [Numo::DFloat] The one-hot-vectors.
       def fit_transform(x, _y = nil)
         check_params_type(Numo::Int32, x: x)
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         fit(x).transform(x)
       end
 
@@ -68,13 +75,9 @@ module Rumale
       # @return [Numo::DFloat] The one-hot-vectors.
       def transform(x)
         check_params_type(Numo::Int32, x: x)
-        n_samples, n_features = x.shape
-        n_features = 1 if n_features.nil?
-        column_indices = (x + @feature_indices[0...-1]).flatten.to_a
-        row_indices = Numo::Int32.new(n_samples).seq.repeat(n_features).to_a
-        codes = Numo::DFloat.zeros(n_samples, @feature_indices[-1])
-        row_indices.zip(column_indices).each { |r, c| codes[r, c] = 1.0 }
-        codes
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+        codes = encode(x, @feature_indices)
+        codes[true, @active_features].dup
       end
 
       # Dump marshal data.
@@ -82,6 +85,7 @@ module Rumale
       def marshal_dump
         { params: @params,
           n_values: @n_values,
+          active_features: @active_features,
           feature_indices: @feature_indices }
       end
 
@@ -90,9 +94,22 @@ module Rumale
       def marshal_load(obj)
         @params = obj[:params]
         @n_values = obj[:n_values]
+        @active_features = obj[:active_features]
         @feature_indices = obj[:feature_indices]
         nil
       end
+
+      private
+
+      def encode(x, indices)
+        n_samples, n_features = x.shape
+        n_features = 1 if n_features.nil?
+        col_indices = (x + indices[0...-1]).flatten.to_a
+        row_indices = Numo::Int32.new(n_samples).seq.repeat(n_features).to_a
+        codes = Numo::DFloat.zeros(n_samples, indices[-1])
+        row_indices.zip(col_indices).each { |r, c| codes[r, c] = 1.0 }
+        codes
+      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.13.1'
+  VERSION = '0.13.2'
 end

data/rumale.gemspec

@@ -33,6 +33,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.extensions    = ['ext/rumale/extconf.rb']
 
+  spec.metadata      = {
+    'homepage_uri' => 'https://github.com/yoshoku/rumale',
+    'changelog_uri' => 'https://github.com/yoshoku/rumale/blob/master/CHANGELOG.md',
+    'source_code_uri' => 'https://github.com/yoshoku/rumale',
+    'documentation_uri' => 'https://yoshoku.github.io/rumale/doc/',
+    'bug_tracker_uri' => 'https://github.com/yoshoku/rumale/issues'
+  }
+
   spec.required_ruby_version = '>= 2.3'
 
   spec.add_runtime_dependency 'numo-narray', '>= 0.9.1'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.2
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-01 00:00:00.000000000 Z
+date: 2019-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -229,6 +229,7 @@ files:
 - lib/rumale/polynomial_model/factorization_machine_regressor.rb
 - lib/rumale/preprocessing/bin_discretizer.rb
 - lib/rumale/preprocessing/l2_normalizer.rb
+- lib/rumale/preprocessing/label_binarizer.rb
 - lib/rumale/preprocessing/label_encoder.rb
 - lib/rumale/preprocessing/max_abs_scaler.rb
 - lib/rumale/preprocessing/min_max_scaler.rb
@@ -251,7 +252,12 @@ files:
 homepage: https://github.com/yoshoku/rumale
 licenses:
 - BSD-2-Clause
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/yoshoku/rumale
+  changelog_uri: https://github.com/yoshoku/rumale/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/yoshoku/rumale
+  documentation_uri: https://yoshoku.github.io/rumale/doc/
+  bug_tracker_uri: https://github.com/yoshoku/rumale/issues
 post_install_message: 
 rdoc_options: []
 require_paths: