Ant System unit testing on tsp

Author: chen0040

README.md

@@ -19,7 +19,7 @@ Add the following dependency to your POM file:
 <dependency>
  <groupId>com.github.chen0040</groupId>
  <artifactId>java-swarm-intelligence</artifactId>
- <version>1.0.2</version>
+ <version>1.0.3</version>
 </dependency>
 ```
 
@@ -94,5 +94,51 @@ logger.info("trend: {}", trend);
 assertThat(bestSolution.getCost()).isCloseTo(0, within(0.01));
 ```
 
+### Ant System
+
+The sample code below shows how to solve a TSP (Travelling Salesman Problem) instance using Ant System:
+ 
+ ```java
+ // load the bayg29 TSP instance
+ TspBenchmark benchmark = Tsp.get(Tsp.Instance.bayg29);
+ 
+PathCostFunction costFunction = new PathCostFunction() {
+ // compute the cost of the tour constructed by an ant on the problem bayg29
+ @Override public double evaluate(List<Integer> path) {
+ double cost = 0;
+ for(int i=0; i < path.size(); ++i) {
+ int j = (i+1) % path.size();
+ double distance = benchmark.distance(path.get(i), path.get(j));
+ cost += distance;
+ }
+ return cost;
+ }
+
+ // heuristic weight for transition from state1 to state2 during path construction
+ // the higher the weight the more favorable to transit from state1 to state2
+ @Override public double stateTransitionWeight(int state1, int state2) {
+ return 1 / (1 + benchmark.distance(state1, state2));
+ }
+};
+
+
+
+AntSystem antSystem = new AntSystem();
+antSystem.setProblemSize(benchmark.size());
+antSystem.setCostFunction(costFunction);
+
+antSystem.setMaxIterations(100);
+
+Ant bestAnt = antSystem.solve();
+
+System.out.println("minimal total distance found by Ant System: " + bestAnt.getCost());
+System.out.println("known minimal total distance: " + costFunction.evaluate(benchmark.optTour()));
+
+System.out.println("best TSP path found: ");
+for(int i=0; i < bestAnt.getPath().size(); ++i) {
+ int j = (i + 1) % bestAnt.getPath().size();
+ System.out.println(bestAnt.getPath().get(i) + " => " + bestAnt.getPath().get(j));
+}
+ ```
 
 

pom.xml

@@ -6,7 +6,7 @@
 
  <groupId>com.github.chen0040</groupId>
  <artifactId>java-swarm-intelligence</artifactId>
- <version>1.0.3</version>
+ <version>1.0.4</version>
 
 
 
@@ -516,6 +516,12 @@
  <version>1.0.11</version>
  </dependency>
 
+ <dependency>
+ <groupId>com.github.chen0040</groupId>
+ <artifactId>java-datasets-discrete-optimization</artifactId>
+ <version>1.0.1</version>
+ </dependency>
+
 
  </dependencies>
 

src/main/java/com/github/chen0040/si/ant/Ant.java

@@ -7,7 +7,9 @@
 import lombok.Setter;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 
 /**
@@ -17,28 +19,29 @@
 @Getter
 @Setter
 public class Ant {
- protected final List<Integer> visitedStates = new ArrayList<>();
+ protected final List<Integer> path = new ArrayList<>();
+ protected final Set<Integer> visited = new HashSet<>();
  private boolean costValid = false;
  private double cost;
 
  public int currentState()
  {
- if(visitedStates.isEmpty()) {
+ if(path.isEmpty()) {
  return -1;
  } else {
- return visitedStates.get(visitedStates.size()-1);
+ return path.get(path.size()-1);
  }
  }
 
  public List<TupleTwo<Integer, Integer>> path()
  {
- if(visitedStates.isEmpty()) return new ArrayList<>();
+ if(path.isEmpty()) return new ArrayList<>();
 
  List<TupleTwo<Integer, Integer>> path = new ArrayList<>();
- for(int i = 0; i < this.visitedStates.size()-1; ++i)
+ for(int i = 0; i < this.path.size()-1; ++i)
  {
- int state1_id = this.visitedStates.get(i);
- int state2_id = this.visitedStates.get(i + 1);
+ int state1_id = this.path.get(i);
+ int state2_id = this.path.get(i + 1);
  path.add(new TupleTwo<>(state1_id, state2_id));
  }
 
@@ -51,30 +54,31 @@ public Ant()
 
  public void visit(int state)
  {
- visitedStates.add(state);
+ path.add(state);
+ visited.add(state);
  costValid = false;
  }
 
  public void reset()
  {
- visitedStates.clear();
+ path.clear();
+ visited.clear();
  costValid = false;
  }
 
- public int pathLength()
- {
- return visitedStates.size();
- }
 
  public boolean hasVisited(int state_id)
  {
- return visitedStates.contains(state_id);
+ return visited.contains(state_id);
  }
 
  public void copy(Ant rhs)
  {
- visitedStates.clear();
- visitedStates.addAll(rhs.visitedStates);
+ path.clear();
+ path.addAll(rhs.path);
+ visited.clear();
+ visited.addAll(rhs.visited);
+
  costValid = rhs.costValid;
  cost = rhs.cost;
  }
@@ -88,7 +92,17 @@ public boolean isBetterThan(Ant that) {
 
 
  public void evaluate(PathMediator mediator) {
- cost = mediator.evaluate(visitedStates);
+ cost = mediator.evaluate(path);
  costValid = true;
  }
+
+
+ public void update(List<Integer> path, double pathCost) {
+ this.path.clear();
+ this.path.addAll(path);
+ this.visited.clear();
+ this.visited.addAll(path);
+ this.cost = pathCost;
+ this.costValid = true;
+ }
 }

src/main/java/com/github/chen0040/si/ant/AntColonySystem.java

@@ -13,30 +13,30 @@ public class AntColonySystem extends AntSystem {
  @Override
  public void depositPheromone()
  {
- List<TupleTwo<Integer,Integer>> path = mGlobalBestAnt.path();
+ List<TupleTwo<Integer,Integer>> path = globalBestAnt.path();
  int segment_count = path.size();
  for (int i = 0; i < segment_count; ++i)
  {
  TupleTwo<Integer,Integer> state_transition = path.get(i);
  int state1_id = state_transition._1();
  int state2_id = state_transition._2();
- double pheromone = mPheromones.get(state1_id, state2_id);
- double p_delta = getRewardPerStateTransition(mGlobalBestAnt);
- pheromone += m_alpha * p_delta;
+ double pheromone = pheromones.get(state1_id, state2_id);
+ double p_delta = getRewardPerStateTransition(globalBestAnt);
+ pheromone += alpha * p_delta;
 
- mPheromones.set(state1_id, state2_id, pheromone);
- if (mSymmetric)
+ pheromones.set(state1_id, state2_id, pheromone);
+ if (symmetric)
  {
- mPheromones.set(state2_id, state1_id, pheromone);
+ pheromones.set(state2_id, state1_id, pheromone);
  }
  }
  }
 
  @Override
- public void transitStates(Ant ant, int state_index)
+ public void transitStates(Ant ant)
  {
  int current_state_id = ant.currentState();
- List<Integer> candidate_states = getCandidateNextStates(ant, current_state_id);
+ List<Integer> candidate_states = getCandidateNextStates(ant);
 
  if (candidate_states.isEmpty()) return;
 
@@ -50,10 +50,10 @@ public void transitStates(Ant ant, int state_index)
  for (int i = 0; i < candidate_states.size(); ++i)
  {
  int candidate_state_id = candidate_states.get(i);
- double pheromone = mPheromones.get(current_state_id, candidate_state_id);
- double heuristic_cost = heuristicCost(current_state_id, candidate_state_id);
+ double pheromone = pheromones.get(current_state_id, candidate_state_id);
+ double heuristic_cost = heuristicValue(current_state_id, candidate_state_id);
 
- double product = Math.pow(pheromone, m_alpha) * Math.pow(heuristic_cost, m_beta);
+ double product = Math.pow(pheromone, alpha) * Math.pow(heuristic_cost, beta);
 
  product_sum += product;
  acc_prob[i] = product_sum;
@@ -66,7 +66,7 @@ public void transitStates(Ant ant, int state_index)
  }
 
  double r = mediator.nextDouble();
- if (r <= m_Q)
+ if (r <= Q)
  {
  selected_state_id = state_id_with_max_prob;
  }
@@ -93,18 +93,18 @@ public void transitStates(Ant ant, int state_index)
 
  protected void localPheromoneUpdate(int state1_id, int state2_id)
  {
- double pheromone = mPheromones.get(state1_id, state2_id);
+ double pheromone = pheromones.get(state1_id, state2_id);
 
- pheromone = (1 - m_rho) * pheromone + m_rho * mTau0;
- if (pheromone <= mTau0)
+ pheromone = (1 - rho) * pheromone + rho * tau0;
+ if (pheromone <= tau0)
  {
- pheromone = mTau0;
+ pheromone = tau0;
  }
 
- mPheromones.set(state1_id, state2_id, pheromone);
- if (mSymmetric)
+ pheromones.set(state1_id, state2_id, pheromone);
+ if (symmetric)
  {
- mPheromones.set(state2_id, state1_id, pheromone);
+ pheromones.set(state2_id, state1_id, pheromone);
  }
  }
 }