modify handling error conditions for invalid data for KNN algorithm

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
+- K-Nearest Neighbours algorithm, add errors conditions and tests
+
 ## [0.1.3] - 2018-11-22
 ### Modified
 - Linear Regression, fit with gradient descent

lib/learn_kit/knn.ex

@@ -45,7 +45,7 @@ defmodule LearnKit.Knn do
   """
   @spec new(data_set) :: %Knn{data_set: data_set}
 
-  def new(data_set) do
+  def new(data_set) when is_list(data_set) do
     %Knn{data_set: data_set}
   end
 
@@ -65,7 +65,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}) do
+  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: []
     data_set = Keyword.put(data_set, key, [value | features])
     %Knn{data_set: data_set}
@@ -94,16 +94,21 @@ defmodule LearnKit.Knn do
   """
   @spec classify(%Knn{data_set: data_set}, [tuple]) :: {:ok, label}
 
-  def classify(%Knn{data_set: data_set}, options \\ []) do
-    try do
-      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
-      {label, _} = prediction(data_set, options)
-      {:ok, label}
-    rescue
-      error -> {:error, error.message}
+  def classify(%Knn{data_set: data_set}, options) when is_list(options) do
+    cond do
+      !Keyword.has_key?(options, :feature) ->
+        {:error, "Feature option is required"}
+
+      !is_list(Keyword.get(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) ->
+        {:error, "K option must be positive integer"}
+
+      true ->
+        options = Keyword.merge([k: 3, algorithm: "brute", weight: "uniform"], options)
+        {label, _} = prediction(data_set, options)
+        {:ok, label}
     end
   end
 end

lib/learn_kit/knn/classify.ex

@@ -8,12 +8,11 @@ defmodule LearnKit.Knn.Classify do
   defmacro __using__(_opts) do
     quote do
       defp prediction(data_set, options) do
-        calc_distances_for_features(data_set, options)
+        data_set
+        |> calc_distances_for_features(options)
         |> sort_distances()
         |> select_closest_features(options)
-        |> calc_feature_weights(options)
-        |> accumulate_weight_of_labels([])
-        |> sort_result()
+        |> check_zero_distance(options)
       end
 
       # select algorithm for prediction
@@ -32,6 +31,21 @@ defmodule LearnKit.Knn.Classify do
         Enum.take(features, Keyword.get(options, :k))
       end
 
+      defp check_zero_distance(closest_features, options) do
+        {distance, label} = Enum.at(closest_features, 0)
+        cond do
+          distance == 0 -> {label, 0}
+          true -> select_best_label(closest_features, options)
+        end
+      end
+
+      defp select_best_label(features, options) do
+        features
+        |> calc_feature_weights(options)
+        |> accumulate_weight_of_labels([])
+        |> sort_result()
+      end
+
       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)))
@@ -70,7 +84,6 @@ defmodule LearnKit.Knn.Classify do
       defp calc_distances_in_label(features, current_feature, key) do
         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

test/learn_kit/knn_test.exs

@@ -3,31 +3,65 @@ defmodule LearnKit.KnnTest do
 
   alias LearnKit.Knn
 
-  test "create new knn classificator with empty data set" do
-    assert %Knn{data_set: data_set} = Knn.new
-
-    assert data_set == []
+  setup_all do
+    {:ok, classifier: Knn.new([{:a1, [[-1, -1], [-2, -1], [-3, -2]]}, {:b1, [[1, 1], [2, 1], [3, 2], [-2, -2]]}])}
   end
 
-  test "add train data to classificator" do
-    %Knn{data_set: data_set} = Knn.new
-                    |> Knn.add_train_data({:a1, [1, 2]})
-                    |> Knn.add_train_data({:a1, [1, 3]})
-                    |> Knn.add_train_data({:b1, [2, 3]})
+  describe "for invalid data" do
+    test "create new classifier with invalid data" do
+      assert_raise FunctionClauseError, fn ->
+        Knn.new("")
+      end
+    end
+
+    test "add train data in invalid format", state do
+      assert_raise FunctionClauseError, fn ->
+        Knn.add_train_data(state[:classifier], {:something_valid, "invalid"})
+      end
+    end
+
+    test "classify without options", state do
+      assert_raise FunctionClauseError, fn ->
+        Knn.classify(state[:classifier], "")
+      end
+    end
+
+    test "classify with empty options", state do
+      assert {:error, "Feature option is required"} = Knn.classify(state[:classifier], [])
+    end
+
+    test "classify with invalid feature", state do
+      assert {:error, "Feature option must be presented as array"} = Knn.classify(state[:classifier], [feature: "1"])
+    end
 
-    assert data_set == [b1: [[2, 3]], a1: [[1, 3], [1, 2]]]
+    test "classify with invalid k", state do
+      assert {:error, "K option must be positive integer"} = Knn.classify(state[:classifier], [feature: [-1, -2], k: -2])
+    end
   end
 
-  test "classify new feature" do
-    classificator = Knn.new
-                    |> Knn.add_train_data({:a1, [-1, -1]})
-                    |> Knn.add_train_data({:a1, [-2, -1]})
-                    |> Knn.add_train_data({:a1, [-3, -2]})
-                    |> Knn.add_train_data({:a2, [1, 1]})
-                    |> Knn.add_train_data({:a2, [2, 1]})
-                    |> Knn.add_train_data({:a2, [3, 2]})
-                    |> Knn.add_train_data({:a2, [-2, -2]})
-
-    assert {:ok, :a1} = Knn.classify(classificator, [feature: [-1, -2], k: 3, weight: "distance"])
+  describe "for valid data" do
+    test "create new knn classifier with empty data set" do
+      assert %Knn{data_set: data_set} = Knn.new
+
+      assert data_set == []
+    end
+
+    test "add train data to classifier" do
+      %Knn{data_set: data_set} =
+        Knn.new
+        |> Knn.add_train_data({:a1, [1, 2]})
+        |> Knn.add_train_data({:a1, [1, 3]})
+        |> Knn.add_train_data({:b1, [2, 3]})
+
+      assert data_set == [b1: [[2, 3]], a1: [[1, 3], [1, 2]]]
+    end
+
+    test "classify new feature", state do
+      assert {:ok, :a1} = Knn.classify(state[:classifier], [feature: [-1, -2], k: 3, weight: "distance"])
+    end
+
+    test "classify new feature, for existed point", state do
+      assert {:ok, :b1} = Knn.classify(state[:classifier], [feature: [-2, -2], k: 3, weight: "uniform"])
+    end
   end
 end