Code Comment updates

Author: davidrichey

lib/learn_kit/regression/linear.ex

@@ -8,6 +8,7 @@ defmodule LearnKit.Regression.Linear do
   alias LearnKit.Regression.Linear
 
   use Linear.Calculations
+  use LearnKit.Regression.Score
 
   @type factors :: [number]
   @type results :: [number]
@@ -80,11 +81,12 @@ defmodule LearnKit.Regression.Linear do
           coefficients: coefficients
         }
 
-  def fit(%Linear{factors: factors, results: results}, options \\ []) when is_list(options) do
+  def fit(linear = %Linear{factors: factors, results: results}, options \\ [])
+      when is_list(options) do
     coefficients =
       Keyword.merge([method: ""], options)
       |> define_method_for_fit()
-      |> do_fit(factors, results)
+      |> do_fit(linear)
 
     %Linear{factors: factors, results: results, coefficients: coefficients}
   end
@@ -112,13 +114,33 @@ defmodule LearnKit.Regression.Linear do
   """
   @spec predict(%Linear{coefficients: coefficients}, list) :: {:ok, list}
 
-  def predict(%Linear{coefficients: coefficients}, samples) when is_list(samples) do
+  def predict(linear = %Linear{coefficients: _}, samples) when is_list(samples) do
     {
       :ok,
-      Enum.map(samples, fn sample -> predict_sample(sample, coefficients) end)
+      Enum.map(samples, fn sample -> predict(linear, sample) end)
     }
   end
 
+  @doc """
+  Predict using the linear model
+
+  ## Parameters
+
+    - predictor: %LearnKit.Regression.Linear{}
+    - sample: Sample variable
+
+  ## Examples
+
+      iex> predictor |> LearnKit.Regression.Linear.predict(4)
+      {:ok, 14.5}
+
+  """
+  @spec predict(%Linear{coefficients: coefficients}, list) :: {:ok, list}
+
+  def predict(%Linear{coefficients: [alpha, beta]}, sample) do
+    sample * beta + alpha
+  end
+
   @doc """
   Returns the coefficient of determination R^2 of the prediction
 
@@ -135,10 +157,10 @@ 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
+  def score(linear = %Linear{factors: _, results: _, coefficients: _}) do
     {
       :ok,
-      calculate_score(coefficients, factors, results)
+      calculate_score(linear)
     }
   end
 end

lib/learn_kit/regression/linear/calculations.ex

@@ -4,10 +4,12 @@ defmodule LearnKit.Regression.Linear.Calculations do
   """
 
   alias LearnKit.Math
+  alias LearnKit.Regression.Linear
 
   defmacro __using__(_opts) do
     quote do
-      defp do_fit(method, factors, results) when method == "gradient descent" do
+      defp do_fit(method, %Linear{factors: factors, results: results})
+           when method == "gradient descent" do
         gradient_descent_iteration(
           [:rand.uniform(), :rand.uniform()],
           0.0001,
@@ -18,7 +20,7 @@ defmodule LearnKit.Regression.Linear.Calculations do
         )
       end
 
-      defp do_fit(_, factors, results) do
+      defp do_fit(_, %Linear{factors: factors, results: results}) do
         beta =
           Math.correlation(factors, results) * Math.standard_deviation(results) /
             Math.standard_deviation(factors)
@@ -27,48 +29,15 @@ defmodule LearnKit.Regression.Linear.Calculations do
         [alpha, beta]
       end
 
-      defp predict_sample(sample, [alpha, beta]) do
-        sample * beta + alpha
-      end
-
-      defp calculate_score([], _, _), do: raise("There was no fit for model")
-
-      defp calculate_score(coefficients, factors, results) do
-        1.0 -
-          sum_of_squared_errors(coefficients, factors, results) / total_sum_of_squares(results)
-      end
-
-      defp total_sum_of_squares(list) do
-        mean_list = Math.mean(list)
-        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
-        Enum.zip(factors, results)
-        |> Enum.reduce(0, fn {xi, yi}, acc ->
-          acc + squared_prediction_error(coefficients, xi, yi)
-        end)
-      end
-
-      defp squared_prediction_error(coefficients, x, y) do
-        coefficients
-        |> prediction_error(x, y)
-        |> :math.pow(2)
-      end
-
-      defp squared_error_gradient(coefficients, x, y) do
-        error_variable = prediction_error(coefficients, x, y)
+      defp squared_error_gradient(linear, x, y) do
+        error_variable = prediction_error(linear, x, y)
 
         [
           -2 * error_variable,
           -2 * error_variable * x
         ]
       end
 
-      defp prediction_error(coefficients, x, y) do
-        y - predict_sample(x, coefficients)
-      end
-
       defp gradient_descent_iteration(_, _, min_theta, _, _, iterations_with_no_improvement)
            when iterations_with_no_improvement >= 100,
            do: min_theta
@@ -92,7 +61,7 @@ defmodule LearnKit.Regression.Linear.Calculations do
           data
           |> Enum.shuffle()
           |> Enum.reduce(theta, fn {xi, yi}, acc ->
-            gradient_i = squared_error_gradient(acc, xi, yi)
+            gradient_i = squared_error_gradient(%Linear{coefficients: theta}, xi, yi)
             acc |> Math.vector_subtraction(alpha |> Math.scalar_multiply(gradient_i))
           end)
 
@@ -109,7 +78,7 @@ defmodule LearnKit.Regression.Linear.Calculations do
       defp check_value(data, min_value, theta, min_theta, iterations_with_no_improvement, alpha) do
         value =
           Enum.reduce(data, 0, fn {xi, yi}, acc ->
-            acc + squared_prediction_error(theta, xi, yi)
+            acc + squared_prediction_error(%Linear{coefficients: theta}, xi, yi)
           end)
 
         cond do

lib/learn_kit/regression/polynomial.ex

@@ -6,11 +6,12 @@ defmodule LearnKit.Regression.Polynomial do
   defstruct factors: [], results: [], coefficients: [], degree: 2
 
   alias LearnKit.Regression.Polynomial
+  use Polynomial.Calculations
 
   @type factors :: [number]
   @type results :: [number]
   @type coefficients :: [number]
-  @type degree :: number
+  @type degree :: integer
 
   @doc """
   Creates polynomial predictor with data_set
@@ -26,6 +27,12 @@ defmodule LearnKit.Regression.Polynomial do
       %LearnKit.Regression.Polynomial{factors: [1, 2, 3, 4], results: [3, 6, 10, 15], coefficients: [], degree: 2}
 
   """
+  @spec new(factors, results) :: %Polynomial{
+          factors: factors,
+          results: results,
+          coefficients: [],
+          degree: 2
+        }
   def new(factors, results) when is_list(factors) and is_list(results) do
     %Polynomial{factors: factors, results: results}
   end
@@ -65,6 +72,12 @@ defmodule LearnKit.Regression.Polynomial do
       }
 
   """
+  @spec fit(%Polynomial{factors: factors, results: results}) :: %Polynomial{
+          factors: factors,
+          results: results,
+          coefficients: coefficients,
+          degree: degree
+        }
   def fit(%Polynomial{factors: factors, results: results}, options \\ []) do
     degree = options[:degree] || 2
     matrix = matrix(factors, degree)
@@ -87,13 +100,10 @@ defmodule LearnKit.Regression.Polynomial do
       {:ok, [20.999999999999723, 27.999999999999574]}
 
   """
+  @spec predict(%Polynomial{coefficients: coefficients, degree: degree}, list) :: {:ok, list}
   def predict(polynomial = %Polynomial{coefficients: _, degree: _}, samples)
       when is_list(samples) do
-    {:ok,
-     Enum.map(samples, fn sample ->
-       {:ok, prediction} = predict(polynomial, sample)
-       prediction
-     end)}
+    {:ok, do_predict(polynomial, samples)}
   end
 
   @doc """
@@ -110,63 +120,9 @@ defmodule LearnKit.Regression.Polynomial do
       {:ok, 20.999999999999723}
 
   """
+  @spec predict(%Polynomial{coefficients: coefficients, degree: degree}, number) :: {:ok, number}
   def predict(%Polynomial{coefficients: coefficients, degree: degree}, sample) do
     ordered_coefficients = coefficients |> Enum.reverse()
     {:ok, substitute_coefficients(ordered_coefficients, sample, degree, 0.0)}
   end
-
-  defp matrix_line(1, factors, degree) do
-    power_ofs = Enum.to_list(1..degree)
-
-    [Enum.count(factors)] ++
-      Enum.map(power_ofs, fn factor ->
-        sum_x_with_k(factors, factor, 0.0)
-      end)
-  end
-
-  defp matrix_line(line, factors, degree) do
-    line_factor = line - 1
-    power_ofs = Enum.to_list(line_factor..(degree + line_factor))
-
-    Enum.map(power_ofs, fn factor ->
-      sum_x_with_k(factors, factor, 0.0)
-    end)
-  end
-
-  defp matrix(factors, degree) do
-    lines = Enum.to_list(1..(degree + 1))
-
-    Enum.map(lines, fn line ->
-      matrix_line(line, factors, degree)
-    end)
-  end
-
-  defp substitute_coefficients([], _, _, sum), do: sum
-
-  defp substitute_coefficients([coefficient | tail], x, k, sum) do
-    sum = sum + :math.pow(x, k) * coefficient
-    substitute_coefficients(tail, x, k - 1, sum)
-  end
-
-  defp sum_x_with_k([x | tail], k, sum) do
-    sum = sum + :math.pow(x, k)
-    sum_x_with_k(tail, k, sum)
-  end
-
-  defp sum_x_with_k([], _, sum), do: sum
-
-  defp sum_x_y_with_k([], [], _degree, sum), do: [sum]
-
-  defp sum_x_y_with_k([x | xtail], [y | ytail], degree, sum) do
-    exponent = degree - 1
-    sum = sum + :math.pow(x, exponent) * y
-    sum_x_y_with_k(xtail, ytail, degree, sum)
-  end
-
-  def x_y_matrix(_, _, 0, matrix), do: matrix |> Enum.reverse()
-
-  def x_y_matrix(xs, ys, degree, matrix) do
-    matrix = matrix ++ [sum_x_y_with_k(xs, ys, degree, 0.0)]
-    x_y_matrix(xs, ys, degree - 1, matrix)
-  end
 end

lib/learn_kit/regression/polynomial/calculations.ex

@@ -0,0 +1,71 @@
+defmodule LearnKit.Regression.Polynomial.Calculations do
+  @moduledoc """
+  Module for fit functions
+  """
+
+  defmacro __using__(_opts) do
+    quote do
+      defp do_predict(polynomial, samples) do
+        Enum.map(samples, fn sample ->
+          {:ok, prediction} = predict(polynomial, sample)
+          prediction
+        end)
+      end
+
+      defp matrix_line(1, factors, degree) do
+        power_ofs = Enum.to_list(1..degree)
+
+        [Enum.count(factors) | sum_of_x_i_with_k(power_ofs, factors)]
+      end
+
+      defp matrix_line(line, factors, degree) do
+        line_factor = line - 1
+        power_ofs = Enum.to_list(line_factor..(degree + line_factor))
+        sum_of_x_i_with_k(power_ofs, factors)
+      end
+
+      defp matrix(factors, degree) do
+        lines = Enum.to_list(1..(degree + 1))
+
+        Enum.map(lines, fn line ->
+          matrix_line(line, factors, degree)
+        end)
+      end
+
+      def sum_of_x_i_with_k(ks, factors) do
+        Enum.map(ks, fn factor ->
+          sum_x_with_k(factors, factor, 0.0)
+        end)
+      end
+
+      defp substitute_coefficients([], _, _, sum), do: sum
+
+      defp substitute_coefficients([coefficient | tail], x, k, sum) do
+        sum = sum + :math.pow(x, k) * coefficient
+        substitute_coefficients(tail, x, k - 1, sum)
+      end
+
+      defp sum_x_with_k([x | tail], k, sum) do
+        sum = sum + :math.pow(x, k)
+        sum_x_with_k(tail, k, sum)
+      end
+
+      defp sum_x_with_k([], _, sum), do: sum
+
+      defp sum_x_y_with_k([], [], _degree, sum), do: [sum]
+
+      defp sum_x_y_with_k([x | xtail], [y | ytail], degree, sum) do
+        exponent = degree - 1
+        sum = sum + :math.pow(x, exponent) * y
+        sum_x_y_with_k(xtail, ytail, degree, sum)
+      end
+
+      def x_y_matrix(_, _, 0, matrix), do: matrix |> Enum.reverse()
+
+      def x_y_matrix(xs, ys, degree, matrix) do
+        matrix = matrix ++ [sum_x_y_with_k(xs, ys, degree, 0.0)]
+        x_y_matrix(xs, ys, degree - 1, matrix)
+      end
+    end
+  end
+end

lib/learn_kit/regression/score.ex

@@ -0,0 +1,41 @@
+defmodule LearnKit.Regression.Score do
+  @moduledoc """
+  Module for fit functions
+  """
+
+  alias LearnKit.Math
+
+  defmacro __using__(_opts) do
+    quote do
+      defp calculate_score(%_{coefficients: []}, _, _), do: raise("There was no fit for model")
+
+      defp calculate_score(regression = %_{coefficients: _, factors: _, results: results}) do
+        1.0 - sum_of_squared_errors(regression) / total_sum_of_squares(results)
+      end
+
+      defp prediction_error(regression, x, y) do
+        y - predict(regression, x)
+      end
+
+      defp sum_of_squared_errors(
+             regression = %_{coefficients: _, factors: factors, results: results}
+           ) do
+        Enum.zip(factors, results)
+        |> Enum.reduce(0, fn {xi, yi}, acc ->
+          acc + squared_prediction_error(regression, xi, yi)
+        end)
+      end
+
+      defp total_sum_of_squares(list) do
+        mean_list = Math.mean(list)
+        Enum.reduce(list, 0, fn x, acc -> acc + :math.pow(x - mean_list, 2) end)
+      end
+
+      defp squared_prediction_error(regression = %_{coefficients: coefficients}, x, y) do
+        regression
+        |> prediction_error(x, y)
+        |> :math.pow(2)
+      end
+    end
+  end
+end