EpsilonGreedy

Author: Wei-1

Diff for: src/main/scala/algorithm/optimization/EpsilonGreedy.scala

@@ -0,0 +1,27 @@
+// Wei Chen - Epsilon Greedy Search
+// 2020-03-08
+
+package com.scalaml.algorithm
+
+class EpsilonGreedy {
+    var currentScores: Array[Double] = null
+
+    def search(
+        evaluation: Array[Double] => Double,
+        choices: Array[Array[Double]],
+        scores: Array[Double] = null,
+        epsilon: Double = 0.1
+    ): Array[Double] = {
+        val size = choices.size
+        if (scores != null)
+            currentScores = scores
+        if (currentScores == null)
+            currentScores = new Array[Double](size)
+        if (math.random < epsilon) {
+            val randSelect = (math.random * size).toInt
+            val value = evaluation(choices(randSelect))
+            currentScores(randSelect) = value
+        }
+        choices(currentScores.indexOf(currentScores.max))
+    }
+}

Diff for: src/main/scala/algorithm/optimization/GeneAlgorithm.scala

@@ -24,6 +24,18 @@ class GeneAlgorithm {
             breeding(parents(ai), parents(bi))
         }
         seeds = parents ++ kids
-        return parents.last // return the best
+        parents.last // return the best
+    }
+
+    def search(
+        evaluation: Array[Double] => Double,
+        breeding: (Array[Double], Array[Double]) => Array[Array[Double]],
+        generationsize: Int = 100,
+        elitesize: Int = 3,
+        generationcount: Int = 10
+    ): Array[Double] = {
+        for (i <- 1 until generationcount)
+            evolve(evaluation, breeding, generationsize, elitesize)
+        evolve(evaluation, breeding, generationsize, elitesize)
     }
 }

Diff for: src/test/scala/algorithm/optimization/EpsilonGreedyTest.scala

@@ -0,0 +1,48 @@
+// Wei Chen - Epsilon Greedy Search Test
+// 2020-03-08
+
+import com.scalaml.general.MatrixFunc._
+import com.scalaml.algorithm.EpsilonGreedy
+import org.scalatest.funsuite.AnyFunSuite
+
+class EpsilonGreedySuite extends AnyFunSuite {
+
+    val eg = new EpsilonGreedy()
+
+
+    def evaluation(arr: Array[Double]): Double = 1 / ((arr.head - 0.7).abs + 1)
+
+    val choices: Array[Array[Double]] = Array(
+        Array(0.7),
+        Array(0.8),
+        Array(1.0),
+        Array(0.5)
+    )
+    val epsilon: Double = 0.1
+
+    test("GeneAlgorithm Test : Initial") {
+        assert(eg.currentScores == null)
+    }
+
+    test("GeneAlgorithm Test : Search - Start") {
+        for (i <- 0 until 1000)
+            eg.search(evaluation, choices, null, epsilon)
+        assert(eg.currentScores.size == choices.size)
+
+        val best = eg.search(evaluation, choices, null, epsilon)
+        assert((best.head - 0.7).abs < 0.05)
+    }
+
+    test("GeneAlgorithm Test : Search - Continue") {
+        var scores: Array[Double] = Array(0, 0, 1 / 1.3, 0)
+        for (i <- 0 until 1000) {
+            eg.search(evaluation, choices, scores, epsilon)
+            scores = eg.currentScores
+        }
+        assert(eg.currentScores.size == scores.size)
+
+        val best = eg.search(evaluation, choices, scores, epsilon)
+        assert((best.head - 0.7).abs < 0.05)
+    }
+
+}

Diff for: src/test/scala/algorithm/optimization/GeneAlgorithmTest.scala

@@ -22,6 +22,7 @@ class GeneAlgorithmSuite extends AnyFunSuite {
 
     val generationsize: Int = 100
     val elitesize: Int = 3
+    val generationcount: Int = 10
 
     test("GeneAlgorithm Test : Initial") {
         assert(ga.seeds == null)
@@ -38,4 +39,16 @@ class GeneAlgorithmSuite extends AnyFunSuite {
         assert((best.head - 0.7).abs < 0.05)
     }
 
+    test("GeneAlgorithm Test : Search") {
+        val best = ga.search(
+            evaluation,
+            breeding,
+            generationsize,
+            elitesize,
+            generationcount
+        )
+        assert(ga.seeds.size == generationsize)
+        assert((best.head - 0.7).abs < 0.05)
+    }
+
 }