jasder
/
rumale
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

🚀 Rename to Rumale

This commit is contained in:
yoshoku 2019-03-02 01:06:25 +09:00
parent e81c102d02
commit 86716139e7
146 changed files with 592 additions and 609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.rspec
View File

@ -1,2 +1,3 @@
--format documentation
--color
--require spec_helper

2
.rubocop.yml
View File

@ -1,7 +1,7 @@
inherit_from: .rubocop_todo.yml
AllCops:
TargetRubyVersion: 2.2
TargetRubyVersion: 2.3
DisplayCopNames: true
DisplayStyleGuide: true

6
.rubocop_todo.yml
View File

@ -10,7 +10,7 @@
# Cop supports --auto-correct.
Layout/ClosingHeredocIndentation:
Exclude:
- 'svmkit.gemspec'
- 'rumale.gemspec'
# Offense count: 2
# Cop supports --auto-correct.
@ -18,13 +18,13 @@ Layout/ClosingHeredocIndentation:
# SupportedStyles: auto_detection, squiggly, active_support, powerpack, unindent
Layout/IndentHeredoc:
Exclude:
- 'svmkit.gemspec'
- 'rumale.gemspec'
# Offense count: 1
# Cop supports --auto-correct.
Layout/LeadingBlankLines:
Exclude:
- 'svmkit.gemspec'
- 'rumale.gemspec'
# Offense count: 1
# Configuration parameters: CountComments, ExcludedMethods.

2
.travis.yml
View File

@ -3,8 +3,6 @@ os: linux
dist: trusty
language: ruby
rvm:
- 2.1
- 2.2
- 2.3
- 2.4
- 2.5

5
CHANGELOG.md
View File

@ -1,9 +1,6 @@
# 0.8.0
## Information
- Rename the project to [Rumale](https://github.com/yoshoku/Rumale).
- SVMKit has been deprecated and has been renamed to Rumale. SVMKit will release only bugfix.
## Breaking changes
- Rename SVMKit to Rumale.
- Rename SGDLienareEstimator class to BaseLienarModel class.
- Add data type option to load_libsvm_file method. By default, the method represents the feature with Numo::DFloat.

4
Gemfile
View File

@ -1,6 +1,4 @@
source 'https://rubygems.org'
git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
# Specify your gem's dependencies in svmkit.gemspec
# Specify your gem's dependencies in rumale.gemspec
gemspec

78
README.md
View File

@ -1,29 +1,27 @@
# SVMKit
# Rumale
[![Build Status](https://travis-ci.org/yoshoku/svmkit.svg?branch=master)](https://travis-ci.org/yoshoku/svmkit)
[![Coverage Status](https://coveralls.io/repos/github/yoshoku/svmkit/badge.svg?branch=master)](https://coveralls.io/github/yoshoku/svmkit?branch=master)
[![Gem Version](https://badge.fury.io/rb/svmkit.svg)](https://badge.fury.io/rb/svmkit)
[![BSD 2-Clause License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://github.com/yoshoku/svmkit/blob/master/LICENSE.txt)
[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/svmkit/)
[![Build Status](https://travis-ci.org/yoshoku/rumale.svg?branch=master)](https://travis-ci.org/yoshoku/rumale)
[![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/)
SVMKit has been deprecated and has been renamed to [Rumale](https://github.com/yoshoku/rumale).
Initially, I started developing SVMKit as an experimental library aiming at implementing SVM in Ruby.
However, since I added many other machine learning algorithms to SVMKit, I decided to change the library name.
SVMKit will continue releasing for bugfix but will not add new features.
SVMKit is a machine learninig library in Ruby.
SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
SVMKit supports Linear / Kernel Support Vector Machine,
Rumale (**Ru**by **ma**chine **le**arning) is a machine learninig library in Ruby.
Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
Rumale supports Linear / Kernel Support Vector Machine,
Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
Naive Bayes, Decision Tree, AdaBoost, Random Forest, K-nearest neighbor classifier,
K-Means, DBSCAN, Principal Component Analysis, and Non-negative Matrix Factorization.
This project was formerly known as SVMKit.
If you use SVMKit, please replace `SVMKit` constants with `Rumale`.
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'svmkit'
gem 'rumale'
```
And then execute:
@ -32,13 +30,13 @@ And then execute:
Or install it yourself as:
$ gem install svmkit
$ gem install rumale
## Usage
### Example 1. Pendigits dataset classification
SVMKit provides function loading libsvm format dataset file.
Rumale provides function loading libsvm format dataset file.
We start by downloading the pendigits dataset from LIBSVM Data web site.
```bash
@ -49,17 +47,17 @@ $ wget https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/multiclass/pendig
Training of the classifier with Linear SVM and RBF kernel feature map is the following code.
```ruby
require 'svmkit'
require 'rumale'
# Load the training dataset.
samples, labels = SVMKit::Dataset.load_libsvm_file('pendigits')
samples, labels = Rumale::Dataset.load_libsvm_file('pendigits')
# Map training data to RBF kernel feature space.
transformer = SVMKit::KernelApproximation::RBF.new(gamma: 0.0001, n_components: 1024, random_seed: 1)
transformer = Rumale::KernelApproximation::RBF.new(gamma: 0.0001, n_components: 1024, random_seed: 1)
transformed = transformer.fit_transform(samples)
# Train linear SVM classifier.
classifier = SVMKit::LinearModel::SVC.new(reg_param: 0.0001, max_iter: 1000, batch_size: 50, random_seed: 1)
classifier = Rumale::LinearModel::SVC.new(reg_param: 0.0001, max_iter: 1000, batch_size: 50, random_seed: 1)
classifier.fit(transformed, labels)
# Save the model.
@ -70,10 +68,10 @@ File.open('classifier.dat', 'wb') { |f| f.write(Marshal.dump(classifier)) }
Classifying testing data with the trained classifier is the following code.
```ruby
require 'svmkit'
require 'rumale'
# Load the testing dataset.
samples, labels = SVMKit::Dataset.load_libsvm_file('pendigits.t')
samples, labels = Rumale::Dataset.load_libsvm_file('pendigits.t')
# Load the model.
transformer = Marshal.load(File.binread('transformer.dat'))
@ -87,7 +85,7 @@ puts("Accuracy: %.1f%%" % (100.0 * classifier.score(transformed, labels)))
# Other evaluating approach
# results = classifier.predict(transformed)
# evaluator = SVMKit::EvaluationMeasure::Accuracy.new
# evaluator = Rumale::EvaluationMeasure::Accuracy.new
# puts("Accuracy: %.1f%%" % (100.0 * evaluator.score(results, labels)))
```
@ -102,18 +100,18 @@ Accuracy: 98.4%
### Example 2. Cross-validation
```ruby
require 'svmkit'
require 'rumale'
# Load dataset.
samples, labels = SVMKit::Dataset.load_libsvm_file('pendigits')
samples, labels = Rumale::Dataset.load_libsvm_file('pendigits')
# Define the estimator to be evaluated.
lr = SVMKit::LinearModel::LogisticRegression.new(reg_param: 0.0001, random_seed: 1)
lr = Rumale::LinearModel::LogisticRegression.new(reg_param: 0.0001, random_seed: 1)
# Define the evaluation measure, splitting strategy, and cross validation.
ev = SVMKit::EvaluationMeasure::LogLoss.new
kf = SVMKit::ModelSelection::StratifiedKFold.new(n_splits: 5, shuffle: true, random_seed: 1)
cv = SVMKit::ModelSelection::CrossValidation.new(estimator: lr, splitter: kf, evaluator: ev)
ev = Rumale::EvaluationMeasure::LogLoss.new
kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5, shuffle: true, random_seed: 1)
cv = Rumale::ModelSelection::CrossValidation.new(estimator: lr, splitter: kf, evaluator: ev)
# Perform 5-cross validation.
report = cv.perform(samples, labels)
@ -126,19 +124,19 @@ puts("5-CV mean log-loss: %.3f" % mean_logloss)
### Example 3. Pipeline
```ruby
require 'svmkit'
require 'rumale'
# Load dataset.
samples, labels = SVMKit::Dataset.load_libsvm_file('pendigits')
samples, labels = Rumale::Dataset.load_libsvm_file('pendigits')
# Construct pipeline with kernel approximation and SVC.
rbf = SVMKit::KernelApproximation::RBF.new(gamma: 0.0001, n_components: 800, random_seed: 1)
svc = SVMKit::LinearModel::SVC.new(reg_param: 0.0001, max_iter: 1000, random_seed: 1)
pipeline = SVMKit::Pipeline::Pipeline.new(steps: { trns: rbf, clsf: svc })
rbf = Rumale::KernelApproximation::RBF.new(gamma: 0.0001, n_components: 800, random_seed: 1)
svc = Rumale::LinearModel::SVC.new(reg_param: 0.0001, max_iter: 1000, random_seed: 1)
pipeline = Rumale::Pipeline::Pipeline.new(steps: { trns: rbf, clsf: svc })
# Define the splitting strategy and cross validation.
kf = SVMKit::ModelSelection::StratifiedKFold.new(n_splits: 5, shuffle: true, random_seed: 1)
cv = SVMKit::ModelSelection::CrossValidation.new(estimator: pipeline, splitter: kf)
kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5, shuffle: true, random_seed: 1)
cv = Rumale::ModelSelection::CrossValidation.new(estimator: pipeline, splitter: kf)
# Perform 5-cross validation.
report = cv.perform(samples, labels)
@ -163,7 +161,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/svmkit.
Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/Rumale.
This project is intended to be a safe, welcoming space for collaboration,
and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
@ -173,5 +171,5 @@ The gem is available as open source under the terms of the [BSD 2-clause License
## Code of Conduct
Everyone interacting in the SVMKit project’s codebases, issue trackers,
chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yoshoku/svmkit/blob/master/CODE_OF_CONDUCT.md).
Everyone interacting in the Rumale project’s codebases, issue trackers,
chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yoshoku/Rumale/blob/master/CODE_OF_CONDUCT.md).

2
Rakefile
View File

@ -3,4 +3,4 @@ require 'rspec/core/rake_task'
RSpec::Core::RakeTask.new(:spec)
task default: :spec
task :default => :spec

8
bin/console
View File

@ -1,14 +1,14 @@
#!/usr/bin/env ruby
require "bundler/setup"
require "svmkit"
require 'bundler/setup'
require 'rumale'
# You can add fixtures and/or initialization code here to make experimenting
# with your gem easier. You can also use a different console, if you like.
# (If you use this, don't forget to add pry to your Gemfile!)
# require "pry"
# require 'pry'
# Pry.start
require "irb"
require 'irb'
IRB.start(__FILE__)

70
lib/rumale.rb Normal file
View File

@ -0,0 +1,70 @@
# frozen_string_literal: true
require 'numo/narray'
require 'rumale/version'
require 'rumale/validation'
require 'rumale/values'
require 'rumale/utils'
require 'rumale/pairwise_metric'
require 'rumale/dataset'
require 'rumale/probabilistic_output'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
require 'rumale/base/regressor'
require 'rumale/base/cluster_analyzer'
require 'rumale/base/transformer'
require 'rumale/base/splitter'
require 'rumale/base/evaluator'
require 'rumale/optimizer/sgd'
require 'rumale/optimizer/rmsprop'
require 'rumale/optimizer/nadam'
require 'rumale/optimizer/yellow_fin'
require 'rumale/pipeline/pipeline'
require 'rumale/kernel_approximation/rbf'
require 'rumale/linear_model/base_linear_model'
require 'rumale/linear_model/svc'
require 'rumale/linear_model/svr'
require 'rumale/linear_model/logistic_regression'
require 'rumale/linear_model/linear_regression'
require 'rumale/linear_model/ridge'
require 'rumale/linear_model/lasso'
require 'rumale/kernel_machine/kernel_svc'
require 'rumale/polynomial_model/base_factorization_machine'
require 'rumale/polynomial_model/factorization_machine_classifier'
require 'rumale/polynomial_model/factorization_machine_regressor'
require 'rumale/multiclass/one_vs_rest_classifier'
require 'rumale/nearest_neighbors/k_neighbors_classifier'
require 'rumale/nearest_neighbors/k_neighbors_regressor'
require 'rumale/naive_bayes/naive_bayes'
require 'rumale/tree/node'
require 'rumale/tree/base_decision_tree'
require 'rumale/tree/decision_tree_classifier'
require 'rumale/tree/decision_tree_regressor'
require 'rumale/ensemble/ada_boost_classifier'
require 'rumale/ensemble/ada_boost_regressor'
require 'rumale/ensemble/random_forest_classifier'
require 'rumale/ensemble/random_forest_regressor'
require 'rumale/clustering/k_means'
require 'rumale/clustering/dbscan'
require 'rumale/decomposition/pca'
require 'rumale/decomposition/nmf'
require 'rumale/preprocessing/l2_normalizer'
require 'rumale/preprocessing/min_max_scaler'
require 'rumale/preprocessing/standard_scaler'
require 'rumale/preprocessing/label_encoder'
require 'rumale/preprocessing/one_hot_encoder'
require 'rumale/model_selection/k_fold'
require 'rumale/model_selection/stratified_k_fold'
require 'rumale/model_selection/cross_validation'
require 'rumale/model_selection/grid_search_cv'
require 'rumale/evaluation_measure/accuracy'
require 'rumale/evaluation_measure/precision'
require 'rumale/evaluation_measure/recall'
require 'rumale/evaluation_measure/f_score'
require 'rumale/evaluation_measure/log_loss'
require 'rumale/evaluation_measure/r2_score'
require 'rumale/evaluation_measure/mean_squared_error'
require 'rumale/evaluation_measure/mean_absolute_error'
require 'rumale/evaluation_measure/purity'
require 'rumale/evaluation_measure/normalized_mutual_information'

4
lib/svmkit/base/base_estimator.rb → lib/rumale/base/base_estimator.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
module SVMKit
module Rumale
# This module consists of basic mix-in classes.
module Base
# Base module for all estimators in SVMKit.
# Base module for all estimators in Rumale.
module BaseEstimator
# Return parameters about an estimator.
# @return [Hash]

10
lib/svmkit/base/classifier.rb → lib/rumale/base/classifier.rb
View File

@ -1,11 +1,11 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/evaluation_measure/accuracy'
require 'rumale/validation'
require 'rumale/evaluation_measure/accuracy'
module SVMKit
module Rumale
module Base
# Module for all classifiers in SVMKit.
# Module for all classifiers in Rumale.
module Classifier
include Validation
@ -28,7 +28,7 @@ module SVMKit
check_sample_array(x)
check_label_array(y)
check_sample_label_size(x, y)
evaluator = SVMKit::EvaluationMeasure::Accuracy.new
evaluator = Rumale::EvaluationMeasure::Accuracy.new
evaluator.score(y, predict(x))
end
end

10
lib/svmkit/base/cluster_analyzer.rb → lib/rumale/base/cluster_analyzer.rb
View File

@ -1,11 +1,11 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/evaluation_measure/purity'
require 'rumale/validation'
require 'rumale/evaluation_measure/purity'
module SVMKit
module Rumale
module Base
# Module for all clustering algorithms in SVMKit.
# Module for all clustering algorithms in Rumale.
module ClusterAnalyzer
include Validation
@ -23,7 +23,7 @@ module SVMKit
check_sample_array(x)
check_label_array(y)
check_sample_label_size(x, y)
evaluator = SVMKit::EvaluationMeasure::Purity.new
evaluator = Rumale::EvaluationMeasure::Purity.new
evaluator.score(y, fit_predict(x))
end
end

6
lib/svmkit/base/evaluator.rb → lib/rumale/base/evaluator.rb
View File

@ -1,10 +1,10 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'rumale/validation'
module SVMKit
module Rumale
module Base
# Module for all evaluation measures in SVMKit.
# Module for all evaluation measures in Rumale.
module Evaluator
include Validation

10
lib/svmkit/base/regressor.rb → lib/rumale/base/regressor.rb
View File

@ -1,11 +1,11 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/evaluation_measure/r2_score'
require 'rumale/validation'
require 'rumale/evaluation_measure/r2_score'
module SVMKit
module Rumale
module Base
# Module for all regressors in SVMKit.
# Module for all regressors in Rumale.
module Regressor
include Validation
@ -28,7 +28,7 @@ module SVMKit
check_sample_array(x)
check_tvalue_array(y)
check_sample_tvalue_size(x, y)
evaluator = SVMKit::EvaluationMeasure::R2Score.new
evaluator = Rumale::EvaluationMeasure::R2Score.new
evaluator.score(y, predict(x))
end
end

6
lib/svmkit/base/splitter.rb → lib/rumale/base/splitter.rb
View File

@ -1,10 +1,10 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'rumale/validation'
module SVMKit
module Rumale
module Base
# Module for all validation methods in SVMKit.
# Module for all validation methods in Rumale.
module Splitter
include Validation

6
lib/svmkit/base/transformer.rb → lib/rumale/base/transformer.rb
View File

@ -1,10 +1,10 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'rumale/validation'
module SVMKit
module Rumale
module Base
# Module for all transfomers in SVMKit.
# Module for all transfomers in Rumale.
module Transformer
include Validation

10
lib/svmkit/clustering/dbscan.rb → lib/rumale/clustering/dbscan.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/cluster_analyzer'
require 'svmkit/pairwise_metric'
require 'rumale/base/base_estimator'
require 'rumale/base/cluster_analyzer'
require 'rumale/pairwise_metric'
module SVMKit
module Rumale
module Clustering
# DBSCAN is a class that implements DBSCAN cluster analysis.
# The current implementation uses the Euclidean distance for analyzing the clusters.
#
# @example
# analyzer = SVMKit::Clustering::DBSCAN.new(eps: 0.5, min_samples: 5)
# analyzer = Rumale::Clustering::DBSCAN.new(eps: 0.5, min_samples: 5)
# cluster_labels = analyzer.fit_predict(samples)
#
# *Reference*

12
lib/svmkit/clustering/k_means.rb → lib/rumale/clustering/k_means.rb
View File

@ -1,17 +1,17 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/cluster_analyzer'
require 'svmkit/pairwise_metric'
require 'rumale/base/base_estimator'
require 'rumale/base/cluster_analyzer'
require 'rumale/pairwise_metric'
module SVMKit
module Rumale
# This module consists of classes that implement cluster analysis methods.
module Clustering
# KMeans is a class that implements K-Means cluster analysis.
# The current implementation uses the Euclidean distance for analyzing the clusters.
#
# @example
# analyzer = SVMKit::Clustering::KMeans.new(n_clusters: 10, max_iter: 50)
# analyzer = Rumale::Clustering::KMeans.new(n_clusters: 10, max_iter: 50)
# cluster_labels = analyzer.fit_predict(samples)
#
# *Reference*
@ -66,7 +66,7 @@ module SVMKit
old_centers = @cluster_centers.dup
@params[:n_clusters].times do |n|
assigned_bits = cluster_labels.eq(n)
@cluster_centers[n, true] = x[assigned_bits.where, true].mean(axis: 0) if assigned_bits.count > 0
@cluster_centers[n, true] = x[assigned_bits.where, true].mean(axis: 0) if assigned_bits.count.positive?
end
error = Numo::NMath.sqrt(((old_centers - @cluster_centers)**2).sum(axis: 1)).mean
break if error <= @params[:tol]

2
lib/svmkit/dataset.rb → lib/rumale/dataset.rb
View File

@ -2,7 +2,7 @@
require 'csv'
module SVMKit
module Rumale
# Module for loading and saving a dataset file.
module Dataset
class << self

14
lib/svmkit/decomposition/nmf.rb → lib/rumale/decomposition/nmf.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/utils'
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/utils'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
module Decomposition
# NMF is a class that implements Non-negative Matrix Factorization.
#
# @example
# decomposer = SVMKit::Decomposition::NMF.new(n_components: 2)
# decomposer = Rumale::Decomposition::NMF.new(n_components: 2)
# representaion = decomposer.fit_transform(samples)
#
# *Reference*
@ -113,8 +113,8 @@ module SVMKit
# initialize some variables.
n_samples, n_features = x.shape
scale = Math.sqrt(x.mean / @params[:n_components])
@components = SVMKit::Utils.rand_uniform([@params[:n_components], n_features], @rng) * scale if update_comps
coefficients = SVMKit::Utils.rand_uniform([n_samples, @params[:n_components]], @rng) * scale
@components = Rumale::Utils.rand_uniform([@params[:n_components], n_features], @rng) * scale if update_comps
coefficients = Rumale::Utils.rand_uniform([n_samples, @params[:n_components]], @rng) * scale
# optimization.
@params[:max_iter].times do
# update

8
lib/svmkit/decomposition/pca.rb → lib/rumale/decomposition/pca.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
# Module for matrix decomposition algorithms.
module Decomposition
# PCA is a class that implements Principal Component Analysis.
#
# @example
# decomposer = SVMKit::Decomposition::PCA.new(n_components: 2)
# decomposer = Rumale::Decomposition::PCA.new(n_components: 2)
# representaion = decomposer.fit_transform(samples)
#
# *Reference*

18
lib/svmkit/ensemble/ada_boost_classifier.rb → lib/rumale/ensemble/ada_boost_classifier.rb
View File

@ -1,19 +1,19 @@
# frozen_string_literal: true
require 'svmkit/values'
require 'svmkit/utils'
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'svmkit/tree/decision_tree_classifier'
require 'rumale/values'
require 'rumale/utils'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
require 'rumale/tree/decision_tree_classifier'
module SVMKit
module Rumale
module Ensemble
# AdaBoostClassifier is a class that implements AdaBoost (SAMME.R) for classification.
# This class uses decision tree for a weak learner.
#
# @example
# estimator =
# SVMKit::Ensemble::AdaBoostClassifier.new(
# Rumale::Ensemble::AdaBoostClassifier.new(
# n_estimators: 10, criterion: 'gini', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
# estimator.fit(training_samples, traininig_labels)
# results = estimator.predict(testing_samples)
@ -102,12 +102,12 @@ module SVMKit
observation_weights = Numo::DFloat.zeros(n_samples) + 1.fdiv(n_samples)
@params[:n_estimators].times do |_t|
# Fit classfier.
ids = SVMKit::Utils.choice_ids(n_samples, observation_weights, @rng)
ids = Rumale::Utils.choice_ids(n_samples, observation_weights, @rng)
break if y[ids].to_a.uniq.size != n_classes
tree = Tree::DecisionTreeClassifier.new(
criterion: @params[:criterion], max_depth: @params[:max_depth],
max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
max_features: @params[:max_features], random_seed: @rng.rand(SVMKit::Values.int_max)
max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
)
tree.fit(x[ids, true], y[ids])
# Calculate estimator error.

16
lib/svmkit/ensemble/ada_boost_regressor.rb → lib/rumale/ensemble/ada_boost_regressor.rb
View File

@ -1,18 +1,18 @@
# frozen_string_literal: true
require 'svmkit/values'
require 'svmkit/base/base_estimator'
require 'svmkit/base/regressor'
require 'svmkit/tree/decision_tree_regressor'
require 'rumale/values'
require 'rumale/base/base_estimator'
require 'rumale/base/regressor'
require 'rumale/tree/decision_tree_regressor'
module SVMKit
module Rumale
module Ensemble
# AdaBoostRegressor is a class that implements random forest for regression.
# This class uses decision tree for a weak learner.
#
# @example
# estimator =
# SVMKit::Ensemble::AdaBoostRegressor.new(
# Rumale::Ensemble::AdaBoostRegressor.new(
# n_estimators: 10, criterion: 'mse', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
# estimator.fit(training_samples, traininig_values)
# results = estimator.predict(testing_samples)
@ -105,11 +105,11 @@ module SVMKit
# Construct forest.
@params[:n_estimators].times do |_t|
# Fit weak learner.
ids = SVMKit::Utils.choice_ids(n_samples, observation_weights, @rng)
ids = Rumale::Utils.choice_ids(n_samples, observation_weights, @rng)
tree = Tree::DecisionTreeRegressor.new(
criterion: @params[:criterion], max_depth: @params[:max_depth],
max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
max_features: @params[:max_features], random_seed: @rng.rand(SVMKit::Values.int_max)
max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
)
tree.fit(x[ids, true], y[ids])
p = tree.predict(x)

14
lib/svmkit/ensemble/random_forest_classifier.rb → lib/rumale/ensemble/random_forest_classifier.rb
View File

@ -1,18 +1,18 @@
# frozen_string_literal: true
require 'svmkit/values'
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'svmkit/tree/decision_tree_classifier'
require 'rumale/values'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
require 'rumale/tree/decision_tree_classifier'
module SVMKit
module Rumale
# This module consists of the classes that implement ensemble-based methods.
module Ensemble
# RandomForestClassifier is a class that implements random forest for classification.
#
# @example
# estimator =
# SVMKit::Ensemble::RandomForestClassifier.new(
# Rumale::Ensemble::RandomForestClassifier.new(
# n_estimators: 10, criterion: 'gini', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
# estimator.fit(training_samples, traininig_labels)
# results = estimator.predict(testing_samples)
@ -95,7 +95,7 @@ module SVMKit
tree = Tree::DecisionTreeClassifier.new(
criterion: @params[:criterion], max_depth: @params[:max_depth],
max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
max_features: @params[:max_features], random_seed: @rng.rand(SVMKit::Values.int_max)
max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
)
bootstrap_ids = Array.new(n_samples) { @rng.rand(0...n_samples) }
tree.fit(x[bootstrap_ids, true], y[bootstrap_ids])

14
lib/svmkit/ensemble/random_forest_regressor.rb → lib/rumale/ensemble/random_forest_regressor.rb
View File

@ -1,17 +1,17 @@
# frozen_string_literal: true
require 'svmkit/values'
require 'svmkit/base/base_estimator'
require 'svmkit/base/regressor'
require 'svmkit/tree/decision_tree_regressor'
require 'rumale/values'
require 'rumale/base/base_estimator'
require 'rumale/base/regressor'
require 'rumale/tree/decision_tree_regressor'
module SVMKit
module Rumale
module Ensemble
# RandomForestRegressor is a class that implements random forest for regression
#
# @example
# estimator =
# SVMKit::Ensemble::RandomForestRegressor.new(
# Rumale::Ensemble::RandomForestRegressor.new(
# n_estimators: 10, criterion: 'mse', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
# estimator.fit(training_samples, traininig_values)
# results = estimator.predict(testing_samples)
@ -89,7 +89,7 @@ module SVMKit
tree = Tree::DecisionTreeRegressor.new(
criterion: @params[:criterion], max_depth: @params[:max_depth],
max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
max_features: @params[:max_features], random_seed: @rng.rand(SVMKit::Values.int_max)
max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
)
bootstrap_ids = Array.new(n_samples) { @rng.rand(0...n_samples) }
tree.fit(x[bootstrap_ids, true], single_target ? y[bootstrap_ids] : y[bootstrap_ids, true])

6
lib/svmkit/evaluation_measure/accuracy.rb → lib/rumale/evaluation_measure/accuracy.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'rumale/base/evaluator'
module SVMKit
module Rumale
# This module consists of the classes for model evaluation.
module EvaluationMeasure
# Accuracy is a class that calculates the accuracy of classifier from the predicted labels.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::Accuracy.new
# evaluator = Rumale::EvaluationMeasure::Accuracy.new
# puts evaluator.score(ground_truth, predicted)
class Accuracy
include Base::Evaluator

8
lib/svmkit/evaluation_measure/f_score.rb → lib/rumale/evaluation_measure/f_score.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'svmkit/evaluation_measure/precision_recall'
require 'rumale/base/evaluator'
require 'rumale/evaluation_measure/precision_recall'
module SVMKit
module Rumale
# This module consists of the classes for model evaluation.
module EvaluationMeasure
# FScore is a class that calculates the F1-score of the predicted labels.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::FScore.new
# evaluator = Rumale::EvaluationMeasure::FScore.new
# puts evaluator.score(ground_truth, predicted)
class FScore
include Base::Evaluator

10
lib/svmkit/evaluation_measure/log_loss.rb → lib/rumale/evaluation_measure/log_loss.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'svmkit/preprocessing/one_hot_encoder'
require 'rumale/base/evaluator'
require 'rumale/preprocessing/one_hot_encoder'
module SVMKit
module Rumale
module EvaluationMeasure
# LogLoss is a class that calculates the logarithmic loss of predicted class probability.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::LogLoss.new
# evaluator = Rumale::EvaluationMeasure::LogLoss.new
# puts evaluator.score(ground_truth, predicted)
class LogLoss
include Base::Evaluator
@ -33,7 +33,7 @@ module SVMKit
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 = SVMKit::Preprocessing::OneHotEncoder.new
encoder = Rumale::Preprocessing::OneHotEncoder.new
encoded_y_true = encoder.fit_transform(y_true)
clipped_p /= clipped_p.sum(1).expand_dims(1)
-(encoded_y_true * Numo::NMath.log(clipped_p)).sum(1)

6
lib/svmkit/evaluation_measure/mean_absolute_error.rb → lib/rumale/evaluation_measure/mean_absolute_error.rb
View File

@ -1,13 +1,13 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'rumale/base/evaluator'
module SVMKit
module Rumale
module EvaluationMeasure
# MeanAbsoluteError is a class that calculates the mean absolute error.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::MeanAbsoluteError.new
# evaluator = Rumale::EvaluationMeasure::MeanAbsoluteError.new
# puts evaluator.score(ground_truth, predicted)
class MeanAbsoluteError
include Base::Evaluator

6
lib/svmkit/evaluation_measure/mean_squared_error.rb → lib/rumale/evaluation_measure/mean_squared_error.rb
View File

@ -1,13 +1,13 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'rumale/base/evaluator'
module SVMKit
module Rumale
module EvaluationMeasure
# MeanSquaredError is a class that calculates the mean squared error.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::MeanSquaredError.new
# evaluator = Rumale::EvaluationMeasure::MeanSquaredError.new
# puts evaluator.score(ground_truth, predicted)
class MeanSquaredError
include Base::Evaluator

8
lib/svmkit/evaluation_measure/normalized_mutual_information.rb → lib/rumale/evaluation_measure/normalized_mutual_information.rb
View File

@ -1,13 +1,13 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'rumale/base/evaluator'
module SVMKit
module Rumale
module EvaluationMeasure
# NormalizedMutualInformation is a class that calculates the normalized mutual information of cluatering results.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::NormalizedMutualInformation.new
# evaluator = Rumale::EvaluationMeasure::NormalizedMutualInformation.new
# puts evaluator.score(ground_truth, predicted)
#
# *Reference*
@ -48,7 +48,7 @@ module SVMKit
tr_sample_ids = y_true.eq(j).where.to_a
n_tr_samples = tr_sample_ids.size
n_intr_samples = (pr_sample_ids & tr_sample_ids).size
if n_intr_samples > 0
if n_intr_samples.positive?
mutual_information +=
n_intr_samples.fdiv(n_samples) * Math.log((n_samples * n_intr_samples).fdiv(n_pr_samples * n_tr_samples))
end

8
lib/svmkit/evaluation_measure/precision.rb → lib/rumale/evaluation_measure/precision.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'svmkit/evaluation_measure/precision_recall'
require 'rumale/base/evaluator'
require 'rumale/evaluation_measure/precision_recall'
module SVMKit
module Rumale
# This module consists of the classes for model evaluation.
module EvaluationMeasure
# Precision is a class that calculates the preicision of the predicted labels.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::Precision.new
# evaluator = Rumale::EvaluationMeasure::Precision.new
# puts evaluator.score(ground_truth, predicted)
class Precision
include Base::Evaluator

4
lib/svmkit/evaluation_measure/precision_recall.rb → lib/rumale/evaluation_measure/precision_recall.rb
View File

@ -1,8 +1,8 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'rumale/base/evaluator'
module SVMKit
module Rumale
# This module consists of the classes for model evaluation.
module EvaluationMeasure
# @!visibility private

6
lib/svmkit/evaluation_measure/purity.rb → lib/rumale/evaluation_measure/purity.rb
View File

@ -1,13 +1,13 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'rumale/base/evaluator'
module SVMKit
module Rumale
module EvaluationMeasure
# Purity is a class that calculates the purity of cluatering results.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::Purity.new
# evaluator = Rumale::EvaluationMeasure::Purity.new
# puts evaluator.score(ground_truth, predicted)
#
# *Reference*

8
lib/svmkit/evaluation_measure/r2_score.rb → lib/rumale/evaluation_measure/r2_score.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'svmkit/evaluation_measure/precision_recall'
require 'rumale/base/evaluator'
require 'rumale/evaluation_measure/precision_recall'
module SVMKit
module Rumale
module EvaluationMeasure
# R2Score is a class that calculates the coefficient of determination for the predicted values.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::R2Score.new
# evaluator = Rumale::EvaluationMeasure::R2Score.new
# puts evaluator.score(ground_truth, predicted)
class R2Score
include Base::Evaluator

8
lib/svmkit/evaluation_measure/recall.rb → lib/rumale/evaluation_measure/recall.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/evaluator'
require 'svmkit/evaluation_measure/precision_recall'
require 'rumale/base/evaluator'
require 'rumale/evaluation_measure/precision_recall'
module SVMKit
module Rumale
# This module consists of the classes for model evaluation.
module EvaluationMeasure
# Recall is a class that calculates the recall of the predicted labels.
#
# @example
# evaluator = SVMKit::EvaluationMeasure::Recall.new
# evaluator = Rumale::EvaluationMeasure::Recall.new
# puts evaluator.score(ground_truth, predicted)
class Recall
include Base::Evaluator

12
lib/svmkit/kernel_approximation/rbf.rb → lib/rumale/kernel_approximation/rbf.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/utils'
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/utils'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
# Module for kernel approximation algorithms.
module KernelApproximation
# Class for RBF kernel feature mapping.
#
# @example
# transformer = SVMKit::KernelApproximation::RBF.new(gamma: 1.0, n_coponents: 128, random_seed: 1)
# transformer = Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_coponents: 128, random_seed: 1)
# new_training_samples = transformer.fit_transform(training_samples)
# new_testing_samples = transformer.transform(testing_samples)
#
@ -64,7 +64,7 @@ module SVMKit
n_features = x.shape[1]
@params[:n_components] = 2 * n_features if @params[:n_components] <= 0
@random_mat = SVMKit::Utils.rand_normal([n_features, @params[:n_components]], @rng) * (2.0 * @params[:gamma])**0.5
@random_mat = Rumale::Utils.rand_normal([n_features, @params[:n_components]], @rng) * (2.0 * @params[:gamma])**0.5
n_half_components = @params[:n_components] / 2
@random_vec = Numo::DFloat.zeros(@params[:n_components] - n_half_components).concatenate(
Numo::DFloat.ones(n_half_components) * (0.5 * Math::PI)

18
lib/svmkit/kernel_machine/kernel_svc.rb → lib/rumale/kernel_machine/kernel_svc.rb
View File

@ -1,10 +1,10 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'svmkit/probabilistic_output'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
require 'rumale/probabilistic_output'
module SVMKit
module Rumale
# This module consists of the classes that implement kernel method-based estimator.
module KernelMachine
# KernelSVC is a class that implements (Nonlinear) Kernel Support Vector Classifier
@ -12,11 +12,11 @@ module SVMKit
# For multiclass classification problem, it uses one-vs-the-rest strategy.
#
# @example
# training_kernel_matrix = SVMKit::PairwiseMetric::rbf_kernel(training_samples)
# training_kernel_matrix = Rumale::PairwiseMetric::rbf_kernel(training_samples)
# estimator =
# SVMKit::KernelMachine::KernelSVC.new(reg_param: 1.0, max_iter: 1000, random_seed: 1)
# Rumale::KernelMachine::KernelSVC.new(reg_param: 1.0, max_iter: 1000, random_seed: 1)
# estimator.fit(training_kernel_matrix, traininig_labels)
# testing_kernel_matrix = SVMKit::PairwiseMetric::rbf_kernel(testing_samples, training_samples)
# testing_kernel_matrix = Rumale::PairwiseMetric::rbf_kernel(testing_samples, training_samples)
# results = estimator.predict(testing_kernel_matrix)
#
# *Reference*
@ -83,7 +83,7 @@ module SVMKit
bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
@weight_vec[n, true] = binary_fit(x, bin_y)
@prob_param[n, true] = if @params[:probability]
SVMKit::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose), bin_y)
Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose), bin_y)
else
Numo::DFloat[1, 0]
end
@ -93,7 +93,7 @@ module SVMKit
bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
@weight_vec = binary_fit(x, bin_y)
@prob_param = if @params[:probability]
SVMKit::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose), bin_y)
Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose), bin_y)
else
Numo::DFloat[1, 0]
end

6
lib/svmkit/linear_model/base_linear_model.rb → lib/rumale/linear_model/base_linear_model.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/optimizer/nadam'
require 'rumale/base/base_estimator'
require 'rumale/optimizer/nadam'
module SVMKit
module Rumale
module LinearModel
# BaseLinearModel is an abstract class for implementation of linear estimator
# with mini-batch stochastic gradient descent optimization.

8
lib/svmkit/linear_model/lasso.rb → lib/rumale/linear_model/lasso.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/base/regressor'
require 'rumale/linear_model/base_linear_model'
require 'rumale/base/regressor'
module SVMKit
module Rumale
module LinearModel
# Lasso is a class that implements Lasso Regression
# with stochastic gradient descent (SGD) optimization.
#
# @example
# estimator =
# SVMKit::LinearModel::Lasso.new(reg_param: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
# Rumale::LinearModel::Lasso.new(reg_param: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
# estimator.fit(training_samples, traininig_values)
# results = estimator.predict(testing_samples)
#

8
lib/svmkit/linear_model/linear_regression.rb → lib/rumale/linear_model/linear_regression.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/base/regressor'
require 'rumale/linear_model/base_linear_model'
require 'rumale/base/regressor'
module SVMKit
module Rumale
module LinearModel
# LinearRegression is a class that implements ordinary least square linear regression
# with mini-batch stochastic gradient descent optimization.
#
# @example
# estimator =
# SVMKit::LinearModel::LinearRegression.new(max_iter: 1000, batch_size: 20, random_seed: 1)
# Rumale::LinearModel::LinearRegression.new(max_iter: 1000, batch_size: 20, random_seed: 1)
# estimator.fit(training_samples, traininig_values)
# results = estimator.predict(testing_samples)
#

8
lib/svmkit/linear_model/logistic_regression.rb → lib/rumale/linear_model/logistic_regression.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/base/classifier'
require 'rumale/linear_model/base_linear_model'
require 'rumale/base/classifier'
module SVMKit
module Rumale
module LinearModel
# LogisticRegression is a class that implements Logistic Regression
# with mini-batch stochastic gradient descent optimization.
@ -11,7 +11,7 @@ module SVMKit
#
# @example
# estimator =
# SVMKit::LinearModel::LogisticRegression.new(reg_param: 1.0, max_iter: 1000, batch_size: 20, random_seed: 1)
# Rumale::LinearModel::LogisticRegression.new(reg_param: 1.0, max_iter: 1000, batch_size: 20, random_seed: 1)
# estimator.fit(training_samples, traininig_labels)
# results = estimator.predict(testing_samples)
#

8
lib/svmkit/linear_model/ridge.rb → lib/rumale/linear_model/ridge.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/base/regressor'
require 'rumale/linear_model/base_linear_model'
require 'rumale/base/regressor'
module SVMKit
module Rumale
module LinearModel
# Ridge is a class that implements Ridge Regression
# with mini-batch stochastic gradient descent optimization.
#
# @example
# estimator =
# SVMKit::LinearModel::Ridge.new(reg_param: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
# Rumale::LinearModel::Ridge.new(reg_param: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
# estimator.fit(training_samples, traininig_values)
# results = estimator.predict(testing_samples)
#

14
lib/svmkit/linear_model/svc.rb → lib/rumale/linear_model/svc.rb
View File

@ -1,10 +1,10 @@
# frozen_string_literal: true
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/base/classifier'
require 'svmkit/probabilistic_output'
require 'rumale/linear_model/base_linear_model'
require 'rumale/base/classifier'
require 'rumale/probabilistic_output'
module SVMKit
module Rumale
# This module consists of the classes that implement generalized linear models.
module LinearModel
# SVC is a class that implements Support Vector Classifier
@ -13,7 +13,7 @@ module SVMKit
#
# @example
# estimator =
# SVMKit::LinearModel::SVC.new(reg_param: 1.0, max_iter: 1000, batch_size: 20, random_seed: 1)
# Rumale::LinearModel::SVC.new(reg_param: 1.0, max_iter: 1000, batch_size: 20, random_seed: 1)
# estimator.fit(training_samples, traininig_labels)
# results = estimator.predict(testing_samples)
#
@ -86,7 +86,7 @@ module SVMKit
bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
@weight_vec[n, true], @bias_term[n] = partial_fit(x, bin_y)
@prob_param[n, true] = if @params[:probability]
SVMKit::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose) + @bias_term[n], bin_y)
Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose) + @bias_term[n], bin_y)
else
Numo::DFloat[1, 0]
end
@ -96,7 +96,7 @@ module SVMKit
bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
@weight_vec, @bias_term = partial_fit(x, bin_y)
@prob_param = if @params[:probability]
SVMKit::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose) + @bias_term, bin_y)
Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose) + @bias_term, bin_y)
else
Numo::DFloat[1, 0]
end

8
lib/svmkit/linear_model/svr.rb → lib/rumale/linear_model/svr.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/base/regressor'
require 'rumale/linear_model/base_linear_model'
require 'rumale/base/regressor'
module SVMKit
module Rumale
module LinearModel
# SVR is a class that implements Support Vector Regressor
# with mini-batch stochastic gradient descent optimization.
#
# @example
# estimator =
# SVMKit::LinearModel::SVR.new(reg_param: 1.0, epsilon: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
# Rumale::LinearModel::SVR.new(reg_param: 1.0, epsilon: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
# estimator.fit(training_samples, traininig_target_values)
# results = estimator.predict(testing_samples)
#

34
lib/svmkit/model_selection/cross_validation.rb → lib/rumale/model_selection/cross_validation.rb
View File

@ -1,22 +1,22 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'svmkit/base/regressor'
require 'svmkit/base/splitter'
require 'svmkit/base/evaluator'
require 'svmkit/evaluation_measure/log_loss'
require 'rumale/validation'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
require 'rumale/base/regressor'
require 'rumale/base/splitter'
require 'rumale/base/evaluator'
require 'rumale/evaluation_measure/log_loss'
module SVMKit
module Rumale
# This module consists of the classes for model validation techniques.
module ModelSelection
# CrossValidation is a class that evaluates a given classifier with cross-validation method.
#
# @example
# svc = SVMKit::LinearModel::SVC.new
# kf = SVMKit::ModelSelection::StratifiedKFold.new(n_splits: 5)
# cv = SVMKit::ModelSelection::CrossValidation.new(estimator: svc, splitter: kf)
# svc = Rumale::LinearModel::SVC.new
# kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5)
# cv = Rumale::ModelSelection::CrossValidation.new(estimator: svc, splitter: kf)
# report = cv.perform(samples, lables)
# mean_test_score = report[:test_score].inject(:+) / kf.n_splits
#
@ -46,9 +46,9 @@ module SVMKit
# @param evaluator [Evaluator] The evaluator that calculates score of estimator results.
# @param return_train_score [Boolean] The flag indicating whether to calculate the score of training dataset.
def initialize(estimator: nil, splitter: nil, evaluator: nil, return_train_score: false)
check_params_type(SVMKit::Base::BaseEstimator, estimator: estimator)
check_params_type(SVMKit::Base::Splitter, splitter: splitter)
check_params_type_or_nil(SVMKit::Base::Evaluator, evaluator: evaluator)
check_params_type(Rumale::Base::BaseEstimator, estimator: estimator)
check_params_type(Rumale::Base::Splitter, splitter: splitter)
check_params_type_or_nil(Rumale::Base::Evaluator, evaluator: evaluator)
check_params_boolean(return_train_score: return_train_score)
@estimator = estimator
@splitter = splitter
@ -69,11 +69,11 @@ module SVMKit
# the return_train_score is false.
def perform(x, y)
check_sample_array(x)
if @estimator.is_a?(SVMKit::Base::Classifier)
if @estimator.is_a?(Rumale::Base::Classifier)
check_label_array(y)
check_sample_label_size(x, y)
end
if @estimator.is_a?(SVMKit::Base::Regressor)
if @estimator.is_a?(Rumale::Base::Regressor)
check_tvalue_array(y)
check_sample_tvalue_size(x, y)
end
@ -116,7 +116,7 @@ module SVMKit
end
def log_loss?
@evaluator.is_a?(SVMKit::EvaluationMeasure::LogLoss)
@evaluator.is_a?(Rumale::EvaluationMeasure::LogLoss)
end
end
end

36
lib/svmkit/model_selection/grid_search_cv.rb → lib/rumale/model_selection/grid_search_cv.rb
View File

@ -1,31 +1,31 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'svmkit/base/evaluator'
require 'svmkit/base/splitter'
require 'svmkit/pipeline/pipeline'
require 'rumale/validation'
require 'rumale/base/base_estimator'
require 'rumale/base/evaluator'
require 'rumale/base/splitter'
require 'rumale/pipeline/pipeline'
module SVMKit
module Rumale
module ModelSelection
# GridSearchCV is a class that performs hyperparameter optimization with grid search method.
#
# @example
# rfc = SVMKit::Ensemble::RandomForestClassifier.new(random_seed: 1)
# rfc = Rumale::Ensemble::RandomForestClassifier.new(random_seed: 1)
# pg = { n_estimators: [5, 10], max_depth: [3, 5], max_leaf_nodes: [15, 31] }
# kf = SVMKit::ModelSelection::StratifiedKFold.new(n_splits: 5)
# gs = SVMKit::ModelSelection::GridSearchCV.new(estimator: rfc, param_grid: pg, splitter: kf)
# kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5)
# gs = Rumale::ModelSelection::GridSearchCV.new(estimator: rfc, param_grid: pg, splitter: kf)
# gs.fit(samples, labels)
# p gs.cv_results
# p gs.best_params
#
# @example
# rbf = SVMKit::KernelApproximation::RBF.new(random_seed: 1)
# svc = SVMKit::LinearModel::SVC.new(random_seed: 1)
# pipe = SVMKit::Pipeline::Pipeline.new(steps: { rbf: rbf, svc: svc })
# rbf = Rumale::KernelApproximation::RBF.new(random_seed: 1)
# svc = Rumale::LinearModel::SVC.new(random_seed: 1)
# pipe = Rumale::Pipeline::Pipeline.new(steps: { rbf: rbf, svc: svc })
# pg = { rbf__gamma: [32.0, 1.0], rbf__n_components: [4, 128], svc__reg_param: [16.0, 0.1] }
# kf = SVMKit::ModelSelection::StratifiedKFold.new(n_splits: 5)
# gs = SVMKit::ModelSelection::GridSearchCV.new(estimator: pipe, param_grid: pg, splitter: kf)
# kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5)
# gs = Rumale::ModelSelection::GridSearchCV.new(estimator: pipe, param_grid: pg, splitter: kf)
# gs.fit(samples, labels)
# p gs.cv_results
# p gs.best_params
@ -65,9 +65,9 @@ module SVMKit
# @param greater_is_better [Boolean] The flag that indicates whether the estimator is better as
# evaluation score is larger.
def initialize(estimator: nil, param_grid: nil, splitter: nil, evaluator: nil, greater_is_better: true)
check_params_type(SVMKit::Base::BaseEstimator, estimator: estimator)
check_params_type(SVMKit::Base::Splitter, splitter: splitter)
check_params_type_or_nil(SVMKit::Base::Evaluator, evaluator: evaluator)
check_params_type(Rumale::Base::BaseEstimator, estimator: estimator)
check_params_type(Rumale::Base::Splitter, splitter: splitter)
check_params_type_or_nil(Rumale::Base::Evaluator, evaluator: evaluator)
check_params_boolean(greater_is_better: greater_is_better)
@params = {}
@params[:param_grid] = valid_param_grid(param_grid)
@ -203,7 +203,7 @@ module SVMKit
def configurated_estimator(prms)
estimator = Marshal.load(Marshal.dump(@params[:estimator]))
if @params[:estimator].is_a?(SVMKit::Pipeline::Pipeline)
if @params[:estimator].is_a?(Rumale::Pipeline::Pipeline)
prms.each do |k, v|
est_name, prm_name = k.to_s.split('__')
estimator.steps[est_name.to_sym].params[prm_name.to_sym] = v

6
lib/svmkit/model_selection/k_fold.rb → lib/rumale/model_selection/k_fold.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/splitter'
require 'rumale/base/splitter'
module SVMKit
module Rumale
# This module consists of the classes for model validation techniques.
module ModelSelection
# KFold is a class that generates the set of data indices for K-fold cross-validation.
#
# @example
# kf = SVMKit::ModelSelection::KFold.new(n_splits: 3, shuffle: true, random_seed: 1)
# kf = Rumale::ModelSelection::KFold.new(n_splits: 3, shuffle: true, random_seed: 1)
# kf.split(samples, labels).each do |train_ids, test_ids|
# train_samples = samples[train_ids, true]
# test_samples = samples[test_ids, true]

6
lib/svmkit/model_selection/stratified_k_fold.rb → lib/rumale/model_selection/stratified_k_fold.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/splitter'
require 'rumale/base/splitter'
module SVMKit
module Rumale
module ModelSelection
# StratifiedKFold is a class that generates the set of data indices for K-fold cross-validation.
# The proportion of the number of samples in each class will be almost equal for each fold.
#
# @example
# kf = SVMKit::ModelSelection::StratifiedKFold.new(n_splits: 3, shuffle: true, random_seed: 1)
# kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 3, shuffle: true, random_seed: 1)
# kf.split(samples, labels).each do |train_ids, test_ids|
# train_samples = samples[train_ids, true]
# test_samples = samples[test_ids, true]

14
lib/svmkit/multiclass/one_vs_rest_classifier.rb → lib/rumale/multiclass/one_vs_rest_classifier.rb
View File

@ -1,20 +1,20 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator.rb'
require 'svmkit/base/classifier.rb'
require 'rumale/base/base_estimator.rb'
require 'rumale/base/classifier.rb'
module SVMKit
module Rumale
# This module consists of the classes that implement multi-class classification strategy.
module Multiclass
# @note
# All classifier in SVMKit support multi-class classifiction since version 0.2.7.
# All classifier in Rumale support multi-class classifiction since version 0.2.7.
# There is no need to explicitly use this class for multiclass classifiction.
#
# OneVsRestClassifier is a class that implements One-vs-Rest (OvR) strategy for multi-class classification.
#
# @example
# base_estimator = SVMKit::LinearModel::LogisticRegression.new
# estimator = SVMKit::Multiclass::OneVsRestClassifier.new(estimator: base_estimator)
# base_estimator = Rumale::LinearModel::LogisticRegression.new
# estimator = Rumale::Multiclass::OneVsRestClassifier.new(estimator: base_estimator)
# estimator.fit(training_samples, training_labels)
# results = estimator.predict(testing_samples)
class OneVsRestClassifier
@ -33,7 +33,7 @@ module SVMKit
#
# @param estimator [Classifier] The (binary) classifier for construction a multi-class classifier.
def initialize(estimator: nil)
check_params_type(SVMKit::Base::BaseEstimator, estimator: estimator)
check_params_type(Rumale::Base::BaseEstimator, estimator: estimator)
@params = {}
@params[:estimator] = estimator
@estimators = nil

12
lib/svmkit/naive_bayes/naive_bayes.rb → lib/rumale/naive_bayes/naive_bayes.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
module SVMKit
module Rumale
# This module consists of the classes that implement naive bayes models.
module NaiveBayes
# BaseNaiveBayes is a class that has methods for common processes of naive bayes classifier.
@ -46,7 +46,7 @@ module SVMKit
# GaussianNB is a class that implements Gaussian Naive Bayes classifier.
#
# @example
# estimator = SVMKit::NaiveBayes::GaussianNB.new
# estimator = Rumale::NaiveBayes::GaussianNB.new
# estimator.fit(training_samples, training_labels)
# results = estimator.predict(testing_samples)
class GaussianNB < BaseNaiveBayes
@ -131,7 +131,7 @@ module SVMKit
# MultinomialNB is a class that implements Multinomial Naive Bayes classifier.
#
# @example
# estimator = SVMKit::NaiveBayes::MultinomialNB.new(smoothing_param: 1.0)
# estimator = Rumale::NaiveBayes::MultinomialNB.new(smoothing_param: 1.0)
# estimator.fit(training_samples, training_labels)
# results = estimator.predict(testing_samples)
#
@ -219,7 +219,7 @@ module SVMKit
# BernoulliNB is a class that implements Bernoulli Naive Bayes classifier.
#
# @example
# estimator = SVMKit::NaiveBayes::BernoulliNB.new(smoothing_param: 1.0, bin_threshold: 0.0)
# estimator = Rumale::NaiveBayes::BernoulliNB.new(smoothing_param: 1.0, bin_threshold: 0.0)
# estimator.fit(training_samples, training_labels)
# results = estimator.predict(testing_samples)
#

8
lib/svmkit/nearest_neighbors/k_neighbors_classifier.rb → lib/rumale/nearest_neighbors/k_neighbors_classifier.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'rumale/base/base_estimator'
require 'rumale/base/classifier'
module SVMKit
module Rumale
# This module consists of the classes that implement estimators based on nearest neighbors rule.
module NearestNeighbors
# KNeighborsClassifier is a class that implements the classifier with the k-nearest neighbors rule.
@ -11,7 +11,7 @@ module SVMKit
#
# @example
# estimator =
# SVMKit::NearestNeighbors::KNeighborsClassifier.new(n_neighbors = 5)
# Rumale::NearestNeighbors::KNeighborsClassifier.new(n_neighbors = 5)
# estimator.fit(training_samples, traininig_labels)
# results = estimator.predict(testing_samples)
#

8
lib/svmkit/nearest_neighbors/k_neighbors_regressor.rb → lib/rumale/nearest_neighbors/k_neighbors_regressor.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/regressor'
require 'rumale/base/base_estimator'
require 'rumale/base/regressor'
module SVMKit
module Rumale
module NearestNeighbors
# KNeighborsRegressor is a class that implements the regressor with the k-nearest neighbors rule.
# The current implementation uses the Euclidean distance for finding the neighbors.
#
# @example
# estimator =
# SVMKit::NearestNeighbors::KNeighborsRegressor.new(n_neighbors = 5)
# Rumale::NearestNeighbors::KNeighborsRegressor.new(n_neighbors = 5)
# estimator.fit(training_samples, traininig_target_values)
# results = estimator.predict(testing_samples)
#

10
lib/svmkit/optimizer/nadam.rb → lib/rumale/optimizer/nadam.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'rumale/validation'
require 'rumale/base/base_estimator'
module SVMKit
module Rumale
# This module consists of the classes that implement optimizers adaptively tuning hyperparameters.
module Optimizer
# Nadam is a class that implements Nadam optimizer.
#
# @example
# optimizer = SVMKit::Optimizer::Nadam.new(learning_rate: 0.01, momentum: 0.9, decay1: 0.9, decay2: 0.999)
# estimator = SVMKit::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# optimizer = Rumale::Optimizer::Nadam.new(learning_rate: 0.01, momentum: 0.9, decay1: 0.9, decay2: 0.999)
# estimator = Rumale::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# estimator.fit(samples, values)
#
# *Reference*

10
lib/svmkit/optimizer/rmsprop.rb → lib/rumale/optimizer/rmsprop.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'rumale/validation'
require 'rumale/base/base_estimator'
module SVMKit
module Rumale
module Optimizer
# RMSProp is a class that implements RMSProp optimizer.
#
# @example
# optimizer = SVMKit::Optimizer::RMSProp.new(learning_rate: 0.01, momentum: 0.9, decay: 0.9)
# estimator = SVMKit::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# optimizer = Rumale::Optimizer::RMSProp.new(learning_rate: 0.01, momentum: 0.9, decay: 0.9)
# estimator = Rumale::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# estimator.fit(samples, values)
#
# *Reference*

10
lib/svmkit/optimizer/sgd.rb → lib/rumale/optimizer/sgd.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'rumale/validation'
require 'rumale/base/base_estimator'
module SVMKit
module Rumale
module Optimizer
# SGD is a class that implements SGD optimizer.
#
# @example
# optimizer = SVMKit::Optimizer::SGD.new(learning_rate: 0.01, momentum: 0.9, decay: 0.9)
# estimator = SVMKit::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# optimizer = Rumale::Optimizer::SGD.new(learning_rate: 0.01, momentum: 0.9, decay: 0.9)
# estimator = Rumale::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# estimator.fit(samples, values)
class SGD
include Base::BaseEstimator

10
lib/svmkit/optimizer/yellow_fin.rb → lib/rumale/optimizer/yellow_fin.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'rumale/validation'
require 'rumale/base/base_estimator'
module SVMKit
module Rumale
module Optimizer
# YellowFin is a class that implements YellowFin optimizer.
#
# @example
# optimizer = SVMKit::Optimizer::YellowFin.new(learning_rate: 0.01, momentum: 0.9, decay: 0.999, window_width: 20)
# estimator = SVMKit::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# optimizer = Rumale::Optimizer::YellowFin.new(learning_rate: 0.01, momentum: 0.9, decay: 0.999, window_width: 20)
# estimator = Rumale::LinearModel::LinearRegression.new(optimizer: optimizer, random_seed: 1)
# estimator.fit(samples, values)
#
# *Reference*

34
lib/svmkit/pairwise_metric.rb → lib/rumale/pairwise_metric.rb
View File

@ -1,8 +1,8 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'rumale/validation'
module SVMKit
module Rumale
# Module for calculating pairwise distances, similarities, and kernels.
module PairwiseMetric
class << self
@ -13,8 +13,8 @@ module SVMKit
# @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
def euclidean_distance(x, y = nil)
y = x if y.nil?
SVMKit::Validation.check_sample_array(x)
SVMKit::Validation.check_sample_array(y)
Rumale::Validation.check_sample_array(x)
Rumale::Validation.check_sample_array(y)
sum_x_vec = (x**2).sum(1)
sum_y_vec = (y**2).sum(1)
dot_xy_mat = x.dot(y.transpose)
@ -33,9 +33,9 @@ module SVMKit
def rbf_kernel(x, y = nil, gamma = nil)
y = x if y.nil?
gamma ||= 1.0 / x.shape[1]
SVMKit::Validation.check_sample_array(x)
SVMKit::Validation.check_sample_array(y)
SVMKit::Validation.check_params_float(gamma: gamma)
Rumale::Validation.check_sample_array(x)
Rumale::Validation.check_sample_array(y)
Rumale::Validation.check_params_float(gamma: gamma)
distance_matrix = euclidean_distance(x, y)
Numo::NMath.exp((distance_matrix**2) * -gamma)
end
@ -47,8 +47,8 @@ module SVMKit
# @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
def linear_kernel(x, y = nil)
y = x if y.nil?
SVMKit::Validation.check_sample_array(x)
SVMKit::Validation.check_sample_array(y)
Rumale::Validation.check_sample_array(x)
Rumale::Validation.check_sample_array(y)
x.dot(y.transpose)
end
@ -63,10 +63,10 @@ module SVMKit
def polynomial_kernel(x, y = nil, degree = 3, gamma = nil, coef = 1)
y = x if y.nil?
gamma ||= 1.0 / x.shape[1]
SVMKit::Validation.check_sample_array(x)
SVMKit::Validation.check_sample_array(y)
SVMKit::Validation.check_params_float(gamma: gamma)
SVMKit::Validation.check_params_integer(degree: degree, coef: coef)
Rumale::Validation.check_sample_array(x)
Rumale::Validation.check_sample_array(y)
Rumale::Validation.check_params_float(gamma: gamma)
Rumale::Validation.check_params_integer(degree: degree, coef: coef)
(x.dot(y.transpose) * gamma + coef)**degree
end
@ -80,10 +80,10 @@ module SVMKit
def sigmoid_kernel(x, y = nil, gamma = nil, coef = 1)
y = x if y.nil?
gamma ||= 1.0 / x.shape[1]
SVMKit::Validation.check_sample_array(x)
SVMKit::Validation.check_sample_array(y)
SVMKit::Validation.check_params_float(gamma: gamma)
SVMKit::Validation.check_params_integer(coef: coef)
Rumale::Validation.check_sample_array(x)
Rumale::Validation.check_sample_array(y)
Rumale::Validation.check_params_float(gamma: gamma)
Rumale::Validation.check_params_integer(coef: coef)
Numo::NMath.tanh(x.dot(y.transpose) * gamma + coef)
end
end

16
lib/svmkit/pipeline/pipeline.rb → lib/rumale/pipeline/pipeline.rb
View File

@ -1,17 +1,17 @@
# frozen_string_literal: true
require 'svmkit/validation'
require 'svmkit/base/base_estimator'
require 'rumale/validation'
require 'rumale/base/base_estimator'
module SVMKit
module Rumale
# Module implements utilities of pipeline that cosists of a chain of transfomers and estimators.
module Pipeline
# Pipeline is a class that implements the function to perform the transformers and estimators sequencially.
#
# @example
# rbf = SVMKit::KernelApproximation::RBF.new(gamma: 1.0, n_coponents: 128, random_seed: 1)
# svc = SVMKit::LinearModel::SVC.new(reg_param: 1.0, fit_bias: true, max_iter: 5000, random_seed: 1)
# pipeline = SVMKit::Pipeline::Pipeline.new(steps: { trs: rbf, est: svc })
# rbf = Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_coponents: 128, random_seed: 1)
# svc = Rumale::LinearModel::SVC.new(reg_param: 1.0, fit_bias: true, max_iter: 5000, random_seed: 1)
# pipeline = Rumale::Pipeline::Pipeline.new(steps: { trs: rbf, est: svc })
# pipeline.fit(training_samples, traininig_labels)
# results = pipeline.predict(testing_samples)
#
@ -42,7 +42,7 @@ module SVMKit
def fit(x, y)
check_sample_array(x)
trans_x = apply_transforms(x, y, fit: true)
last_estimator.fit(trans_x, y) unless last_estimator.nil?
last_estimator&.fit(trans_x, y)
self
end
@ -171,7 +171,7 @@ module SVMKit
end
estimator = steps[steps.keys.last]
unless estimator.nil? || estimator.class.method_defined?(:fit)
unless estimator.nil? || estimator.class.method_defined?(:fit) # rubocop:disable Style/GuardClause
raise TypeError,
'Class of last step in pipeline should be implemented fit method: ' \
"#{steps.keys.last} => #{estimator.class}"

6
lib/svmkit/polynomial_model/base_factorization_machine.rb → lib/rumale/polynomial_model/base_factorization_machine.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/optimizer/nadam'
require 'rumale/base/base_estimator'
require 'rumale/optimizer/nadam'
module SVMKit
module Rumale
# This module consists of the classes that implement polynomial models.
module PolynomialModel
# BaseFactorizationMachine is an abstract class for implementation of Factorization Machine-based estimators.

8
lib/svmkit/polynomial_model/factorization_machine_classifier.rb → lib/rumale/polynomial_model/factorization_machine_classifier.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/base/classifier'
require 'svmkit/polynomial_model/base_factorization_machine'
require 'rumale/base/classifier'
require 'rumale/polynomial_model/base_factorization_machine'
module SVMKit
module Rumale
# This module consists of the classes that implement polynomial models.
module PolynomialModel
# FactorizationMachineClassifier is a class that implements Factorization Machine
@ -12,7 +12,7 @@ module SVMKit
#
# @example
# estimator =
# SVMKit::PolynomialModel::FactorizationMachineClassifier.new(
# Rumale::PolynomialModel::FactorizationMachineClassifier.new(
# n_factors: 10, loss: 'hinge', reg_param_linear: 0.001, reg_param_factor: 0.001,
# max_iter: 5000, batch_size: 50, random_seed: 1)
# estimator.fit(training_samples, traininig_labels)

8
lib/svmkit/polynomial_model/factorization_machine_regressor.rb → lib/rumale/polynomial_model/factorization_machine_regressor.rb
View File

@ -1,16 +1,16 @@
# frozen_string_literal: true
require 'svmkit/base/regressor'
require 'svmkit/polynomial_model/base_factorization_machine'
require 'rumale/base/regressor'
require 'rumale/polynomial_model/base_factorization_machine'
module SVMKit
module Rumale
module PolynomialModel
# FactorizationMachineRegressor is a class that implements Factorization Machine
# with stochastic gradient descent (SGD) optimization.
#
# @example
# estimator =
# SVMKit::PolynomialModel::FactorizationMachineRegressor.new(
# Rumale::PolynomialModel::FactorizationMachineRegressor.new(
# n_factors: 10, reg_param_linear: 0.1, reg_param_factor: 0.1,
# max_iter: 5000, batch_size: 50, random_seed: 1)
# estimator.fit(training_samples, traininig_values)

8
lib/svmkit/preprocessing/l2_normalizer.rb → lib/rumale/preprocessing/l2_normalizer.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
# This module consists of the classes that perform preprocessings.
module Preprocessing
# Normalize samples to unit L2-norm.
#
# @example
# normalizer = SVMKit::Preprocessing::StandardScaler.new
# normalizer = Rumale::Preprocessing::StandardScaler.new
# new_samples = normalizer.fit_transform(samples)
class L2Normalizer
include Base::BaseEstimator

8
lib/svmkit/preprocessing/label_encoder.rb → lib/rumale/preprocessing/label_encoder.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
module Preprocessing
# Encode labels to values between 0 and n_classes - 1.
#
# @example
# encoder = SVMKit::Preprocessing::LabelEncoder.new
# encoder = Rumale::Preprocessing::LabelEncoder.new
# labels = Numo::Int32[1, 8, 8, 15, 0]
# encoded_labels = encoder.fit_transform(labels)
# # > pp encoded_labels

8
lib/svmkit/preprocessing/min_max_scaler.rb → lib/rumale/preprocessing/min_max_scaler.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
# This module consists of the classes that perform preprocessings.
module Preprocessing
# Normalize samples by scaling each feature to a given range.
#
# @example
# normalizer = SVMKit::Preprocessing::MinMaxScaler.new(feature_range: [0.0, 1.0])
# normalizer = Rumale::Preprocessing::MinMaxScaler.new(feature_range: [0.0, 1.0])
# new_training_samples = normalizer.fit_transform(training_samples)
# new_testing_samples = normalizer.transform(testing_samples)
class MinMaxScaler

8
lib/svmkit/preprocessing/one_hot_encoder.rb → lib/rumale/preprocessing/one_hot_encoder.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
module Preprocessing
# Encode categorical integer features to one-hot-vectors.
#
# @example
# encoder = SVMKit::Preprocessing::OneHotEncoder.new
# encoder = Rumale::Preprocessing::OneHotEncoder.new
# labels = Numo::Int32[0, 0, 2, 3, 2, 1]
# one_hot_vectors = encoder.fit_transform(labels)
# # > pp one_hot_vectors

8
lib/svmkit/preprocessing/standard_scaler.rb → lib/rumale/preprocessing/standard_scaler.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/base/transformer'
require 'rumale/base/base_estimator'
require 'rumale/base/transformer'
module SVMKit
module Rumale
# This module consists of the classes that perform preprocessings.
module Preprocessing
# Normalize samples by centering and scaling to unit variance.
#
# @example
# normalizer = SVMKit::Preprocessing::StandardScaler.new
# normalizer = Rumale::Preprocessing::StandardScaler.new
# new_training_samples = normalizer.fit_transform(training_samples)
# new_testing_samples = normalizer.transform(testing_samples)
class StandardScaler

14
lib/svmkit/probabilistic_output.rb → lib/rumale/probabilistic_output.rb
View File

@ -1,14 +1,14 @@
# frozen_string_literal: true
module SVMKit
module Rumale
# Module for calculating posterior class probabilities with SVM outputs.
# This module is used for internal processes.
#
# @example
# estimator = SVMKit::LinearModel::SVC.new
# estimator = Rumale::LinearModel::SVC.new
# estimator.fit(x, bin_y)
# df = estimator.decision_function(x)
# params = SVMKit::ProbabilisticOutput.fit_sigmoid(df, bin_y)
# params = Rumale::ProbabilisticOutput.fit_sigmoid(df, bin_y)
# probs = 1 / (Numo::NMath.exp(params[0] * df + params[1]) + 1)
#
# *Reference*
@ -74,8 +74,8 @@ module SVMKit
pos = fn.ge(0.0)
neg = fn.lt(0.0)
err = 0.0
err += (target_probs[pos] * fn[pos] + Numo::NMath.log(1 + Numo::NMath.exp(-fn[pos]))).sum if pos.count > 0
err += ((target_probs[neg] - 1) * fn[neg] + Numo::NMath.log(1 + Numo::NMath.exp(fn[neg]))).sum if neg.count > 0
err += (target_probs[pos] * fn[pos] + Numo::NMath.log(1 + Numo::NMath.exp(-fn[pos]))).sum if pos.count.positive?
err += ((target_probs[neg] - 1) * fn[neg] + Numo::NMath.log(1 + Numo::NMath.exp(fn[neg]))).sum if neg.count.positive?
err
end
@ -84,8 +84,8 @@ module SVMKit
pos = fn.ge(0.0)
neg = fn.lt(0.0)
probs = Numo::DFloat.zeros(df.shape[0])
probs[pos] = Numo::NMath.exp(-fn[pos]) / (1 + Numo::NMath.exp(-fn[pos])) if pos.count > 0
probs[neg] = 1 / (1 + Numo::NMath.exp(fn[neg])) if neg.count > 0
probs[pos] = Numo::NMath.exp(-fn[pos]) / (1 + Numo::NMath.exp(-fn[pos])) if pos.count.positive?
probs[neg] = 1 / (1 + Numo::NMath.exp(fn[neg])) if neg.count.positive?
probs
end

6
lib/svmkit/tree/base_decision_tree.rb → lib/rumale/tree/base_decision_tree.rb
View File

@ -1,9 +1,9 @@
# frozen_string_literal: true
require 'svmkit/base/base_estimator'
require 'svmkit/tree/node'
require 'rumale/base/base_estimator'
require 'rumale/tree/node'
module SVMKit
module Rumale
# This module consists of the classes that implement tree models.
module Tree
# BaseDecisionTree is an abstract class for implementation of decision tree-based estimator.

8
lib/svmkit/tree/decision_tree_classifier.rb → lib/rumale/tree/decision_tree_classifier.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/tree/base_decision_tree'
require 'svmkit/base/classifier'
require 'rumale/tree/base_decision_tree'
require 'rumale/base/classifier'
module SVMKit
module Rumale
module Tree
# DecisionTreeClassifier is a class that implements decision tree for classification.
#
# @example
# estimator =
# SVMKit::Tree::DecisionTreeClassifier.new(
# Rumale::Tree::DecisionTreeClassifier.new(
# criterion: 'gini', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
# estimator.fit(training_samples, traininig_labels)
# results = estimator.predict(testing_samples)

8
lib/svmkit/tree/decision_tree_regressor.rb → lib/rumale/tree/decision_tree_regressor.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
require 'svmkit/tree/base_decision_tree'
require 'svmkit/base/regressor'
require 'rumale/tree/base_decision_tree'
require 'rumale/base/regressor'
module SVMKit
module Rumale
module Tree
# DecisionTreeRegressor is a class that implements decision tree for regression.
#
# @example
# estimator =
# SVMKit::Tree::DecisionTreeRegressor.new(
# Rumale::Tree::DecisionTreeRegressor.new(
# max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
# estimator.fit(training_samples, traininig_values)
# results = estimator.predict(testing_samples)

2
lib/svmkit/tree/node.rb → lib/rumale/tree/node.rb
View File

@ -1,6 +1,6 @@
# frozen_string_literal: true
module SVMKit
module Rumale
module Tree
# Node is a class that implements node used for construction of decision tree.
# This class is used for internal data structures.

2
lib/svmkit/utils.rb → lib/rumale/utils.rb
View File

@ -1,6 +1,6 @@
# frozen_string_literal: true
module SVMKit
module Rumale
# @!visibility private
module Utils
module_function

4
lib/svmkit/validation.rb → lib/rumale/validation.rb
View File

@ -1,6 +1,6 @@
# frozen_string_literal: true
module SVMKit
module Rumale
# @!visibility private
module Validation
module_function
@ -72,7 +72,7 @@ module SVMKit
# @!visibility private
def check_params_positive(params = {})
params.reject { |_, v| v.nil? }.each { |k, v| raise ArgumentError, "Expect #{k} to be positive value" if v < 0 }
params.reject { |_, v| v.nil? }.each { |k, v| raise ArgumentError, "Expect #{k} to be positive value" if v.negative? }
nil
end
end

2
lib/svmkit/values.rb → lib/rumale/values.rb
View File

@ -1,6 +1,6 @@
# frozen_string_literal: true
module SVMKit
module Rumale
# @!visibility private
module Values
module_function

6
lib/rumale/version.rb Normal file
View File

@ -0,0 +1,6 @@
# frozen_string_literal: true
# Rumale is a machine learning library in Ruby.
module Rumale
VERSION = '0.8.0'
end

70
lib/svmkit.rb
View File

@ -1,70 +0,0 @@
# frozen_string_literal: true
require 'numo/narray'
require 'svmkit/version'
require 'svmkit/validation'
require 'svmkit/values'
require 'svmkit/utils'
require 'svmkit/pairwise_metric'
require 'svmkit/dataset'
require 'svmkit/probabilistic_output'
require 'svmkit/base/base_estimator'
require 'svmkit/base/classifier'
require 'svmkit/base/regressor'
require 'svmkit/base/cluster_analyzer'
require 'svmkit/base/transformer'
require 'svmkit/base/splitter'
require 'svmkit/base/evaluator'
require 'svmkit/optimizer/sgd'
require 'svmkit/optimizer/rmsprop'
require 'svmkit/optimizer/nadam'
require 'svmkit/optimizer/yellow_fin'
require 'svmkit/pipeline/pipeline'
require 'svmkit/kernel_approximation/rbf'
require 'svmkit/linear_model/base_linear_model'
require 'svmkit/linear_model/svc'
require 'svmkit/linear_model/svr'
require 'svmkit/linear_model/logistic_regression'
require 'svmkit/linear_model/linear_regression'
require 'svmkit/linear_model/ridge'
require 'svmkit/linear_model/lasso'
require 'svmkit/kernel_machine/kernel_svc'
require 'svmkit/polynomial_model/base_factorization_machine'
require 'svmkit/polynomial_model/factorization_machine_classifier'
require 'svmkit/polynomial_model/factorization_machine_regressor'
require 'svmkit/multiclass/one_vs_rest_classifier'
require 'svmkit/nearest_neighbors/k_neighbors_classifier'
require 'svmkit/nearest_neighbors/k_neighbors_regressor'
require 'svmkit/naive_bayes/naive_bayes'
require 'svmkit/tree/node'
require 'svmkit/tree/base_decision_tree'
require 'svmkit/tree/decision_tree_classifier'
require 'svmkit/tree/decision_tree_regressor'
require 'svmkit/ensemble/ada_boost_classifier'
require 'svmkit/ensemble/ada_boost_regressor'
require 'svmkit/ensemble/random_forest_classifier'
require 'svmkit/ensemble/random_forest_regressor'
require 'svmkit/clustering/k_means'
require 'svmkit/clustering/dbscan'
require 'svmkit/decomposition/pca'
require 'svmkit/decomposition/nmf'
require 'svmkit/preprocessing/l2_normalizer'
require 'svmkit/preprocessing/min_max_scaler'
require 'svmkit/preprocessing/standard_scaler'
require 'svmkit/preprocessing/label_encoder'
require 'svmkit/preprocessing/one_hot_encoder'
require 'svmkit/model_selection/k_fold'
require 'svmkit/model_selection/stratified_k_fold'
require 'svmkit/model_selection/cross_validation'
require 'svmkit/model_selection/grid_search_cv'
require 'svmkit/evaluation_measure/accuracy'
require 'svmkit/evaluation_measure/precision'
require 'svmkit/evaluation_measure/recall'
require 'svmkit/evaluation_measure/f_score'
require 'svmkit/evaluation_measure/log_loss'
require 'svmkit/evaluation_measure/r2_score'
require 'svmkit/evaluation_measure/mean_squared_error'
require 'svmkit/evaluation_measure/mean_absolute_error'
require 'svmkit/evaluation_measure/purity'
require 'svmkit/evaluation_measure/normalized_mutual_information'

7
lib/svmkit/version.rb
View File

@ -1,7 +0,0 @@
# frozen_string_literal: true
# SVMKit is a machine learning library in Ruby.
module SVMKit
# @!visibility private
VERSION = '0.8.0'.freeze
end

28
svmkit.gemspec → rumale.gemspec
View File

@ -1,34 +1,26 @@
lib = File.expand_path('lib', __dir__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'svmkit/version'
require 'rumale/version'
Gem::Specification.new do |spec|
spec.name = 'svmkit'
spec.version = SVMKit::VERSION
spec.name = 'rumale'
spec.version = Rumale::VERSION
spec.authors = ['yoshoku']
spec.email = ['yoshoku@outlook.com']
spec.summary = <<MSG
SVMKit is a machine learninig library in Ruby.
SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
Rumale is a machine learninig library in Ruby.
Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
MSG
spec.description = <<MSG
SVMKit is a machine learninig library in Ruby.
SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
SVMKit supports Linear / Kernel Support Vector Machine,
Rumale is a machine learninig library in Ruby.
Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
Rumale currently supports Linear / Kernel Support Vector Machine,
Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
Naive Bayes, Decision Tree, AdaBoost, Random Forest, K-nearest neighbor algorithm,
K-Means, DBSCAN, Principal Component Analysis, and Non-negative Matrix Factorization.
Note that the SVMKit has been deprecated and has been renamed to Rumale.
SVMKit will continue releasing for bugfix but will not add new features.
MSG
spec.post_install_message = <<MSG
*************************************************************************
Note that the SVMKit has been deprecated and has been renamed to Rumale.
Please see https://rubygems.org/gems/rumale
*************************************************************************
MSG
spec.homepage = 'https://github.com/yoshoku/svmkit'
spec.homepage = 'https://github.com/yoshoku/Rumale'
spec.license = 'BSD-2-Clause'
spec.files = `git ls-files -z`.split("\x0").reject do |f|
@ -38,7 +30,7 @@ MSG
spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
spec.require_paths = ['lib']
spec.required_ruby_version = '>= 2.1'
spec.required_ruby_version = '>= 2.3'
spec.add_runtime_dependency 'numo-narray', '>= 0.9.1'

4
spec/base/classifier_spec.rb
View File

@ -2,10 +2,10 @@
require 'spec_helper'
RSpec.describe SVMKit::Base::Classifier do
RSpec.describe Rumale::Base::Classifier do
let(:dummy_class) do
class Dummy
include SVMKit::Base::Classifier
include Rumale::Base::Classifier
end
Dummy.new
end

4
spec/base/cluster_analyzer_spec.rb
View File

@ -2,10 +2,10 @@
require 'spec_helper'
RSpec.describe SVMKit::Base::ClusterAnalyzer do
RSpec.describe Rumale::Base::ClusterAnalyzer do
let(:dummy_class) do
class Dummy
include SVMKit::Base::ClusterAnalyzer
include Rumale::Base::ClusterAnalyzer
end
Dummy.new
end

4
spec/base/evaluator_spec.rb
View File

@ -2,10 +2,10 @@
require 'spec_helper'
RSpec.describe SVMKit::Base::Evaluator do
RSpec.describe Rumale::Base::Evaluator do
let(:dummy_class) do
class Dummy
include SVMKit::Base::Evaluator
include Rumale::Base::Evaluator
end
Dummy.new
end

4
spec/base/regressor_spec.rb
View File

@ -2,10 +2,10 @@
require 'spec_helper'
RSpec.describe SVMKit::Base::Regressor do
RSpec.describe Rumale::Base::Regressor do
let(:dummy_class) do
class Dummy
include SVMKit::Base::Regressor
include Rumale::Base::Regressor
end
Dummy.new
end

4
spec/base/splitter_spec.rb
View File

@ -2,10 +2,10 @@
require 'spec_helper'
RSpec.describe SVMKit::Base::Splitter do
RSpec.describe Rumale::Base::Splitter do
let(:dummy_class) do
class Dummy
include SVMKit::Base::Splitter
include Rumale::Base::Splitter
end
Dummy.new
end

4
spec/base/transformer_spec.rb
View File

@ -2,10 +2,10 @@
require 'spec_helper'
RSpec.describe SVMKit::Base::Transformer do
RSpec.describe Rumale::Base::Transformer do
let(:dummy_class) do
class Dummy
include SVMKit::Base::Transformer
include Rumale::Base::Transformer
end
Dummy.new
end

2
spec/clustering/dbscan_spec.rb
View File

@ -3,7 +3,7 @@
require 'pp'
require 'spec_helper'
RSpec.describe SVMKit::Clustering::DBSCAN do
RSpec.describe Rumale::Clustering::DBSCAN do
let(:x_mlt) { Marshal.load(File.read(__dir__ + '/../test_samples_three_clusters.dat')) }
let(:y_mlt) { Marshal.load(File.read(__dir__ + '/../test_labels_three_clusters.dat')) - 1 }
let(:analyzer) { described_class.new(eps: 1.0) }

2
spec/clustering/k_means_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::Clustering::KMeans do
RSpec.describe Rumale::Clustering::KMeans do
let(:x_mlt) { Marshal.load(File.read(__dir__ + '/../test_samples_three_clusters.dat')) }
let(:y_mlt) { Marshal.load(File.read(__dir__ + '/../test_labels_three_clusters.dat')) - 1 }
let(:analyzer) { described_class.new(n_clusters: 3, max_iter: 50, random_seed: 1) }

2
spec/datasets_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::Dataset do
RSpec.describe Rumale::Dataset do
let(:labels) { Numo::Int32.asarray([1, 2, 2, 1, 1, 0]) }
let(:target_variables) { Numo::DFloat.asarray([1.2, 2.0, 2.3, 1.0, 1.1, 0.64]) }
let(:mult_target_vals) { Numo::DFloat.asarray([[1.2, 2.0], [2.3, 1.0], [1.1, 0.64], [2.1, 1.9], [0.0, 1.7], [8.7, 4.1]]) }

6
spec/decomposition/nmf_spec.rb
View File

@ -2,15 +2,15 @@
require 'spec_helper'
RSpec.describe SVMKit::Decomposition::NMF do
RSpec.describe Rumale::Decomposition::NMF do
let(:n_samples) { 200 }
let(:n_features) { 6 }
let(:n_components) { 3 }
let(:decomposer) { described_class.new(n_components: n_components, max_iter: 10000, tol: 1.0e-4, random_seed: 1) }
let(:x) do
rng = Random.new(1)
a = SVMKit::Utils.rand_uniform([n_samples, n_components], rng)
b = SVMKit::Utils.rand_uniform([n_components, n_features], rng)
a = Rumale::Utils.rand_uniform([n_samples, n_components], rng)
b = Rumale::Utils.rand_uniform([n_components, n_features], rng)
a.dot(b)
end

4
spec/decomposition/pca_spec.rb
View File

@ -2,11 +2,11 @@
require 'spec_helper'
RSpec.describe SVMKit::Decomposition::PCA do
RSpec.describe Rumale::Decomposition::PCA do
let(:x) { Marshal.load(File.read(__dir__ + '/../test_samples.dat')) }
let(:n_components) { 16 }
let(:decomposer) { described_class.new(n_components: n_components, tol: 1.0e-8, random_seed: 1) }
let(:transformer) { SVMKit::KernelApproximation::RBF.new(gamma: 1.0, n_components: 32, random_seed: 1) }
let(:transformer) { Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_components: 32, random_seed: 1) }
it 'projects high-dimensinal data into subspace.' do
samples = transformer.fit_transform(x)

6
spec/ensemble/ada_boost_classifier_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::Ensemble::AdaBoostClassifier do
RSpec.describe Rumale::Ensemble::AdaBoostClassifier do
let(:x_bin) { Marshal.load(File.read(__dir__ + '/../test_samples.dat')) }
let(:y_bin) { Marshal.load(File.read(__dir__ + '/../test_labels.dat')) }
let(:x_mlt) { Marshal.load(File.read(__dir__ + '/../test_samples_three_clusters.dat')) }
@ -13,7 +13,7 @@ RSpec.describe SVMKit::Ensemble::AdaBoostClassifier do
_n_samples, n_features = x_bin.shape
estimator.fit(x_bin, y_bin)
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeClassifier)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeClassifier)
expect(estimator.classes.class).to eq(Numo::Int32)
expect(estimator.classes.size).to eq(2)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)
@ -26,7 +26,7 @@ RSpec.describe SVMKit::Ensemble::AdaBoostClassifier do
_n_samples, n_features = x_mlt.shape
estimator.fit(x_mlt, y_mlt)
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeClassifier)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeClassifier)
expect(estimator.classes.class).to eq(Numo::Int32)
expect(estimator.classes.size).to eq(3)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)

4
spec/ensemble/ada_boost_regressor_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::Ensemble::AdaBoostRegressor do
RSpec.describe Rumale::Ensemble::AdaBoostRegressor do
let(:x) { Marshal.load(File.read(__dir__ + '/../test_samples.dat')) }
let(:y) { x[true, 0] + x[true, 1]**2 }
let(:y_mult) { Numo::DFloat[x[true, 0].to_a, (x[true, 1]**2).to_a].transpose.dot(Numo::DFloat[[0.6, 0.4], [0.0, 0.1]]) }
@ -15,7 +15,7 @@ RSpec.describe SVMKit::Ensemble::AdaBoostRegressor do
estimator.fit(x, y)
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeRegressor)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeRegressor)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)
expect(estimator.feature_importances.shape[0]).to eq(n_features)
expect(estimator.feature_importances.shape[1]).to be_nil

6
spec/ensemble/random_forest_classifier_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::Ensemble::RandomForestClassifier do
RSpec.describe Rumale::Ensemble::RandomForestClassifier do
let(:x_bin) { Marshal.load(File.read(__dir__ + '/../test_samples.dat')) }
let(:y_bin) { Marshal.load(File.read(__dir__ + '/../test_labels.dat')) }
let(:x_mlt) { Marshal.load(File.read(__dir__ + '/../test_samples_three_clusters.dat')) }
@ -18,7 +18,7 @@ RSpec.describe SVMKit::Ensemble::RandomForestClassifier do
expect(estimator.params[:max_features]).to eq(2)
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators.size).to eq(n_estimators)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeClassifier)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeClassifier)
expect(estimator.classes.class).to eq(Numo::Int32)
expect(estimator.classes.size).to eq(2)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)
@ -32,7 +32,7 @@ RSpec.describe SVMKit::Ensemble::RandomForestClassifier do
estimator.fit(x_mlt, y_mlt)
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators.size).to eq(n_estimators)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeClassifier)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeClassifier)
expect(estimator.classes.class).to eq(Numo::Int32)
expect(estimator.classes.size).to eq(3)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)

6
spec/ensemble/random_forest_regressor_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::Ensemble::RandomForestRegressor do
RSpec.describe Rumale::Ensemble::RandomForestRegressor do
let(:x) { Marshal.load(File.read(__dir__ + '/../test_samples.dat')) }
let(:y) { x[true, 0] + x[true, 1]**2 }
let(:y_mult) { Numo::DFloat[x[true, 0].to_a, (x[true, 1]**2).to_a].transpose.dot(Numo::DFloat[[0.6, 0.4], [0.0, 0.1]]) }
@ -19,7 +19,7 @@ RSpec.describe SVMKit::Ensemble::RandomForestRegressor do
expect(estimator.params[:max_features]).to eq(2)
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators.size).to eq(n_estimators)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeRegressor)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeRegressor)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)
expect(estimator.feature_importances.shape[0]).to eq(n_features)
expect(estimator.feature_importances.shape[1]).to be_nil
@ -39,7 +39,7 @@ RSpec.describe SVMKit::Ensemble::RandomForestRegressor do
expect(estimator.estimators.class).to eq(Array)
expect(estimator.estimators.size).to eq(n_estimators)
expect(estimator.estimators[0].class).to eq(SVMKit::Tree::DecisionTreeRegressor)
expect(estimator.estimators[0].class).to eq(Rumale::Tree::DecisionTreeRegressor)
expect(estimator.feature_importances.class).to eq(Numo::DFloat)
expect(estimator.feature_importances.shape[0]).to eq(n_features)
expect(estimator.feature_importances.shape[1]).to be_nil

2
spec/evaluation_measure/accuracy_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::EvaluationMeasure::Accuracy do
RSpec.describe Rumale::EvaluationMeasure::Accuracy do
let(:bin_ground_truth) { Numo::Int32[1, 1, 1, 1, 1, -1, -1, -1, -1, -1] }
let(:bin_predicted) { Numo::Int32[-1, -1, 1, 1, 1, -1, -1, 1, 1, 1] }
let(:mult_ground_truth) { Numo::Int32[1, 1, 2, 2, 3, 3, 0, 0, 4, 4] }

2
spec/evaluation_measure/f_score_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::EvaluationMeasure::FScore do
RSpec.describe Rumale::EvaluationMeasure::FScore do
let(:bin_ground_truth) { Numo::Int32[1, 1, 1, 1, -1, -1, -1, -1] }
let(:bin_predicted) { Numo::Int32[-1, -1, 1, 1, -1, -1, 1, 1] }
let(:mult_ground_truth) { Numo::Int32[0, 1, 2, 0, 1, 2, 3, 3, 0, 0] }

2
spec/evaluation_measure/log_loss_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::EvaluationMeasure::LogLoss do
RSpec.describe Rumale::EvaluationMeasure::LogLoss do
let(:bin_ground_truth) { Numo::Int32[1, 1, 1, 1, 1, -1, -1, -1, -1, -1] }
let(:bin_predicted) { Numo::DFloat[0.9, 0.8, 0.6, 0.6, 0.8, 0.1, 0.2, 0.4, 0.4, 0.2] }
let(:mult_ground_truth) { Numo::Int32[1, 0, 0, 2] }

2
spec/evaluation_measure/mean_absolute_error_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::EvaluationMeasure::MeanAbsoluteError do
RSpec.describe Rumale::EvaluationMeasure::MeanAbsoluteError do
let(:ground_truth) { Numo::DFloat[3.2, -0.2, 2.2, 6.8] }
let(:estimated) { Numo::DFloat[2.9, -0.1, 2.3, 7.2] }
let(:mult_ground_truth) { Numo::DFloat[[0.5, 1.9], [-0.7, 1.8], [7.9, -6.5]] }

2
spec/evaluation_measure/mean_squared_error_spec.rb
View File

@ -2,7 +2,7 @@
require 'spec_helper'
RSpec.describe SVMKit::EvaluationMeasure::MeanSquaredError do
RSpec.describe Rumale::EvaluationMeasure::MeanSquaredError do
let(:ground_truth) { Numo::DFloat[3.2, -0.2, 2.2, 6.8] }
let(:estimated) { Numo::DFloat[2.9, -0.1, 2.3, 7.2] }
let(:mult_ground_truth) { Numo::DFloat[[0.5, 1.9], [-0.7, 1.8], [7.9, -6.5]] }

Some files were not shown because too many files have changed in this diff Show More