Added variants of coupled simulated annealing

Author: mandar2812

build.sbt

@@ -12,7 +12,7 @@ packageDescription := "DynaML is a scala library/repl for implementing and worki
   "which can be extended easily to implement advanced models for small and large scale applications.\n\n"+
   "But the library can also be used as an educational/research tool for data analysis."
 
-val mainVersion = "v1.4-beta.31"
+val mainVersion = "v1.4-beta.32"
 
 val dataDirectory = settingKey[File]("The directory holding the data files for running example scripts")
 

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/optimization/CoupledSimulatedAnnealing.scala

@@ -19,6 +19,7 @@ under the License.
 package io.github.mandar2812.dynaml.optimization
 
 import breeze.stats.distributions.CauchyDistribution
+import spire.implicits._
 
 import scala.util.Random
 
@@ -33,6 +34,8 @@ class CoupledSimulatedAnnealing[M <: GloballyOptimizable](model: M)
 
   protected var MAX_ITERATIONS: Int = 10
 
+  var variant = CoupledSimulatedAnnealing.MuSA
+
   def setMaxIterations(m: Int) = {
     MAX_ITERATIONS = m
     this
@@ -53,9 +56,7 @@ class CoupledSimulatedAnnealing[M <: GloballyOptimizable](model: M)
     this
   }
 
-  protected val acceptance = (energy: Double,
-                              coupling: Double,
-                              temperature: Double) => {
+  protected def acceptance(energy: Double, oldEnergy: Double, coupling: Double, temperature: Double) = {
     val prob = math.exp(-1.0*energy/temperature)
     prob/(prob+coupling)
   }
@@ -74,6 +75,9 @@ class CoupledSimulatedAnnealing[M <: GloballyOptimizable](model: M)
   def mutationTemperature(initialTemp: Double)(k: Int): Double =
     initialTemp/k.toDouble
 
+  def gamma(landscape: Seq[Double])(accTemp: Double): Double =
+    CoupledSimulatedAnnealing.couplingFactor(variant)(landscape, accTemp)
+
   override def optimize(initialConfig: Map[String, Double],
                         options: Map[String, String] = Map()) = {
 
@@ -85,28 +89,29 @@ class CoupledSimulatedAnnealing[M <: GloballyOptimizable](model: M)
     val energyLandscape = getEnergyLandscape(initialConfig, options)
 
     var currentEnergyLandscape = energyLandscape
-    var newEnergyLandscape = energyLandscape
 
-    (1 to MAX_ITERATIONS).foreach((iteration) => {
+    cfor(1)(iteration => iteration < MAX_ITERATIONS, iteration => iteration + 1)( iteration => {
       logger.info("**************************")
       logger.info("CSA Iteration: "+iteration)
       //mutate each element of the grid with
       //the generating distribution
       //and accept using the acceptance distribution
       mutTemp = mutationTemperature(iTemp)(iteration)
       accTemp = acceptanceTemperature(iTemp)(iteration)
-      val couplingFactor = currentEnergyLandscape.map(c => math.exp(-1.0*c._1/accTemp)).sum
+
+      val maxEnergy = currentEnergyLandscape.map(_._1).max
+
+      val couplingFactor = gamma(currentEnergyLandscape.map(t => t._1 - maxEnergy))(accTemp)
       //Now mutate each solution and accept/reject
       //according to the acceptance probability
-
-      newEnergyLandscape = currentEnergyLandscape.map((config) => {
+      val newEnergyLandscape = currentEnergyLandscape.map((config) => {
         //mutate this config
         val new_config = mutate(config._2, mutTemp)
         val new_energy = system.energy(new_config, options)
         val ans = if(new_energy < config._1) {
           (new_energy, new_config)
         } else {
-          val acc = acceptance(new_energy, couplingFactor, accTemp)
+          val acc = acceptance(new_energy - maxEnergy, config._1, couplingFactor, accTemp)
           if(Random.nextDouble <= acc) (new_energy, new_config) else config
         }
         ans
@@ -126,3 +131,33 @@ class CoupledSimulatedAnnealing[M <: GloballyOptimizable](model: M)
     (system, landscape(optimum))
   }
 }
+
+
+object CoupledSimulatedAnnealing {
+
+  val MuSA = "CSA-MuSA"
+  val BA = "CSA-BA"
+  val M = "CSA-M"
+  val MwVC = "CSA-MwVC"
+  val SA = "SA"
+
+  def couplingFactor(variant: String)(landscape: Seq[Double], Tacc: Double): Double = {
+    if(variant == MuSA || variant == BA)
+      landscape.map(energy => math.exp(-1.0*energy/Tacc)).sum
+    else if (variant == M || variant == MwVC)
+      landscape.map(energy => math.exp(energy/Tacc)).sum
+    else 1.0
+  }
+
+  def acceptanceProbability(variant: String)(energy: Double, oldEnergy: Double, gamma: Double, temperature: Double) = {
+    if(variant == MuSA )
+      math.exp(-1.0*energy/temperature)/(math.exp(-1.0*energy/temperature)+gamma)
+    else if (variant == BA)
+      1.0 - (math.exp(-1.0*oldEnergy/temperature)/gamma)
+    else if (variant == M || variant == MwVC)
+      math.exp(oldEnergy/temperature)/gamma
+    else gamma/(1.0 + math.exp((energy - oldEnergy)/temperature))
+  }
+
+
+}

project/Dependencies.scala

@@ -2,7 +2,7 @@ import sbt._
 
 object Dependencies {
 
-  val scala = "2.11.7"
+  val scala = "2.11.8"
 
   val baseDependencies = Seq(
     "org.scala-lang" % "scala-compiler" % scala % "compile",
@@ -38,7 +38,7 @@ object Dependencies {
   )
 
   val replDependency = Seq(
-    "com.lihaoyi" % "ammonite-repl_2.11.7" % "0.5.8"
+    "com.lihaoyi" % "ammonite-repl_2.11.8" % "0.5.8"
   )
 
   val tinkerpopDependency = Seq(