modify code style

Author: kortirso

lib/learn_kit/knn.ex

@@ -27,8 +27,7 @@ defmodule LearnKit.Knn do
   @spec new() :: %Knn{data_set: []}
 
   def new do
-    []
-    |> Knn.new
+    Knn.new([])
   end
 
   @doc """

lib/learn_kit/knn/classify.ex

@@ -9,11 +9,11 @@ defmodule LearnKit.Knn.Classify do
     quote do
       defp prediction(data_set, options) do
         calc_distances_for_features(data_set, options)
-        |> sort_distances
+        |> sort_distances()
         |> select_closest_features(options)
         |> calc_feature_weights(options)
-        |> define_weight_of_labels
-        |> sort_result
+        |> accumulate_weight_of_labels([])
+        |> sort_result()
       end
 
       # select algorithm for prediction
@@ -25,45 +25,35 @@ defmodule LearnKit.Knn.Classify do
       end
 
       defp sort_distances(features) do
-        features
-        |> Enum.sort(&(elem(&1, 0) <= elem(&2, 0)))
+        Enum.sort(features, &(elem(&1, 0) <= elem(&2, 0)))
       end
 
       defp select_closest_features(features, options) do
-        features
-        |> Enum.take(Keyword.get(options, :k))
+        Enum.take(features, Keyword.get(options, :k))
       end
 
       defp calc_feature_weights(features, options) do
-        features
-        |> Enum.map(fn feature ->
-          feature
-          |> Tuple.append(calc_feature_weight(Keyword.get(options, :weight), elem(feature, 0)))
+        Enum.map(features, fn feature ->
+          Tuple.append(feature, calc_feature_weight(Keyword.get(options, :weight), elem(feature, 0)))
         end)
       end
 
-      defp define_weight_of_labels(features) do
-        features
-        |> accumulate_weight_of_labels([])
-      end
-
       defp sort_result(features) do
         features
         |> Enum.sort(&(elem(&1, 1) >= elem(&2, 1)))
-        |> List.first
+        |> List.first()
       end
 
       # brute algorithm for prediction
       defp brute_algorithm(data_set, options) do
         data_set
-        |> Keyword.keys
+        |> Keyword.keys()
         |> handle_features_in_label(data_set, Keyword.get(options, :feature))
-        |> List.flatten
+        |> List.flatten()
       end
 
       defp handle_features_in_label(keys, data_set, current_feature) do
-        keys
-        |> Enum.map(fn key ->
+        Enum.map(keys, fn key ->
           data_set
           |> Keyword.get(key)
           |> filter_features_by_size(current_feature)
@@ -72,25 +62,19 @@ defmodule LearnKit.Knn.Classify do
       end
 
       defp filter_features_by_size(features, current_feature) do
-        features
-        |> Enum.filter(fn feature ->
+        Enum.filter(features, fn feature ->
           length(feature) == length(current_feature)
         end)
       end
 
       defp calc_distances_in_label(features, current_feature, key) do
-        features
-        |> Enum.reduce([], fn feature, acc ->
-          distance = feature |> calc_distance_between_features(current_feature)
+        Enum.reduce(features, [], fn feature, acc ->
+          distance = calc_distance_between_points(0, feature, current_feature, 0, length(feature) - 1)
           if distance == 0, do: raise "Feature exists in train data set with label #{key}"
           acc = [{distance, key} | acc]
         end)
       end
 
-      defp calc_distance_between_features(feature_from_data_set, feature) do
-        calc_distance_between_points(0, feature_from_data_set, feature, 0, length(feature_from_data_set) - 1)
-      end
-
       defp calc_distance_between_points(acc, feature_from_data_set, feature, current_index, size) when current_index <= size do
         Enum.at(feature_from_data_set, current_index) - Enum.at(feature, current_index)
         |> :math.pow(2)
@@ -99,8 +83,7 @@ defmodule LearnKit.Knn.Classify do
       end
 
       defp calc_distance_between_points(acc, _, _, _, _) do
-        acc
-        |> :math.sqrt
+        :math.sqrt(acc)
       end
 
       defp calc_feature_weight(weight, distance) do

lib/learn_kit/math.ex

@@ -63,8 +63,7 @@ defmodule LearnKit.Math do
 
   def variance(list) when is_list(list) do
     list_mean = mean(list)
-    list
-    |> variance(list_mean)
+    variance(list, list_mean)
   end
 
   @doc """
@@ -81,7 +80,7 @@ defmodule LearnKit.Math do
   def variance(list, list_mean) when is_list(list) do
     list
     |> Enum.map(fn x -> :math.pow(list_mean - x, 2) end)
-    |> mean
+    |> mean()
   end
 
   @doc """
@@ -102,8 +101,8 @@ defmodule LearnKit.Math do
 
   def standard_deviation(list) when is_list(list) do
     list
-    |> variance
-    |> :math.sqrt
+    |> variance()
+    |> :math.sqrt()
   end
 
   @doc """
@@ -118,8 +117,7 @@ defmodule LearnKit.Math do
   @spec standard_deviation_from_variance(number) :: number
 
   def standard_deviation_from_variance(list_variance) do
-    list_variance
-    |> :math.sqrt
+    :math.sqrt(list_variance)
   end
 
   @doc """
@@ -157,8 +155,7 @@ defmodule LearnKit.Math do
   @spec scalar_multiply(integer, list) :: list
 
   def scalar_multiply(multiplicator, list) when is_list(list) do
-    list
-    |> Enum.map(fn x -> x * multiplicator end)
+    Enum.map(list, fn x -> x * multiplicator end)
   end
 
   @doc """
@@ -229,8 +226,8 @@ defmodule LearnKit.Math do
     mean_y = mean(y)
 
     divider = Enum.zip(x, y) |> Enum.reduce(0, fn {xi, yi}, acc -> acc + (xi - mean_x) * (yi - mean_y) end)
-    denom_x = x |> Enum.reduce(0, fn xi, acc -> acc + :math.pow(xi - mean_x, 2) end)
-    denom_y = y |> Enum.reduce(0, fn yi, acc -> acc + :math.pow(yi - mean_y, 2) end)
+    denom_x = Enum.reduce(x, 0, fn xi, acc -> acc + :math.pow(xi - mean_x, 2) end)
+    denom_y = Enum.reduce(y, 0, fn yi, acc -> acc + :math.pow(yi - mean_y, 2) end)
 
     divider / :math.sqrt(denom_x * denom_y)
   end

lib/learn_kit/naive_bayes/gaussian.ex

@@ -34,8 +34,7 @@ defmodule LearnKit.NaiveBayes.Gaussian do
   @spec new() :: %Gaussian{data_set: []}
 
   def new do
-    []
-    |> Gaussian.new
+    Gaussian.new([])
   end
 
   @doc """
@@ -122,7 +121,7 @@ defmodule LearnKit.NaiveBayes.Gaussian do
   @spec predict_proba(%Gaussian{fit_data: fit_data}, feature) :: {:ok, predictions}
 
   def predict_proba(%Gaussian{fit_data: fit_data}, feature) do
-    result = fit_data |> classify_data(feature)
+    result = classify_data(fit_data, feature)
     {:ok, result}
   end
 
@@ -162,7 +161,7 @@ defmodule LearnKit.NaiveBayes.Gaussian do
   @spec score(%Gaussian{data_set: data_set, fit_data: fit_data}) :: {:ok, number}
 
   def score(%Gaussian{data_set: data_set, fit_data: fit_data}) do
-    result = fit_data |> calc_score(data_set)
+    result = calc_score(fit_data, data_set)
     {:ok, result}
   end
 end

lib/learn_kit/naive_bayes/gaussian/classify.ex

@@ -7,7 +7,7 @@ defmodule LearnKit.NaiveBayes.Gaussian.Classify do
       # classify data
       # returns data like [label1: 0.03592747361085857, label2: 0.00399309643713954]
       defp classify_data(fit_data, feature) do
-        labels_count = fit_data |> Keyword.keys |> length
+        labels_count = fit_data |> Keyword.keys() |> length()
         fit_data
         |> Enum.map(fn {label, fit_results} ->
           {label, class_probability(labels_count, feature, fit_results)}

lib/learn_kit/naive_bayes/gaussian/fit.ex

@@ -8,18 +8,21 @@ defmodule LearnKit.NaiveBayes.Gaussian.Fit do
   defmacro __using__(_opts) do
     quote do
       defp fit_data(data_set) do
-        data_set
-        |> Enum.map(fn {key, value} ->
+        Enum.map(data_set, fn {key, value} ->
           {key, calc_features(value)}
         end)
       end
 
       defp calc_features(features) do
         features
-        |> Math.transpose
-        |> Enum.map(fn feature ->
-          mean = Math.mean(feature)
-          variance = Math.variance(feature, mean)
+        |> Math.transpose()
+        |> calc_combination()
+      end
+
+      defp calc_combination(combinations) do
+        Enum.map(combinations, fn combination ->
+          mean = Math.mean(combination)
+          variance = Math.variance(combination, mean)
           standard_deviation = Math.standard_deviation_from_variance(variance)
           %{mean: mean, variance: variance, standard_deviation: standard_deviation}
         end)

lib/learn_kit/naive_bayes/gaussian/score.ex

@@ -11,19 +11,16 @@ defmodule LearnKit.NaiveBayes.Gaussian.Score do
       defp calc_score(fit_data, data_set) do
         data_set
         |> Enum.map(fn {label, features} ->
-          features
-          |> check_features(fit_data, label)
+          check_features(features, fit_data, label)
         end)
-        |> List.flatten
-        |> Math.mean
+        |> List.flatten()
+        |> Math.mean()
         |> Float.ceil(6)
       end
 
       defp check_features(features, fit_data, label) do
-        features
-        |> Enum.map(fn feature ->
-          feature
-          |> check_feature(fit_data, label)
+        Enum.map(features, fn feature ->
+          check_feature(feature, fit_data, label)
         end)
       end
 

lib/learn_kit/regression/linear.ex

@@ -80,9 +80,10 @@ defmodule LearnKit.Regression.Linear do
   @spec fit(%Linear{factors: factors, results: results}) :: %Linear{factors: factors, results: results, coefficients: coefficients}
 
   def fit(%Linear{factors: factors, results: results}, options \\ []) do
-    coefficients = Keyword.merge([method: ""], options)
-                    |> define_method_for_fit
-                    |> fit_data(factors, results)
+    coefficients =
+      Keyword.merge([method: ""], options)
+      |> define_method_for_fit()
+      |> fit_data(factors, results)
     %Linear{factors: factors, results: results, coefficients: coefficients}
   end
 
@@ -110,7 +111,7 @@ defmodule LearnKit.Regression.Linear do
   @spec predict(%Linear{coefficients: coefficients}, list) :: {:ok, list}
 
   def predict(%Linear{coefficients: coefficients}, samples) do
-    result = samples |> Enum.map(fn sample -> predict_sample(sample, coefficients) end)
+    result = Enum.map(samples, fn sample -> predict_sample(sample, coefficients) end)
     {:ok, result}
   end
 

lib/learn_kit/regression/linear/calculations.ex

@@ -29,8 +29,7 @@ defmodule LearnKit.Regression.Linear.Calculations do
 
       defp total_sum_of_squares(list) do
         mean_list = Math.mean(list)
-        list
-        |> Enum.reduce(0, fn x, acc -> acc + :math.pow(x - mean_list, 2) end)
+        Enum.reduce(list, 0, fn x, acc -> acc + :math.pow(x - mean_list, 2) end)
       end
 
       defp sum_of_squared_errors(coefficients, factors, results) do
@@ -45,7 +44,7 @@ defmodule LearnKit.Regression.Linear.Calculations do
       end
 
       defp squared_error_gradient(coefficients, x, y) do
-        error_variable = coefficients |> prediction_error(x, y)
+        error_variable = prediction_error(coefficients, x, y)
         [
           -2 * error_variable,
           -2 * error_variable * x
@@ -64,22 +63,24 @@ defmodule LearnKit.Regression.Linear.Calculations do
           min_value,
           iterations_with_no_improvement,
           alpha
-        ] = data |> check_value(min_value, theta, min_theta, iterations_with_no_improvement, alpha)
-
-        theta = data
-                |> Enum.shuffle
-                |> Enum.reduce(theta, fn {xi, yi}, acc ->
-                  gradient_i = squared_error_gradient(acc, xi, yi)
-                  acc |> Math.vector_subtraction(alpha |> Math.scalar_multiply(gradient_i))
-                end)
+        ] = check_value(data, min_value, theta, min_theta, iterations_with_no_improvement, alpha)
+
+        theta =
+          data
+          |> Enum.shuffle()
+          |> Enum.reduce(theta, fn {xi, yi}, acc ->
+            gradient_i = squared_error_gradient(acc, xi, yi)
+            acc |> Math.vector_subtraction(alpha |> Math.scalar_multiply(gradient_i))
+          end)
         gradient_descent_iteration(theta, alpha, min_theta, min_value, data, iterations_with_no_improvement)
       end
 
       defp check_value(data, min_value, theta, min_theta, iterations_with_no_improvement, alpha) do
-        value = data |> Enum.reduce(0, fn {xi, yi}, acc -> acc + squared_prediction_error(theta, xi, yi) end)
+        value = Enum.reduce(data, 0, fn {xi, yi}, acc -> acc + squared_prediction_error(theta, xi, yi) end)
         cond do
           value < min_value ->
             [theta, value, 0, 0.0001]
+
           true ->
             [min_theta, min_value, iterations_with_no_improvement + 1, alpha * 0.9]
         end