rumale 0.18.6 → 0.18.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40d5504cf4463721f53a4202ed99ec3f015c571fbadf3a4a4c7e0ac6eb00c7a7
-  data.tar.gz: fae3bebad1e88aa166d9279e5f5a2de4ebbad5f79fd416fef68d33d4f66ba2c6
+  metadata.gz: 5e3069531e5acbdaab178769d20684a0fa260e29f6c39a645632b903fff8cce0
+  data.tar.gz: d39c7e61a20b1bce23ccbb9d809bb06f1babce101f509c78c6da2a64e95f180f
 SHA512:
-  metadata.gz: b9d32bc9bd5c5f37d27b06fcaa554c28f9a209debaaac4024c1c2a1f6fb367484ce760168f62a2d9e1ee24d9372ad9cccd1d36e7280f202734e5330105a995fa
-  data.tar.gz: c18470cb533df4f6315324942afc98b5c52f4b7f6246078f459987a3407b79ae60a42599f40bc6236d5adba3dc85799a091e0d7ae5e9a1a3fd9fc626206cbef2
+  metadata.gz: eb9077b26d63f153eefd4c68ea57083e12b6a465d06864da8b24a3f9d2aff907b8de350ade5c96e8e9ec28997424839b91ac884d787a7bff7c2a44d212addd81
+  data.tar.gz: 7d94c6d80e16ed405f87a7c777b4922863e42922a5b33046df4bc42d9daa5f5243ebb6c5492cb2d20120215cdce9a5c4b0ac3156012bf38cf91e7717b2c51c22

data/.rubocop.yml

@@ -3,7 +3,7 @@ require:
   - rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5
   DisplayCopNames: true
   DisplayStyleGuide: true
   Exclude:
@@ -70,14 +70,26 @@ Naming/MethodParameterName:
 Naming/ConstantName:
   Enabled: false
 
+Style/ExponentialNotation:
+  Enabled: true
+
 Style/FormatStringToken:
   Enabled: false
 
 Style/NumericLiterals:
   Enabled: false
 
+Style/SlicingWithRange:
+  Enabled: true
+
 Layout/EmptyLineAfterGuardClause:
-  Enabled: false
+  Enabled: true
+
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
 
 RSpec/MultipleExpectations:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.18.7
+- Fix to convert target_name to string array in [classification_report method](https://yoshoku.github.io/rumale/doc/Rumale/EvaluationMeasure.html#classification_report-class_method).
+- Refactor some codes with Rubocop.
+
 # 0.18.6
 - Fix some configuration files.
 - Update API documentation.

data/lib/rumale/base/base_estimator.rb

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

data/lib/rumale/clustering/dbscan.rb

@@ -54,6 +54,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         partial_fit(x)
         self
       end
@@ -66,6 +67,7 @@ module Rumale
       def fit_predict(x)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         partial_fit(x)
         labels
       end
@@ -80,6 +82,7 @@ module Rumale
         @labels = Numo::Int32.zeros(n_samples) - 2
         n_samples.times do |query_id|
           next if @labels[query_id] >= -1
+
           cluster_id += 1 if expand_cluster(metric_mat, query_id, cluster_id)
         end
         @core_sample_ids = Numo::Int32[*@core_sample_ids.flatten]
@@ -102,6 +105,7 @@ module Rumale
           while (m = target_ids.shift)
             neighbor_ids = region_query(metric_mat[m, true])
             next if neighbor_ids.size < @params[:min_samples]
+
             neighbor_ids.each do |n|
               target_ids.push(n) if @labels[n] < -1
               @labels[n] = cluster_id if @labels[n] <= -1

data/lib/rumale/clustering/gaussian_mixture.rb

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

data/lib/rumale/clustering/hdbscan.rb

@@ -55,6 +55,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         fit_predict(x)
         self
       end
@@ -67,6 +68,7 @@ module Rumale
       def fit_predict(x)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
         @labels = partial_fit(distance_mat)
       end

data/lib/rumale/clustering/k_means.rb

@@ -106,6 +106,7 @@ module Rumale
         rand_id = [*0...n_samples].sample(@params[:n_clusters], random: sub_rng)
         @cluster_centers = x[rand_id, true].dup
         return unless @params[:init] == 'k-means++'
+
         # k-means++ initialize
         (1...@params[:n_clusters]).each do |n|
           distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers[0...n, true])

data/lib/rumale/clustering/k_medoids.rb

@@ -64,6 +64,7 @@ module Rumale
       def fit(x, _not_used = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         # initialize some varibales.
         distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
         init_cluster_centers(distance_mat)
@@ -76,6 +77,7 @@ module Rumale
           end
           new_error = distance_mat[true, @medoid_ids].mean
           break if (error - new_error).abs <= @params[:tol]
+
           error = new_error
         end
         @cluster_centers = x[@medoid_ids, true].dup if @params[:metric] == 'euclidean'
@@ -93,6 +95,7 @@ module Rumale
         if @params[:metric] == 'precomputed' && distance_mat.shape[1] != @medoid_ids.size
           raise ArgumentError, 'Expect the size input matrix to be n_samples-by-n_clusters.'
         end
+
         assign_cluster(distance_mat)
       end
 
@@ -123,6 +126,7 @@ module Rumale
         sub_rng = @rng.dup
         @medoid_ids = Numo::Int32.asarray([*0...n_samples].sample(@params[:n_clusters], random: sub_rng))
         return unless @params[:init] == 'k-means++'
+
         # k-means++ initialize
         (1...@params[:n_clusters]).each do |n|
           distances = distance_mat[true, @medoid_ids[0...n]]

data/lib/rumale/clustering/power_iteration.rb

@@ -71,6 +71,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input affinity matrix to be square.' if @params[:affinity] == 'precomputed' && x.shape[0] != x.shape[1]
+
         fit_predict(x)
         self
       end
@@ -107,6 +108,7 @@ module Rumale
           new_embedded_line /= new_embedded_line.abs.sum
           new_error = (new_embedded_line - embedded_line).abs
           break if (new_error - error).abs.max <= tol
+
           embedded_line = new_embedded_line
           error = new_error
         end

data/lib/rumale/clustering/single_linkage.rb

@@ -54,6 +54,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         fit_predict(x)
         self
       end
@@ -66,6 +67,7 @@ module Rumale
       def fit_predict(x)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
         @labels = partial_fit(distance_mat)
       end

data/lib/rumale/dataset.rb

@@ -65,6 +65,7 @@ module Rumale
         Rumale::Validation.check_params_numeric_or_nil(noise: noise, random_seed: random_seed)
         raise ArgumentError, 'The number of samples must be more than 2.' if n_samples <= 1
         raise RangeError, 'The interval of factor is (0, 1).' if factor <= 0 || factor >= 1
+
         # initialize some variables.
         rs = random_seed
         rs ||= srand
@@ -101,6 +102,7 @@ module Rumale
         Rumale::Validation.check_params_boolean(shuffle: shuffle)
         Rumale::Validation.check_params_numeric_or_nil(noise: noise, random_seed: random_seed)
         raise ArgumentError, 'The number of samples must be more than 2.' if n_samples <= 1
+
         # initialize some variables.
         rs = random_seed
         rs ||= srand

data/lib/rumale/decomposition/factor_analysis.rb

@@ -90,9 +90,11 @@ module Rumale
           @components = (sqrt_noise_variance.diag.dot(u) * scaler).transpose.dup
           @noise_variance = Numo::DFloat.maximum(sample_vars - @components.transpose.dot(@components).diagonal, 1e-12)
           next if @params[:tol].nil?
+
           new_loglike = log_likelihood(cov_mat, @components, @noise_variance)
           @loglike.push(new_loglike)
           break if (old_loglike - new_loglike).abs <= @params[:tol]
+
           old_loglike = new_loglike
         end
 

data/lib/rumale/decomposition/pca.rb

@@ -87,6 +87,7 @@ module Rumale
             @params[:max_iter].times do
               updated = orthogonalize(covariance_mat.dot(comp_vec))
               break if (updated.dot(comp_vec) - 1).abs < @params[:tol]
+
               comp_vec = updated
             end
             @components = @components.nil? ? comp_vec : Numo::NArray.vstack([@components, comp_vec])

data/lib/rumale/ensemble/ada_boost_classifier.rb

@@ -105,6 +105,7 @@ module Rumale
           # Fit classfier.
           ids = Rumale::Utils.choice_ids(n_samples, observation_weights, sub_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],
@@ -120,12 +121,14 @@ module Rumale
           @estimators.push(tree)
           @feature_importances += tree.feature_importances
           break if error.zero?
+
           # Update observation weights.
           log_proba = Numo::NMath.log(proba)
           observation_weights *= Numo::NMath.exp(-1.0 * (n_classes - 1).fdiv(n_classes) * (y_codes * log_proba).sum(1))
           observation_weights = observation_weights.clip(1.0e-15, nil)
           sum_observation_weights = observation_weights.sum
           break if sum_observation_weights.zero?
+
           observation_weights /= sum_observation_weights
         end
         @feature_importances /= @feature_importances.sum

data/lib/rumale/ensemble/ada_boost_regressor.rb

@@ -93,6 +93,7 @@ module Rumale
         check_sample_tvalue_size(x, y)
         # Check target values
         raise ArgumentError, 'Expect target value vector to be 1-D arrray' unless y.shape.size == 1
+
         # Initialize some variables.
         n_samples, n_features = x.shape
         @params[:max_features] = n_features unless @params[:max_features].is_a?(Integer)
@@ -117,6 +118,7 @@ module Rumale
           abs_err = ((p - y) / y).abs
           err = observation_weights[abs_err.gt(@params[:threshold])].sum
           break if err <= 0.0
+
           # Calculate weight.
           beta = err**@params[:exponent]
           weight = Math.log(1.fdiv(beta))
@@ -131,6 +133,7 @@ module Rumale
           observation_weights = observation_weights.clip(1.0e-15, nil)
           sum_observation_weights = observation_weights.sum
           break if sum_observation_weights.zero?
+
           observation_weights /= sum_observation_weights
         end
         @estimator_weights = Numo::DFloat.asarray(@estimator_weights)

data/lib/rumale/evaluation_measure/function.rb

@@ -86,7 +86,8 @@ module Rumale
       weighted_recall = (Numo::DFloat.cast(recalls) * weights).sum
       weighted_fscore = (Numo::DFloat.cast(fscores) * weights).sum
       # output reults.
-      target_name ||= classes.map(&:to_s)
+      target_name ||= classes
+      target_name.map!(&:to_s)
       if output_hash
         res = {}
         target_name.each_with_index do |label, n|

data/lib/rumale/evaluation_measure/normalized_mutual_information.rb

@@ -28,8 +28,10 @@ module Rumale
         # calculate entropies.
         class_entropy = entropy(y_true)
         return 0.0 if class_entropy.zero?
+
         cluster_entropy = entropy(y_pred)
         return 0.0 if cluster_entropy.zero?
+
         # calculate mutual information.
         mi = MutualInformation.new
         mi.score(y_true, y_pred) / Math.sqrt(class_entropy * cluster_entropy)

data/lib/rumale/evaluation_measure/precision_recall.rb

@@ -14,6 +14,7 @@ module Rumale
         y_true.sort.to_a.uniq.map do |label|
           target_positions = y_pred.eq(label)
           next 0.0 if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_positives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           n_true_positives / (n_true_positives + n_false_positives)
@@ -25,6 +26,7 @@ module Rumale
         y_true.sort.to_a.uniq.map do |label|
           target_positions = y_true.eq(label)
           next 0.0 if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_negatives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           n_true_positives / (n_true_positives + n_false_negatives)
@@ -35,6 +37,7 @@ module Rumale
       def f_score_each_class(y_true, y_pred)
         precision_each_class(y_true, y_pred).zip(recall_each_class(y_true, y_pred)).map do |p, r|
           next 0.0 if p.zero? && r.zero?
+
           (2.0 * p * r) / (p + r)
         end
       end
@@ -44,6 +47,7 @@ module Rumale
         evaluated_values = y_true.sort.to_a.uniq.map do |label|
           target_positions = y_pred.eq(label)
           next [0.0, 0.0] if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_positives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           [n_true_positives, n_true_positives + n_false_positives]
@@ -57,6 +61,7 @@ module Rumale
         evaluated_values = y_true.sort.to_a.uniq.map do |label|
           target_positions = y_true.eq(label)
           next 0.0 if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_negatives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           [n_true_positives, n_true_positives + n_false_negatives]

data/lib/rumale/evaluation_measure/roc_auc.rb

@@ -64,6 +64,7 @@ module Rumale
         y_score = Numo::DFloat.cast(y_score) unless y_score.is_a?(Numo::DFloat)
         raise ArgumentError, 'Expect y_true to be 1-D arrray.' unless y_true.shape[1].nil?
         raise ArgumentError, 'Expect y_score to be 1-D arrray.' unless y_score.shape[1].nil?
+
         labels = y_true.to_a.uniq
         if pos_label.nil?
           raise ArgumentError, 'y_true must be binary labels or pos_label must be specified if y_true is multi-label' unless labels.size == 2
@@ -96,8 +97,10 @@ module Rumale
         y = Numo::NArray.asarray(y) unless y.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect x to be 1-D arrray.' unless x.shape[1].nil?
         raise ArgumentError, 'Expect y to be 1-D arrray.' unless y.shape[1].nil?
+
         n_samples = [x.shape[0], y.shape[0]].min
         raise ArgumentError, 'At least two points are required to calculate area under curve.' if n_samples < 2
+
         (0...n_samples).to_a.each_cons(2).map { |i, j| 0.5 * (x[i] - x[j]).abs * (y[i] + y[j]) }.reduce(&:+)
       end
 

data/lib/rumale/evaluation_measure/silhouette_score.rb

@@ -47,6 +47,7 @@ module Rumale
           cls_pos = y.eq(labels[n])
           sz_cluster = cls_pos.count
           next unless sz_cluster > 1
+
           cls_dist_mat = dist_mat[cls_pos, cls_pos].dup
           cls_dist_mat[cls_dist_mat.diag_indices] = 0.0
           intra_dists[cls_pos] = cls_dist_mat.sum(0) / (sz_cluster - 1)
@@ -57,6 +58,7 @@ module Rumale
           cls_pos = y.eq(labels[m])
           n_clusters.times do |n|
             next if m == n
+
             not_cls_pos = y.eq(labels[n])
             inter_dists[cls_pos] = Numo::DFloat.minimum(
               inter_dists[cls_pos], dist_mat[cls_pos, not_cls_pos].mean(1)

data/lib/rumale/feature_extraction/hash_vectorizer.rb

@@ -71,6 +71,7 @@ module Rumale
           f.each do |k, v|
             k = "#{k}#{separator}#{v}".to_sym if v.is_a?(String)
             next if @vocabulary.key?(k)
+
             @feature_names.push(k)
             @vocabulary[k] = @vocabulary.size
           end

data/lib/rumale/kernel_machine/kernel_ridge.rb

@@ -30,6 +30,7 @@ module Rumale
       def initialize(reg_param: 1.0)
         raise TypeError, 'Expect class of reg_param to be Float or Numo::DFloat' unless reg_param.is_a?(Float) || reg_param.is_a?(Numo::DFloat)
         raise ArgumentError, 'Expect reg_param array to be 1-D arrray' if reg_param.is_a?(Numo::DFloat) && reg_param.shape.size != 1
+
         @params = {}
         @params[:reg_param] = reg_param
         @weight_vec = nil
@@ -55,6 +56,7 @@ module Rumale
           @weight_vec = Numo::Linalg.solve(reg_kernel_mat, y, driver: 'sym')
         else
           raise ArgumentError, 'Expect y and reg_param to have the same number of elements.' unless y.shape[1] == @params[:reg_param].shape[0]
+
           n_outputs = y.shape[1]
           @weight_vec = Numo::DFloat.zeros(n_samples, n_outputs)
           n_outputs.times do |n|

data/lib/rumale/linear_model/base_linear_model.rb

@@ -68,6 +68,7 @@ module Rumale
           # Update weight.
           loss_gradient = calc_loss_gradient(sub_samples, sub_targets, weight)
           next if loss_gradient.ne(0.0).count.zero?
+
           weight = calc_new_weight(optimizer, sub_samples, weight, loss_gradient)
         end
         split_weight(weight)

data/lib/rumale/linear_model/linear_regression.rb

@@ -162,6 +162,7 @@ module Rumale
       def load_linalg?
         return false if defined?(Numo::Linalg).nil?
         return false if Numo::Linalg::VERSION < '0.1.4'
+
         true
       end
     end

data/lib/rumale/linear_model/ridge.rb

@@ -164,6 +164,7 @@ module Rumale
       def load_linalg?
         return false if defined?(Numo::Linalg).nil?
         return false if Numo::Linalg::VERSION < '0.1.4'
+
         true
       end
     end

data/lib/rumale/manifold/mds.rb

@@ -83,6 +83,7 @@ module Rumale
       def fit(x, _not_used = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         # initialize some varibales.
         n_samples = x.shape[0]
         hi_distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
@@ -142,6 +143,7 @@ module Rumale
       def terminate?(old_stress, new_stress)
         return false if @params[:tol].nil?
         return false if old_stress.nil?
+
         (old_stress - new_stress).abs <= @params[:tol]
       end
 

data/lib/rumale/manifold/tsne.rb

@@ -89,6 +89,7 @@ module Rumale
       def fit(x, _not_used = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         # initialize some varibales.
         @n_iter = 0
         distance_mat = @params[:metric] == 'precomputed' ? x**2 : Rumale::PairwiseMetric.squared_error(x)
@@ -99,6 +100,7 @@ module Rumale
         one_vec = Numo::DFloat.ones(x.shape[0]).expand_dims(1)
         @params[:max_iter].times do |t|
           break if terminate?(hi_prob_mat, lo_prob_mat)
+
           a = hi_prob_mat * lo_prob_mat
           b = lo_prob_mat * lo_prob_mat
           y = (b.dot(one_vec) * y + (a - b).dot(y)) / a.dot(one_vec)
@@ -170,6 +172,7 @@ module Rumale
           entropy, probs = gaussian_distributed_probability_vector(sample_id, distance_vec, beta)
           diff_entropy = entropy - init_entropy
           break if diff_entropy.abs <= 1e-5
+
           if diff_entropy.positive?
             betamin = beta
             if betamax == Float::MAX
@@ -211,6 +214,7 @@ module Rumale
 
       def terminate?(p, q)
         return false if @params[:tol].nil?
+
         cost(p, q) <= @params[:tol]
       end
     end

data/lib/rumale/metric_learning/neighbourhood_component_analysis.rb

@@ -126,6 +126,7 @@ module Rumale
           res = prm
           puts "[NeighbourhoodComponentAnalysis] The value of objective function after #{res[:n_iter]} epochs: #{x.shape[0] - res[:fnc]}" if @params[:verbose]
           break if (fold - res[:fnc]).abs <= @params[:tol] && (dold - res[:jcb]).abs <= @params[:tol]
+
           fold = res[:fnc]
           dold = res[:jcb]
         end

data/lib/rumale/model_selection/grid_search_cv.rb

@@ -156,6 +156,7 @@ module Rumale
 
       def valid_param_grid(grid)
         raise TypeError, 'Expect class of param_grid to be Hash or Array' unless grid.is_a?(Hash) || grid.is_a?(Array)
+
         grid = [grid] if grid.is_a?(Hash)
         grid.each do |h|
           raise TypeError, 'Expect class of elements in param_grid to be Hash' unless h.is_a?(Hash)

data/lib/rumale/nearest_neighbors/k_neighbors_classifier.rb

@@ -67,6 +67,7 @@ module Rumale
         y = check_convert_label_array(y)
         check_sample_label_size(x, y)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         @prototypes = if @params[:metric] == 'euclidean'
                         if @params[:algorithm] == 'vptree'
                           VPTree.new(x)

data/lib/rumale/nearest_neighbors/k_neighbors_regressor.rb

@@ -61,6 +61,7 @@ module Rumale
         y = check_convert_tvalue_array(y)
         check_sample_tvalue_size(x, y)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         @prototypes = if @params[:metric] == 'euclidean'
                         if @params[:algorithm] == 'vptree'
                           VPTree.new(x)
@@ -82,6 +83,7 @@ module Rumale
         if @params[:metric] == 'precomputed' && x.shape[1] != @values.shape[0]
           raise ArgumentError, 'Expect the size input matrix to be n_testing_samples-by-n_training_samples.'
         end
+
         # Initialize some variables.
         n_samples = x.shape[0]
         n_prototypes, n_outputs = @values.shape

data/lib/rumale/neural_network/base_mlp.rb

@@ -233,6 +233,7 @@ module Rumale
             # calc loss function
             loss, dout = loss_func.call(out, sub_y)
             break if loss < @params[:tol]
+
             # backward
             backward.call(dout)
           end

data/lib/rumale/pipeline/pipeline.rb

@@ -119,6 +119,7 @@ module Rumale
         @steps.keys.reverse_each do |name|
           transformer = @steps[name]
           next if transformer.nil?
+
           itrans_z = transformer.inverse_transform(itrans_z)
         end
         itrans_z
@@ -140,6 +141,7 @@ module Rumale
         steps.keys[0...-1].each do |name|
           transformer = steps[name]
           next if transformer.nil? || %i[fit transform].all? { |m| transformer.class.method_defined?(m) }
+
           raise TypeError,
                 'Class of intermediate step in pipeline should be implemented fit and transform methods: ' \
                 "#{name} => #{transformer.class}"
@@ -158,6 +160,7 @@ module Rumale
         @steps.keys[0...-1].each do |name|
           transformer = @steps[name]
           next if transformer.nil?
+
           transformer.fit(trans_x, y) if fit
           trans_x = transformer.transform(trans_x)
         end

data/lib/rumale/polynomial_model/base_factorization_machine.rb

@@ -75,6 +75,7 @@ module Rumale
             # Calculate gradients for loss function.
             loss_grad = loss_gradient(sub_x, ex_sub_x, sub_y, factor_mat, weight_vec)
             next if loss_grad.ne(0.0).count.zero?
+
             # Update each parameter.
             weight_vec = weight_optimizer.call(weight_vec, weight_gradient(loss_grad, ex_sub_x, weight_vec))
             @params[:n_factors].times do |n|

data/lib/rumale/preprocessing/one_hot_encoder.rb

@@ -51,6 +51,7 @@ module Rumale
       def fit(x, _y = nil)
         x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
         @n_values = x.max(0) + 1
         @feature_indices = Numo::Int32.hstack([[0], @n_values]).cumsum
         @active_features = encode(x, @feature_indices).sum(0).ne(0).where
@@ -67,6 +68,7 @@ module Rumale
         x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
         fit(x).transform(x)
       end
 
@@ -77,6 +79,7 @@ module Rumale
       def transform(x)
         x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
         codes = encode(x, @feature_indices)
         codes[true, @active_features].dup
       end

data/lib/rumale/preprocessing/ordinal_encoder.rb

@@ -51,6 +51,7 @@ module Rumale
       def fit(x, _y = nil)
         raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
         n_features = x.shape[1]
         @categories = Array.new(n_features) { |n| x[true, n].to_a.uniq.sort }
         self
@@ -65,6 +66,7 @@ module Rumale
       def fit_transform(x, _y = nil)
         raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
         fit(x).transform(x)
       end
 

data/lib/rumale/preprocessing/polynomial_features.rb

@@ -41,6 +41,7 @@ module Rumale
       def initialize(degree: 2)
         check_params_numeric(degree: degree)
         raise ArgumentError, 'Expect the value of degree parameter greater than or eqaul to 1.' if degree < 1
+
         @params = {}
         @params[:degree] = degree
         @n_output_features = nil

data/lib/rumale/probabilistic_output.rb

@@ -47,6 +47,7 @@ module Rumale
           hess_mat = hessian_matrix(probs, df, sigma)
           break if grad_vec.abs.lt(1e-5).count == 2
           break if (old_grad_vec - grad_vec).abs.sum < 1e-5
+
           old_grad_vec = grad_vec
           # Calculate Newton directions.
           dirs_vec = directions(grad_vec, hess_mat)
@@ -58,6 +59,7 @@ module Rumale
             new_beta = beta + stepsize * dirs_vec[1]
             new_err = error_function(target_probs, df, new_alpha, new_beta)
             next unless new_err < err + 0.0001 * stepsize * grad_dir
+
             alpha = new_alpha
             beta = new_beta
             err = new_err

data/lib/rumale/tree/base_decision_tree.rb

@@ -53,6 +53,7 @@ module Rumale
         return node.leaf_id if node.leaf
         return apply_at_node(node.left, sample) if node.right.nil?
         return apply_at_node(node.right, sample) if node.left.nil?
+
         if sample[node.feature_id] <= node.threshold
           apply_at_node(node.left, sample)
         else
@@ -138,6 +139,7 @@ module Rumale
       def eval_importance_at_node(node)
         return nil if node.leaf
         return nil if node.left.nil? || node.right.nil?
+
         gain = node.n_samples * node.impurity -
                node.left.n_samples * node.left.impurity -
                node.right.n_samples * node.right.impurity

data/lib/rumale/tree/decision_tree_classifier.rb

@@ -110,6 +110,7 @@ module Rumale
         return node.probs if node.leaf
         return predict_proba_at_node(node.left, sample) if node.right.nil?
         return predict_proba_at_node(node.right, sample) if node.left.nil?
+
         if sample[node.feature_id] <= node.threshold
           predict_proba_at_node(node.left, sample)
         else

data/lib/rumale/tree/gradient_tree_regressor.rb

@@ -123,6 +123,7 @@ module Rumale
         return node.leaf_id if node.leaf
         return apply_at_node(node.left, sample) if node.right.nil?
         return apply_at_node(node.right, sample) if node.left.nil?
+
         if sample[node.feature_id] <= node.threshold
           apply_at_node(node.left, sample)
         else

data/lib/rumale/utils.rb

@@ -13,6 +13,7 @@ module Rumale
         chosen = 0
         probs.each_with_index do |p, idx|
           break (chosen = idx) if target <= p
+
           target -= p
         end
         chosen

data/lib/rumale/validation.rb

@@ -9,6 +9,7 @@ module Rumale
     def check_convert_sample_array(x)
       x = Numo::DFloat.cast(x) unless x.is_a?(Numo::DFloat)
       raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.ndim == 2
+
       x
     end
 
@@ -16,6 +17,7 @@ module Rumale
     def check_convert_label_array(y)
       y = Numo::Int32.cast(y) unless y.is_a?(Numo::Int32)
       raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.ndim == 1
+
       y
     end
 
@@ -29,6 +31,7 @@ module Rumale
     def check_sample_array(x)
       raise TypeError, 'Expect class of sample matrix to be Numo::DFloat' unless x.is_a?(Numo::DFloat)
       raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.ndim == 2
+
       nil
     end
 
@@ -36,24 +39,28 @@ module Rumale
     def check_label_array(y)
       raise TypeError, 'Expect class of label vector to be Numo::Int32' unless y.is_a?(Numo::Int32)
       raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.ndim == 1
+
       nil
     end
 
     # @!visibility private
     def check_tvalue_array(y)
       raise TypeError, 'Expect class of target value vector to be Numo::DFloat' unless y.is_a?(Numo::DFloat)
+
       nil
     end
 
     # @!visibility private
     def check_sample_label_size(x, y)
       raise ArgumentError, 'Expect to have the same number of samples for sample matrix and label vector' unless x.shape[0] == y.shape[0]
+
       nil
     end
 
     # @!visibility private
     def check_sample_tvalue_size(x, y)
       raise ArgumentError, 'Expect to have the same number of samples for sample matrix and target value vector' unless x.shape[0] == y.shape[0]
+
       nil
     end
 

data/lib/rumale/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.18.6
+  version: 0.18.7
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-02 00:00:00.000000000 Z
+date: 2020-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray