modify normalization algorithm

Author: kortirso

lib/learn_kit/preprocessing.ex

@@ -11,16 +11,11 @@ defmodule LearnKit.Preprocessing do
   @type matrix :: [row]
 
   @doc """
-  Normalization of data set
+  Normalize data set with minimax normalization
 
   ## Parameters
 
     - features: list of features for normalization
-    - options: keyword list with options
-
-  ## Options
-
-    - type: minimax/z_normalization, default is minimax, optional
 
   ## Examples
 
@@ -31,6 +26,27 @@ defmodule LearnKit.Preprocessing do
         [1.0, 1.0]
       ]
 
+  """
+  @spec normalize(matrix) :: matrix
+
+  def normalize(features) when is_list(features) do
+    normalize(features, [type: "minimax"])
+  end
+
+  @doc """
+  Normalize data set
+
+  ## Parameters
+
+    - features: list of features for normalization
+    - options: keyword list with options
+
+  ## Options
+
+    - type: minimax/z_normalization, default is minimax, optional
+
+  ## Examples
+
       iex> LearnKit.Preprocessing.normalize([[1, 2], [3, 4], [5, 6]], [type: "z_normalization"])
       [
         [-1.224744871391589, -1.224744871391589],
@@ -39,18 +55,13 @@ defmodule LearnKit.Preprocessing do
       ]
 
   """
-  @spec normalize(matrix) :: matrix
   @spec normalize(matrix, list) :: matrix
 
-  def normalize(features) when is_list(features) do
-    normalize(features, [type: "minimax"])
-  end
-
   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
-      "z_normalization" -> z_normalization(features)
-      _ -> minimax_normalization(features)
+      "z_normalization" -> normalization(features, "z_normalization")
+      _ -> normalization(features, "minimax")
     end
   end
 end

lib/learn_kit/preprocessing/normalize.ex

@@ -7,49 +7,43 @@ defmodule LearnKit.Preprocessing.Normalize do
 
   defmacro __using__(_opts) do
     quote do
-      defp minimax_normalization(features) do
+      defp normalization(features, type) do
         features_by_index = Math.transpose(features)
-        list_of_params =
-          features_by_index
-          |> Enum.map(fn list ->
-            {
-              Enum.min(list),
-              Enum.max(list)
-            }
-          end)
+        list_of_params = Enum.map(features_by_index, fn list -> return_params(list, type) end)
         features_by_index
         |> Enum.with_index()
-        |> Enum.map(fn {feature, index} ->
-          params_for_point = Enum.at(list_of_params, index)
-          range = elem(params_for_point, 1) - elem(params_for_point, 0)
-          feature
-          |> Enum.map(fn point ->
-            (point - elem(params_for_point, 0)) / range
-          end)
-        end)
+        |> Enum.map(fn {feature, index} -> transform_feature(feature, Enum.at(list_of_params, index), type) end)
         |> Math.transpose()
       end
 
-      defp z_normalization(features) do
-        features_by_index = Math.transpose(features)
-        list_of_params =
-          features_by_index
-          |> Enum.map(fn list ->
-            {
-              Math.mean(list),
-              Math.standard_deviation(list)
-            }
-          end)
-        features_by_index
-        |> Enum.with_index()
-        |> Enum.map(fn {feature, index} ->
-          params_for_point = Enum.at(list_of_params, index)
-          feature
-          |> Enum.map(fn point ->
-            (point - elem(params_for_point, 0)) / elem(params_for_point, 1)
-          end)
-        end)
-        |> Math.transpose()
+      defp return_params(list, "minimax") do
+        {
+          Enum.min(list),
+          Enum.max(list)
+        }
+      end
+
+      defp return_params(list, "z_normalization") do
+        {
+          Math.mean(list),
+          Math.standard_deviation(list)
+        }
+      end
+
+      defp transform_feature(feature, params_for_point, type) do
+        divider = define_divider(params_for_point, type)
+        case divider do
+          0 -> feature
+          _ -> Enum.map(feature, fn point -> (point - elem(params_for_point, 0)) / divider end)
+        end
+      end
+
+      defp define_divider(params_for_point, "minimax") do
+        elem(params_for_point, 1) - elem(params_for_point, 0)
+      end
+
+      defp define_divider(params_for_point, "z_normalization") do
+        elem(params_for_point, 1)
       end
     end
   end