modify tests

Author: kortirso

lib/learn_kit/knn.ex

@@ -97,9 +97,7 @@ defmodule LearnKit.Knn do
 
   def classify(%Knn{data_set: data_set}, options \\ []) do
     try do
-      unless Keyword.has_key?(options, :feature) do
-        raise "Feature option is required"
-      end
+      unless Keyword.has_key?(options, :feature), do: raise "Feature option is required"
       # modification of options
       options = Keyword.merge([k: 3, algorithm: "brute", weight: "uniform"], options)
       # prediction

lib/learn_kit/knn/classify.ex

@@ -2,6 +2,9 @@ defmodule LearnKit.Knn.Classify do
   @moduledoc """
   Module for knn classify functions
   """
+
+  alias LearnKit.Math
+
   defmacro __using__(_opts) do
     quote do
       defp prediction(data_set, options) do
@@ -34,7 +37,8 @@ defmodule LearnKit.Knn.Classify do
       defp calc_feature_weights(features, options) do
         features
         |> Enum.map(fn feature ->
-          Tuple.append(feature, calc_feature_weight(Keyword.get(options, :weight), elem(feature, 0)))
+          feature
+          |> Tuple.append(calc_feature_weight(Keyword.get(options, :weight), elem(feature, 0)))
         end)
       end
 
@@ -78,9 +82,7 @@ defmodule LearnKit.Knn.Classify do
         features
         |> Enum.reduce([], fn feature, acc ->
           distance = feature |> calc_distance_between_features(current_feature)
-          if distance == 0 do
-            raise "Feature exists in train data set with label #{key}"
-          end
+          if distance == 0, do: raise "Feature exists in train data set with label #{key}"
           acc = [{distance, key} | acc]
         end)
       end
@@ -92,19 +94,15 @@ defmodule LearnKit.Knn.Classify do
       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)
-        |> summ(acc)
+        |> Math.summ(acc)
         |> calc_distance_between_points(feature_from_data_set, feature, current_index + 1, size)
       end
 
-      defp calc_distance_between_points(acc, _feature_from_data_set, _feature, _current_index, _size) do
+      defp calc_distance_between_points(acc, _, _, _, _) do
         acc
         |> :math.sqrt
       end
 
-      defp summ(a, b) do
-        a + b
-      end
-
       defp calc_feature_weight(weight, distance) do
         case weight do
           "uniform" -> 1
@@ -117,7 +115,7 @@ defmodule LearnKit.Knn.Classify do
         acc
       end
 
-      defp accumulate_weight_of_labels([{_distance, key, weight} | tail], acc) do
+      defp accumulate_weight_of_labels([{_, key, weight} | tail], acc) do
         previous = if Keyword.has_key?(acc, key), do: Keyword.get(acc, key), else: 0
         acc = Keyword.put(acc, key, previous + weight)
         accumulate_weight_of_labels(tail, acc)

lib/learn_kit/math.ex

@@ -6,6 +6,21 @@ defmodule LearnKit.Math do
   @type row :: [number]
   @type matrix :: [row]
 
+  @doc """
+  Sum of 2 numbers
+
+  ## Examples
+
+      iex> LearnKit.Math.summ(1, 2)
+      3
+
+  """
+  @spec summ(number, number) :: number
+
+  def summ(a, b) do
+    a + b
+  end
+
   @doc """
   Calculate the mean from a list of numbers
 
@@ -125,8 +140,8 @@ defmodule LearnKit.Math do
   defp swap_rows_cols([head | _]) when head == [], do: []
 
   defp swap_rows_cols(rows) do
-    firsts = Enum.map(rows, fn(x) -> hd(x) end)
-    others = Enum.map(rows, fn(x) -> tl(x) end)
+    firsts = Enum.map(rows, fn x -> hd(x) end)
+    others = Enum.map(rows, fn x -> tl(x) end)
     [firsts | swap_rows_cols(others)]
   end
 
@@ -194,8 +209,7 @@ defmodule LearnKit.Math do
     size = length(x)
 
     Enum.zip(x, y)
-    |> Enum.map(fn {xi, yi} -> (xi - mean_x) * (yi - mean_y) end)
-    |> Enum.sum
+    |> Enum.reduce(0, fn {xi, yi}, acc -> acc + (xi - mean_x) * (yi - mean_y) end)
     |> division(size - 1)
   end
 
@@ -214,15 +228,9 @@ defmodule LearnKit.Math do
     mean_x = mean(x)
     mean_y = mean(y)
 
-    divider = Enum.zip(x, y)
-            |> Enum.map(fn {xi, yi} -> (xi - mean_x) * (yi - mean_y) end)
-            |> Enum.sum
-    denom_x = x
-              |> Enum.map(fn xi -> :math.pow(xi - mean_x, 2) end)
-              |> Enum.sum
-    denom_y = y
-              |> Enum.map(fn yi -> :math.pow(yi - mean_y, 2) end)
-              |> Enum.sum
+    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)
 
     divider / :math.sqrt(denom_x * denom_y)
   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 = length(Keyword.keys(fit_data))
+        labels_count = fit_data |> Keyword.keys |> length
         fit_data
         |> Enum.map(fn {label, fit_results} ->
           {label, class_probability(labels_count, feature, fit_results)}
@@ -23,7 +23,7 @@ defmodule LearnKit.NaiveBayes.Gaussian.Classify do
       end
 
       # multiply together the feature probabilities for all of the features in a label for given values
-      defp feature_mult([], _fit_results, acc, _index), do: acc
+      defp feature_mult([], _, acc, _), do: acc
 
       defp feature_mult([head | tail], fit_results, acc, index) do
         acc = acc * feature_probability(index, head, fit_results)
@@ -38,7 +38,7 @@ defmodule LearnKit.NaiveBayes.Gaussian.Classify do
           if fit_result.mean == value, do: 1.0, else: 0.0
         else
         # calculate the gaussian probability
-          exp = - :math.pow((value - fit_result.mean), 2) / (2 * fit_result.variance)
+          exp = - :math.pow(value - fit_result.mean, 2) / (2 * fit_result.variance)
           :math.exp(exp) / :math.sqrt(2 * :math.pi * fit_result.variance)
         end
       end

lib/learn_kit/regression/linear.ex

@@ -87,9 +87,9 @@ defmodule LearnKit.Regression.Linear do
   end
 
   defp define_method_for_fit(options) do
-    cond do
-      Keyword.get(options, :method) == "gradient descent" -> "gradient descent"
-      true -> ""
+    case Keyword.get(options, :method) do
+      "gradient descent" -> "gradient descent"
+      _ -> ""
     end
   end
 

lib/learn_kit/regression/linear/calculations.ex

@@ -30,14 +30,12 @@ defmodule LearnKit.Regression.Linear.Calculations do
       defp total_sum_of_squares(list) do
         mean_list = Math.mean(list)
         list
-        |> Enum.map(fn x -> :math.pow(x - mean_list, 2) end)
-        |> Enum.sum
+        |> Enum.reduce(0, fn x, acc -> acc + :math.pow(x - mean_list, 2) end)
       end
 
       defp sum_of_squared_errors(coefficients, factors, results) do
         Enum.zip(factors, results)
-        |> Enum.map(fn {xi, yi} -> squared_prediction_error(coefficients, xi, yi) end)
-        |> Enum.sum
+        |> Enum.reduce(0, fn {xi, yi}, acc -> acc + squared_prediction_error(coefficients, xi, yi) end)
       end
 
       defp squared_prediction_error(coefficients, x, y) do
@@ -78,9 +76,7 @@ defmodule LearnKit.Regression.Linear.Calculations do
       end
 
       defp check_value(data, min_value, theta, min_theta, iterations_with_no_improvement, alpha) do
-        value = data
-                |> Enum.map(fn {xi, yi} -> squared_prediction_error(theta, xi, yi) end)
-                |> Enum.sum
+        value = data |> Enum.reduce(0, fn {xi, yi}, acc -> acc + squared_prediction_error(theta, xi, yi) end)
         cond do
           value < min_value ->
             [theta, value, 0, 0.0001]

test/learn_kit/math_test.exs

@@ -3,6 +3,10 @@ defmodule LearnKit.MathTest do
 
   alias LearnKit.Math
 
+  test "calculate sum" do
+    assert 3 = Math.summ(1, 2)
+  end
+
   test "calculate mean" do
     assert 2.0 = Math.mean([1, 2, 3])
   end
@@ -34,4 +38,16 @@ defmodule LearnKit.MathTest do
   test "calculate correlation" do
     assert 0.9672471299049061 = Math.correlation([1, 2, 3], [14, 17, 25])
   end
+
+  test "transposing a matrix" do
+    assert [[1, 3, 5], [2, 4, 6]] = Math.transpose([[1, 2], [3, 4], [5, 6]])
+  end
+
+  test "scalar multiplication with matrix" do
+    assert [50, 60] = Math.scalar_multiply(10, [5, 6])
+  end
+
+  test "vector subtraction" do
+    assert [5, 45, 20] = Math.vector_subtraction([40, 50, 60], [35, 5, 40])
+  end
 end

test/learn_kit/regression/linear_test.exs

@@ -29,6 +29,12 @@ defmodule LearnKit.Regression.LinearTest do
     assert coefficients == [-1.5, 4.0]
   end
 
+  test "fit data set with gradient descent", state do
+    %Linear{coefficients: coefficients} = state[:predictor] |> Linear.fit([method: "gradient descent"])
+
+    assert [-1.5, 4.0] = coefficients |> Enum.map(fn x -> Float.round(x, 2) end)
+  end
+
   test "return prediction using the linear model", state do
     predictor = state[:predictor] |> Linear.fit