code refactoring

Author: kortirso

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+### Modified
+- code refactoring
+
 ## [0.1.5] - 2018-12-18
 ### Added
 - preprocessing normalization for data set

lib/learn_kit/knn.ex

@@ -26,9 +26,7 @@ defmodule LearnKit.Knn do
   """
   @spec new() :: %Knn{data_set: []}
 
-  def new do
-    Knn.new([])
-  end
+  def new, do: Knn.new([])
 
   @doc """
   Creates classifier with data_set
@@ -45,9 +43,7 @@ defmodule LearnKit.Knn do
   """
   @spec new(data_set) :: %Knn{data_set: data_set}
 
-  def new(data_set) when is_list(data_set) do
-    %Knn{data_set: data_set}
-  end
+  def new(data_set) when is_list(data_set), do: %Knn{data_set: data_set}
 
   @doc """
   Add train data to classifier
@@ -66,7 +62,7 @@ defmodule LearnKit.Knn do
   @spec add_train_data(%Knn{data_set: data_set}, point) :: %Knn{data_set: data_set}
 
   def add_train_data(%Knn{data_set: data_set}, {key, value}) when is_atom(key) and is_list(value) do
-    features = if Keyword.has_key?(data_set, key), do: Keyword.get(data_set, key), else: []
+    features = if Keyword.has_key?(data_set, key), do: data_set[key], else: []
     data_set = Keyword.put(data_set, key, [value | features])
     %Knn{data_set: data_set}
   end
@@ -100,10 +96,10 @@ defmodule LearnKit.Knn do
       !Keyword.has_key?(options, :feature) ->
         {:error, "Feature option is required"}
 
-      !is_list(Keyword.get(options, :feature)) ->
+      !is_list(options[:feature]) ->
         {:error, "Feature option must be presented as array"}
 
-      Keyword.has_key?(options, :k) && (!is_integer(Keyword.get(options, :k)) || Keyword.get(options, :k) <= 0) ->
+      Keyword.has_key?(options, :k) && (!is_integer(options[:k]) || options[:k] <= 0) ->
         {:error, "K option must be positive integer"}
 
       true ->

lib/learn_kit/knn/classify.ex

@@ -9,7 +9,7 @@ defmodule LearnKit.Knn.Classify do
     quote do
       defp prediction(data_set, options) do
         data_set
-        |> filter_features_by_size(Keyword.get(options, :feature))
+        |> filter_features_by_size(options[:feature])
         |> check_normalization(options)
         |> calc_distances_for_features(options)
         |> sort_distances()
@@ -29,7 +29,7 @@ defmodule LearnKit.Knn.Classify do
 
       # normalize features
       defp check_normalization(data_set, options) do
-        type = Keyword.get(options, :normalization)
+        type = options[:normalization]
         case type do
           t when t in ["minimax", "z_normalization"] -> normalize(data_set, type)
           _ -> data_set
@@ -38,7 +38,7 @@ defmodule LearnKit.Knn.Classify do
 
       # select algorithm for prediction
       defp calc_distances_for_features(data_set, options) do
-        case Keyword.get(options, :algorithm) do
+        case options[:algorithm] do
           "brute" -> brute_algorithm(data_set, options)
           _ -> []
         end
@@ -51,7 +51,7 @@ defmodule LearnKit.Knn.Classify do
 
       # take closest features
       defp select_closest_features(features, options) do
-        Enum.take(features, Keyword.get(options, :k))
+        Enum.take(features, options[:k])
       end
 
       # check existeness of current feature in data set
@@ -92,7 +92,7 @@ defmodule LearnKit.Knn.Classify do
 
       defp calc_feature_weights(features, options) do
         Enum.map(features, fn feature ->
-          Tuple.append(feature, calc_feature_weight(Keyword.get(options, :weight), elem(feature, 0)))
+          Tuple.append(feature, calc_feature_weight(options[:weight], elem(feature, 0)))
         end)
       end
 
@@ -106,14 +106,13 @@ defmodule LearnKit.Knn.Classify do
       defp brute_algorithm(data_set, options) do
         data_set
         |> Keyword.keys()
-        |> handle_features_in_label(data_set, Keyword.get(options, :feature))
+        |> handle_features_in_label(data_set, options[:feature])
         |> List.flatten()
       end
 
       defp handle_features_in_label(keys, data_set, current_feature) do
         Enum.map(keys, fn key ->
-          data_set
-          |> Keyword.get(key)
+          data_set[key]
           |> calc_distances_in_label(current_feature, key)
         end)
       end
@@ -152,7 +151,7 @@ defmodule LearnKit.Knn.Classify do
       end
 
       defp accumulate_weight_of_labels([{_, key, weight} | tail], acc) do
-        previous = if Keyword.has_key?(acc, key), do: Keyword.get(acc, key), else: 0
+        previous = if Keyword.has_key?(acc, key), do: acc[key], else: 0
         acc = Keyword.put(acc, key, previous + weight)
         accumulate_weight_of_labels(tail, acc)
       end

lib/learn_kit/math.ex

@@ -17,9 +17,20 @@ defmodule LearnKit.Math do
   """
   @spec summ(number, number) :: number
 
-  def summ(a, b) do
-    a + b
-  end
+  def summ(a, b), do: a + b
+
+  @doc """
+  Division for 2 elements
+
+  ## Examples
+
+      iex> LearnKit.Math.division(10, 2)
+      5.0
+
+  """
+  @spec division(number, number) :: number
+
+  def division(x, y) when y != 0, do: x / y
 
   @doc """
   Calculate the mean from a list of numbers
@@ -35,14 +46,14 @@ defmodule LearnKit.Math do
   """
   @spec mean(list) :: number
 
-  def mean(list) when is_list(list), do: mean(list, 0, 0)
+  def mean(list) when is_list(list), do: do_mean(list, 0, 0)
 
-  defp mean([], 0, 0), do: nil
+  defp do_mean([], 0, 0), do: nil
 
-  defp mean([], sum, number), do: sum / number
+  defp do_mean([], sum, number), do: sum / number
 
-  defp mean([head | tail], sum, number) do
-    mean(tail, sum + head, number + 1)
+  defp do_mean([head | tail], sum, number) do
+    do_mean(tail, sum + head, number + 1)
   end
 
   @doc """
@@ -131,16 +142,14 @@ defmodule LearnKit.Math do
   """
   @spec transpose(matrix) :: matrix
 
-  def transpose(m) do
-    swap_rows_cols(m)
-  end
+  def transpose(m), do: do_transpose(m)
 
-  defp swap_rows_cols([head | _]) when head == [], do: []
+  defp do_transpose([head | _]) when head == [], do: []
 
-  defp swap_rows_cols(rows) do
+  defp do_transpose(rows) do
     firsts = Enum.map(rows, fn x -> hd(x) end)
     others = Enum.map(rows, fn x -> tl(x) end)
-    [firsts | swap_rows_cols(others)]
+    [firsts | do_transpose(others)]
   end
 
   @doc """
@@ -169,26 +178,11 @@ defmodule LearnKit.Math do
   """
   @spec vector_subtraction(list, list) :: list
 
-  def vector_subtraction(x, y) when is_list(x) and is_list(y) and length(x) == length(y) do
+  def vector_subtraction(x, y) when length(x) == length(y) do
     Enum.zip(x, y)
     |> Enum.map(fn {xi, yi} -> xi - yi end)
   end
 
-  @doc """
-  Division for 2 elements
-
-  ## Examples
-
-      iex> LearnKit.Math.division(10, 2)
-      5.0
-
-  """
-  @spec division(number, number) :: number
-
-  def division(x, y) when y != 0 do
-    x / y
-  end
-
   @doc """
   Calculate the covariance of two lists
 

lib/learn_kit/preprocessing.ex

@@ -29,9 +29,7 @@ defmodule LearnKit.Preprocessing do
   """
   @spec normalize(matrix) :: matrix
 
-  def normalize(features) when is_list(features) do
-    normalize(features, [type: "minimax"])
-  end
+  def normalize(features) when is_list(features), do: normalize(features, [type: "minimax"])
 
   @doc """
   Normalize data set
@@ -59,7 +57,7 @@ defmodule LearnKit.Preprocessing do
 
   def normalize(features, options) when is_list(features) and is_list(options) do
     options = Keyword.merge([type: "minimax"], options)
-    case Keyword.get(options, :type) do
+    case options[:type] do
       "z_normalization" -> normalization(features, "z_normalization")
       _ -> normalization(features, "minimax")
     end

lib/learn_kit/regression/linear.ex

@@ -24,9 +24,7 @@ defmodule LearnKit.Regression.Linear do
   """
   @spec new() :: %Linear{factors: [], results: [], coefficients: []}
 
-  def new do
-    Linear.new([], [])
-  end
+  def new, do: Linear.new([], [])
 
   @doc """
   Creates predictor with data_set
@@ -44,9 +42,7 @@ defmodule LearnKit.Regression.Linear do
   """
   @spec new(factors, results) :: %Linear{factors: factors, results: results, coefficients: []}
 
-  def new(factors, results) do
-    %Linear{factors: factors, results: results}
-  end
+  def new(factors, results) when is_list(factors) and is_list(results), do: %Linear{factors: factors, results: results}
 
   @doc """
   Fit train data
@@ -79,16 +75,16 @@ 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
+  def fit(%Linear{factors: factors, results: results}, options \\ []) when is_list(options) do
     coefficients =
       Keyword.merge([method: ""], options)
       |> define_method_for_fit()
-      |> fit_data(factors, results)
+      |> do_fit(factors, results)
     %Linear{factors: factors, results: results, coefficients: coefficients}
   end
 
   defp define_method_for_fit(options) do
-    case Keyword.get(options, :method) do
+    case options[:method] do
       "gradient descent" -> "gradient descent"
       _ -> ""
     end
@@ -110,9 +106,11 @@ defmodule LearnKit.Regression.Linear do
   """
   @spec predict(%Linear{coefficients: coefficients}, list) :: {:ok, list}
 
-  def predict(%Linear{coefficients: coefficients}, samples) do
-    result = Enum.map(samples, fn sample -> predict_sample(sample, coefficients) end)
-    {:ok, result}
+  def predict(%Linear{coefficients: coefficients}, samples) when is_list(samples) do
+    {
+      :ok,
+      Enum.map(samples, fn sample -> predict_sample(sample, coefficients) end)
+    }
   end
 
   @doc """
@@ -131,6 +129,9 @@ defmodule LearnKit.Regression.Linear do
   @spec score(%Linear{factors: factors, results: results, coefficients: coefficients}) :: {:ok, number}
 
   def score(%Linear{factors: factors, results: results, coefficients: coefficients}) do
-    {:ok, calculate_score(coefficients, factors, results)}
+    {
+      :ok,
+      calculate_score(coefficients, factors, results)
+    }
   end
 end

lib/learn_kit/regression/linear/calculations.ex

@@ -7,11 +7,11 @@ defmodule LearnKit.Regression.Linear.Calculations do
 
   defmacro __using__(_opts) do
     quote do
-      defp fit_data(method, factors, results) when method == "gradient descent" do
+      defp do_fit(method, factors, results) when method == "gradient descent" do
         gradient_descent_iteration([:rand.uniform, :rand.uniform], 0.0001, nil, 1000000, Enum.zip(factors, results), 0)
       end
 
-      defp fit_data(_, factors, results) do
+      defp do_fit(_, factors, results) do
         beta = Math.correlation(factors, results) * Math.standard_deviation(results) / Math.standard_deviation(factors)
         alpha = Math.mean(results) - beta * Math.mean(factors)
         [alpha, beta]