rumale 0.18.4 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4ec0f04029a88ea7950bb74bf9e0bd970cf8b546253da4ef4545244ad0adf68
-  data.tar.gz: ed927fb58359fe49d4834593ec2034535f5ac8d37c773d6cb5a53227c4777f61
+  metadata.gz: f49170105721cfebcae9f1a424e9a858650d78225541a8cb63b0ad4c70734988
+  data.tar.gz: ecc35086328eee1066252e75b8cd638256039e93beebc0bce5714493fe72570b
 SHA512:
-  metadata.gz: 58727ddc9c5c6f9c12ac8231f57295988795bf07ec6f748543fff924a4d8085472a210789992ba2a3cc4827300823d141313da1fd20a10be3b5970b40871e4e3
-  data.tar.gz: cc1af7ff552a9fe516e0588081ad6645cb03d4c8dd774492ea35c3e1a28eece7383dc88604c41e1cc1417f5d05af1324a7b97c121cb7ee76bcc697e4173195be
+  metadata.gz: 68f432bb34ff6c8e467a91d7c7e3aa07e816c2dd8807defc9e4e82e7a720c925062dbd27c8a7ec3294ecef2d71041baead2510edaf03a1eee210dc811eede22d
+  data.tar.gz: 5854eacc12de6c3cdcdbab0f9b4e73fc64d1be0533732348da6b4d6dcb0be9f115e2415501b05148fd021fa844ac0c25adc1bb858432a02ca6fe19d30a3538c7

data/.rubocop.yml

@@ -3,11 +3,11 @@ require:
   - rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5
   DisplayCopNames: true
   DisplayStyleGuide: true
   Exclude:
-    - 'bin/*'
+    - 'ext/rumale/extconf.rb'
     - 'rumale.gemspec'
     - 'Rakefile'
     - 'Gemfile'
@@ -15,10 +15,26 @@ AllCops:
 Style/Documentation:
   Enabled: false
 
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true
+
+Lint/RaiseException:
+  Enabled: true
+
+Lint/StructNewOverride:
+  Enabled: true
+
 Layout/LineLength:
   Max: 145
   IgnoredPatterns: ['(\A|\s)#']
 
+
 Metrics/ModuleLength:
   Max: 200
 
@@ -54,14 +70,26 @@ Naming/MethodParameterName:
 Naming/ConstantName:
   Enabled: false
 
+Style/ExponentialNotation:
+  Enabled: true
+
 Style/FormatStringToken:
   Enabled: false
 
 Style/NumericLiterals:
   Enabled: false
 
+Style/SlicingWithRange:
+  Enabled: true
+
 Layout/EmptyLineAfterGuardClause:
-  Enabled: false
+  Enabled: true
+
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
 
 RSpec/MultipleExpectations:
   Enabled: false

data/.travis.yml

@@ -1,6 +1,6 @@
-os: linux
-dist: xenial
+---
 language: ruby
+cache: bundler
 rvm:
   - '2.4'
   - '2.5'
@@ -14,4 +14,4 @@ addons:
       - liblapacke-dev
 
 before_install:
-  - gem install bundler -v 2.0.2
+  - gem install bundler -v 2.1.4

data/CHANGELOG.md

@@ -1,3 +1,46 @@
+# 0.19.1
+- Add cluster analysis class for [mini-batch K-Means](https://yoshoku.github.io/rumale/doc/Rumale/Clustering/MiniBatchKMeans.html).
+- Fix some typos.
+
+# 0.19.0
+- Change mmh3 and mopti gem to non-runtime dependent library.
+  - The mmh3 gem is used in [FeatureHasher](https://yoshoku.github.io/rumale/doc/Rumale/FeatureExtraction/FeatureHasher.html).
+  You only need to require mmh3 gem when using FeatureHasher.
+    ```ruby
+    require 'mmh3'
+    require 'rumale'
+
+    encoder = Rumale::FeatureExtraction::FeatureHasher.new
+    ```
+  - The mopti gem is used in [NeighbourhoodComponentAnalysis](https://yoshoku.github.io/rumale/doc/Rumale/MetricLearning/NeighbourhoodComponentAnalysis.html).
+  You only need to require mopti gem when using NeighbourhoodComponentAnalysis.
+    ```ruby
+    require 'mopti'
+    require 'rumale'
+
+    transformer = Rumale::MetricLearning::NeighbourhoodComponentAnalysis.new
+    ```
+- Change the default value of solver parameter on [PCA](https://yoshoku.github.io/rumale/doc/Rumale/Decomposition/PCA.html) to 'auto'.
+If Numo::Linalg is loaded, 'evd' is selected for the solver, otherwise 'fpt' is selected.
+- Deprecate [PolynomialModel](https://yoshoku.github.io/rumale/doc/Rumale/PolynomialModel.html), [Optimizer](https://yoshoku.github.io/rumale/doc/Rumale/Optimizer.html), and the estimators contained in them. They will be deleted in version 0.20.0.
+  - Many machine learning libraries do not contain factorization machine algorithms, they are provided by another compatible library.
+  In addition, there are no plans to implement estimators in PolynomialModel.
+  Thus, the author decided to deprecate PolynomialModel.
+  - Currently, the Optimizer classes are only used by PolynomialModel estimators.
+  Therefore, they have been deprecated together with PolynomialModel.
+
+# 0.18.7
+- Fix to convert target_name to string array in [classification_report method](https://yoshoku.github.io/rumale/doc/Rumale/EvaluationMeasure.html#classification_report-class_method).
+- Refactor some codes with Rubocop.
+
+# 0.18.6
+- Fix some configuration files.
+- Update API documentation.
+
+# 0.18.5
+- Add functions for calculation of cosine similarity and distance to [Rumale::PairwiseMetric](https://yoshoku.github.io/rumale/doc/Rumale/PairwiseMetric.html).
+- Refactor some codes with Rubocop.
+
 # 0.18.4
 - Add transformer class for [KernelFDA](https://yoshoku.github.io/rumale/doc/Rumale/KernelMachine/KernelFDA.html).
 - Refactor [KernelPCA](https://yoshoku.github.io/rumale/doc/Rumale/KernelMachine/KernelPCA.html).

data/Gemfile

@@ -2,3 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rumale.gemspec
 gemspec
+
+gem 'coveralls', '~> 0.8'
+gem 'mmh3', '>= 1.0'
+gem 'mopti', '>= 0.1.0'
+gem 'numo-linalg', '>= 0.1.4'
+gem 'parallel', '>= 1.17.0'
+gem 'rake', '~> 12.0'
+gem 'rake-compiler', '~> 1.0'
+gem 'rspec', '~> 3.0'

data/README.md

@@ -11,7 +11,7 @@
 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.
 Rumale supports Support Vector Machine,
-Logistic Regression, Ridge, Lasso, Factorization Machine,
+Logistic Regression, Ridge, Lasso,
 Multi-layer Perceptron,
 Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
 K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
@@ -42,39 +42,7 @@ Or install it yourself as:
 
 ## Usage
 
-### Example 1. XOR data
-First, let's classify simple xor data.
-
-```ruby
-require 'rumale'
-
-# Prepare XOR data.
-samples = [[0, 0], [0, 1], [1, 0], [1, 1]]
-labels = [0, 1, 1, 0]
-
-# Train classifier with nearest neighbor rule.
-estimator = Rumale::NearestNeighbors::KNeighborsClassifier.new(n_neighbors: 1)
-estimator.fit(samples, labels)
-
-# Predict labels.
-p labels
-p estimator.predict(samples)
-```
-
-Execution of the above script result in the following.
-
-```ruby
-[0, 1, 1, 0]
-Numo::Int32#shape=[4]
-[0, 1, 1, 0]
-```
-
-The basic usage of Rumale is to first train the model with the fit method
-and then estimate with the predict method.
-In addition, Rumale recommends using arrays such as feature vectors and labels with
-[Numo::NArray](https://github.com/ruby-numo/numo-narray).
-
-### Example 2. Pendigits dataset classification
+### Example 1. Pendigits dataset classification
 
 Rumale provides function loading libsvm format dataset file.
 We start by downloading the pendigits dataset from LIBSVM Data web site.
@@ -137,7 +105,7 @@ $ ruby test.rb
 Accuracy: 98.7%
 ```
 
-### Example 3. Cross-validation
+### Example 2. Cross-validation
 
 ```ruby
 require 'rumale'
@@ -168,7 +136,7 @@ $ ruby cross_validation.rb
 5-CV mean log-loss: 0.355
 ```
 
-### Example 4. Pipeline
+### Example 3. Pipeline
 
 ```ruby
 require 'rumale'
@@ -200,9 +168,10 @@ $ ruby pipeline.rb
 5-CV mean accuracy: 99.6 %
 ```
 
-## Speeding up
+## Speed up
 
 ### Numo::Linalg
+Rumale uses [Numo::NArray](https://github.com/ruby-numo/numo-narray) for typed arrays.
 Loading the [Numo::Linalg](https://github.com/ruby-numo/numo-linalg) allows to perform matrix product of Numo::NArray using BLAS libraries.
 For example, using the [OpenBLAS](https://github.com/xianyi/OpenBLAS) speeds up many estimators in Rumale.
 
@@ -259,13 +228,6 @@ When -1 is given to n_jobs parameter, all processors are used.
 estimator = Rumale::Ensemble::RandomForestClassifier.new(n_jobs: -1, random_seed: 1)
 ```
 
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/rumale.

data/lib/rumale.rb

@@ -70,6 +70,7 @@ require 'rumale/ensemble/random_forest_regressor'
 require 'rumale/ensemble/extra_trees_classifier'
 require 'rumale/ensemble/extra_trees_regressor'
 require 'rumale/clustering/k_means'
+require 'rumale/clustering/mini_batch_k_means'
 require 'rumale/clustering/k_medoids'
 require 'rumale/clustering/gaussian_mixture'
 require 'rumale/clustering/dbscan'

data/lib/rumale/base/base_estimator.rb

@@ -25,6 +25,7 @@ module Rumale
 
       def enable_parallel?
         return false if @params[:n_jobs].nil?
+
         if defined?(Parallel).nil?
           warn('If you want to use parallel option, you should install and load Parallel in advance.')
           return false
@@ -34,6 +35,7 @@ module Rumale
 
       def n_processes
         return 1 unless enable_parallel?
+
         @params[:n_jobs] <= 0 ? Parallel.processor_count : @params[:n_jobs]
       end
 

data/lib/rumale/clustering/dbscan.rb

@@ -13,7 +13,7 @@ module Rumale
     #   cluster_labels = analyzer.fit_predict(samples)
     #
     # *Reference*
-    # - M. Ester, H-P. Kriegel, J. Sander, and X. Xu, "A density-based algorithm for discovering clusters in large spatial databases with noise," Proc. KDD' 96, pp. 266--231, 1996.
+    # - Ester, M., Kriegel, H-P., Sander, J., and Xu, X., "A density-based algorithm for discovering clusters in large spatial databases with noise," Proc. KDD' 96, pp. 266--231, 1996.
     class DBSCAN
       include Base::BaseEstimator
       include Base::ClusterAnalyzer
@@ -54,6 +54,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         partial_fit(x)
         self
       end
@@ -66,6 +67,7 @@ module Rumale
       def fit_predict(x)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         partial_fit(x)
         labels
       end
@@ -80,6 +82,7 @@ module Rumale
         @labels = Numo::Int32.zeros(n_samples) - 2
         n_samples.times do |query_id|
           next if @labels[query_id] >= -1
+
           cluster_id += 1 if expand_cluster(metric_mat, query_id, cluster_id)
         end
         @core_sample_ids = Numo::Int32[*@core_sample_ids.flatten]
@@ -102,6 +105,7 @@ module Rumale
           while (m = target_ids.shift)
             neighbor_ids = region_query(metric_mat[m, true])
             next if neighbor_ids.size < @params[:min_samples]
+
             neighbor_ids.each do |n|
               target_ids.push(n) if @labels[n] < -1
               @labels[n] = cluster_id if @labels[n] <= -1

data/lib/rumale/clustering/gaussian_mixture.rb

@@ -86,6 +86,7 @@ module Rumale
           new_memberships = calc_memberships(x, @weights, @means, @covariances, @params[:covariance_type])
           error = (memberships - new_memberships).abs.max
           break if error <= @params[:tol]
+
           memberships = new_memberships.dup
         end
         self
@@ -209,6 +210,7 @@ module Rumale
 
       def check_enable_linalg(method_name)
         return unless @params[:covariance_type] == 'full' && !enable_linalg?
+
         raise "GaussianMixture##{method_name} requires Numo::Linalg when covariance_type is 'full' but that is not loaded."
       end
     end

data/lib/rumale/clustering/hdbscan.rb

@@ -15,9 +15,9 @@ module Rumale
     #   cluster_labels = analyzer.fit_predict(samples)
     #
     # *Reference*
-    # - R J. G. B. Campello, D. Moulavi, A. Zimek, and J. Sander, "Hierarchical Density Estimates for Data Clustering, Visualization, and Outlier Detection," TKDD, Vol. 10 (1), pp. 5:1--5:51, 2015.
-    # - R J. G. B. Campello, D. Moulavi, and J Sander, "Density-Based Clustering Based on Hierarchical Density Estimates," Proc. PAKDD'13, pp. 160--172, 2013.
-    # - L. Lelis and J. Sander, "Semi-Supervised Density-Based Clustering," Proc. ICDM'09, pp. 842--847, 2009.
+    # - Campello, R J. G. B., Moulavi, D., Zimek, A., and Sander, J., "Hierarchical Density Estimates for Data Clustering, Visualization, and Outlier Detection," TKDD, Vol. 10 (1), pp. 5:1--5:51, 2015.
+    # - Campello, R J. G. B., Moulavi, D., and Sander, J., "Density-Based Clustering Based on Hierarchical Density Estimates," Proc. PAKDD'13, pp. 160--172, 2013.
+    # - Lelis, L., and Sander, J., "Semi-Supervised Density-Based Clustering," Proc. ICDM'09, pp. 842--847, 2009.
     class HDBSCAN
       include Base::BaseEstimator
       include Base::ClusterAnalyzer
@@ -55,6 +55,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         fit_predict(x)
         self
       end
@@ -67,6 +68,7 @@ module Rumale
       def fit_predict(x)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
         @labels = partial_fit(distance_mat)
       end
@@ -134,6 +136,7 @@ module Rumale
         res
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
       def condense_tree(hierarchy, min_cluster_size)
         n_edges = hierarchy.size
         root = 2 * n_edges
@@ -262,6 +265,7 @@ module Rumale
         end
         res
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rumale/clustering/k_means.rb

@@ -15,7 +15,7 @@ module Rumale
     #   cluster_labels = analyzer.fit_predict(samples)
     #
     # *Reference*
-    # - D. Arthur and S. Vassilvitskii, "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
+    # - Arthur, D., and Vassilvitskii, S., "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
     class KMeans
       include Base::BaseEstimator
       include Base::ClusterAnalyzer
@@ -106,6 +106,7 @@ module Rumale
         rand_id = [*0...n_samples].sample(@params[:n_clusters], random: sub_rng)
         @cluster_centers = x[rand_id, true].dup
         return unless @params[:init] == 'k-means++'
+
         # k-means++ initialize
         (1...@params[:n_clusters]).each do |n|
           distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers[0...n, true])

data/lib/rumale/clustering/k_medoids.rb

@@ -13,7 +13,7 @@ module Rumale
     #   cluster_labels = analyzer.fit_predict(samples)
     #
     # *Reference*
-    # - D. Arthur and S. Vassilvitskii, "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
+    # - Arthur, D., and Vassilvitskii, S., "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
     class KMedoids
       include Base::BaseEstimator
       include Base::ClusterAnalyzer
@@ -64,6 +64,7 @@ module Rumale
       def fit(x, _not_used = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         # initialize some varibales.
         distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
         init_cluster_centers(distance_mat)
@@ -76,6 +77,7 @@ module Rumale
           end
           new_error = distance_mat[true, @medoid_ids].mean
           break if (error - new_error).abs <= @params[:tol]
+
           error = new_error
         end
         @cluster_centers = x[@medoid_ids, true].dup if @params[:metric] == 'euclidean'
@@ -93,6 +95,7 @@ module Rumale
         if @params[:metric] == 'precomputed' && distance_mat.shape[1] != @medoid_ids.size
           raise ArgumentError, 'Expect the size input matrix to be n_samples-by-n_clusters.'
         end
+
         assign_cluster(distance_mat)
       end
 
@@ -123,6 +126,7 @@ module Rumale
         sub_rng = @rng.dup
         @medoid_ids = Numo::Int32.asarray([*0...n_samples].sample(@params[:n_clusters], random: sub_rng))
         return unless @params[:init] == 'k-means++'
+
         # k-means++ initialize
         (1...@params[:n_clusters]).each do |n|
           distances = distance_mat[true, @medoid_ids[0...n]]

data/lib/rumale/clustering/mini_batch_k_means.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/cluster_analyzer'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module Clustering
+    # MniBatchKMeans is a class that implements K-Means cluster analysis
+    # with mini-batch stochastic gradient descent (SGD).
+    #
+    # @example
+    #   analyzer = Rumale::Clustering::MiniBatchKMeans.new(n_clusters: 10, max_iter: 50, batch_size: 50, random_seed: 1)
+    #   cluster_labels = analyzer.fit_predict(samples)
+    #
+    # *Reference*
+    # - Sculley, D., "Web-scale k-means clustering," Proc. WWW'10, pp. 1177--1178, 2010.
+    class MiniBatchKMeans
+      include Base::BaseEstimator
+      include Base::ClusterAnalyzer
+
+      # Return the centroids.
+      # @return [Numo::DFloat] (shape: [n_clusters, n_features])
+      attr_reader :cluster_centers
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new cluster analyzer with K-Means method with mini-batch SGD.
+      #
+      # @param n_clusters [Integer] The number of clusters.
+      # @param init [String] The initialization method for centroids ('random' or 'k-means++').
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param batch_size [Integer] The size of the mini batches.
+      # @param tol [Float] The tolerance of termination criterion.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_clusters: 8, init: 'k-means++', max_iter: 100, batch_size: 100, tol: 1.0e-4, random_seed: nil)
+        check_params_numeric(n_clusters: n_clusters, max_iter: max_iter, batch_size: batch_size, tol: tol)
+        check_params_string(init: init)
+        check_params_numeric_or_nil(random_seed: random_seed)
+        check_params_positive(n_clusters: n_clusters, max_iter: max_iter)
+        @params = {}
+        @params[:n_clusters] = n_clusters
+        @params[:init] = init == 'random' ? 'random' : 'k-means++'
+        @params[:max_iter] = max_iter
+        @params[:batch_size] = batch_size
+        @params[:tol] = tol
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
+        @cluster_centers = nil
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      # Analysis clusters with given training data.
+      #
+      # @overload fit(x) -> MiniBatchKMeans
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
+      # @return [KMeans] The learned cluster analyzer itself.
+      def fit(x, _y = nil)
+        x = check_convert_sample_array(x)
+        # initialization.
+        n_samples = x.shape[0]
+        update_counter = Numo::Int32.zeros(@params[:n_clusters])
+        sub_rng = @rng.dup
+        init_cluster_centers(x, sub_rng)
+        # optimization with mini-batch sgd.
+        @params[:max_iter].times do |_t|
+          sample_ids = [*0...n_samples].shuffle(random: sub_rng)
+          old_centers = @cluster_centers.dup
+          until (subset_ids = sample_ids.shift(@params[:batch_size])).empty?
+            # sub sampling
+            sub_x = x[subset_ids, true]
+            # assign nearest centroids
+            cluster_labels = assign_cluster(sub_x)
+            # update centroids
+            @params[:n_clusters].times do |c|
+              assigned_bits = cluster_labels.eq(c)
+              next unless assigned_bits.count.positive?
+
+              update_counter[c] += 1
+              learning_rate = 1.fdiv(update_counter[c])
+              update = sub_x[assigned_bits.where, true].mean(axis: 0)
+              @cluster_centers[c, true] = (1 - learning_rate) * @cluster_centers[c, true] + learning_rate * update
+            end
+          end
+          error = Numo::NMath.sqrt(((old_centers - @cluster_centers)**2).sum(axis: 1)).mean
+          break if error <= @params[:tol]
+        end
+        self
+      end
+
+      # Predict cluster labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the cluster label.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
+      def predict(x)
+        x = check_convert_sample_array(x)
+        assign_cluster(x)
+      end
+
+      # Analysis clusters and assign samples to clusters.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
+      def fit_predict(x)
+        x = check_convert_sample_array(x)
+        fit(x)
+        predict(x)
+      end
+
+      private
+
+      def assign_cluster(x)
+        distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers)
+        distance_matrix.min_index(axis: 1) - Numo::Int32[*0.step(distance_matrix.size - 1, @cluster_centers.shape[0])]
+      end
+
+      def init_cluster_centers(x, sub_rng)
+        # random initialize
+        n_samples = x.shape[0]
+        rand_id = [*0...n_samples].sample(@params[:n_clusters], random: sub_rng)
+        @cluster_centers = x[rand_id, true].dup
+        return unless @params[:init] == 'k-means++'
+
+        # k-means++ initialize
+        (1...@params[:n_clusters]).each do |n|
+          distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers[0...n, true])
+          min_distances = distance_matrix.flatten[distance_matrix.min_index(axis: 1)]
+          probs = min_distances**2 / (min_distances**2).sum
+          cum_probs = probs.cumsum
+          selected_id = cum_probs.gt(sub_rng.rand).where.to_a.first
+          @cluster_centers[n, true] = x[selected_id, true].dup
+        end
+      end
+    end
+  end
+end