Preparing compose config

Author: B-Moritz

alg/NSGA_II/conf/experiment_improved_random_key.yaml

@@ -2,9 +2,9 @@ defaults:
 - experiment: basic
 
 experiment:
-    repetitions: 1
+    repetitions: 10
     n_iterations: 150
-    problem_names: ["ft20"] #["ft06", "ft10", "ft20", "abz7", "abz8", "abz9", "la28", "la40"]
+    problem_names: ["ft06", "ft10", "ft20", "abz7", "abz8", "abz9", "la28", "la40"]
     experiment_id: 2
     dump_population: False
 

compose.yaml

@@ -15,10 +15,18 @@ services:
   #  cpuset: "1"
   #  command: ./run_position_experiment.bash
 
-  qga_hash_jssp:
-    build:
+  #qga_hash_jssp:
+  #  build:
+  #    context: .
+  #  volumes:
+  #    - ./logdata_2:/QGA_JSSP/logdata_2
+  #  cpuset: "2"
+  #  command: ./run_hash_based.bash
+
+  qga_improv_rnadom_key:
+   build:
       context: .
-    volumes:
-      - ./logdata_2:/QGA_JSSP/logdata_2
-    cpuset: "2"
-    command: ./run_hash_based.bash
+      volumes:
+        - ./logdata_2:/QGA_JSSP/logdata_2
+      cpuset: "2"
+      command: ./run_hash_based.bash

lab/alternative_rotation.ipynb

@@ -1070,6 +1070,88 @@ def rotate(self,
             # Converge more significant bits
             self.binary_chromosome[0, :cutoffpoint] = np.logical_not(b.x[:cutoffpoint])
             self.binary_chromosome[1, :cutoffpoint] = b.x[:cutoffpoint]
+
+
+class EnhancedQuantumRandomKeyIndividual(Individual):
+    
+    def __init__(self, n_jobs: int, n_machines: int, individual_cfg: DictConfig, time_log: bool=False) -> None:
+        self.individual_cfg = individual_cfg
+        self.n_machines = n_machines
+        self.n_jobs = n_jobs
+        self.time_log = time_log
+        self.start_std = self.individual_cfg.start_std
+        self.base_permutation = np.repeat(np.arange(self.n_jobs), self.n_machines)
+        self.initialize_individual()
+        self.convert_permutation()
+
+    def initialize_individual(self):
+        self.positions = np.random.randint(0, self.n_jobs, size=self.n_jobs*self.n_machines)
+        self.standard_deviations = np.ones(shape=self.n_jobs*self.n_machines) * self.start_std
+        self.random_keys = np.zeros_like(self.positions)
+
+    def periodic_triangular_function_vectorized(self, x: np.ndarray, j: int) -> np.ndarray:
+        y = lambda x, offset, sign: sign*(x - offset)
+        y_res = np.empty_like(x)
+        
+        x1 = x[(np.floor(x) // j) % 2 == 0]
+        x2 = x[(np.floor(x) // j) % 2 > 0]
+
+        y_res[(np.floor(x) // j) % 2 == 0] = y(x1, (np.floor(x1) // j)*j, 1)
+        y_res[(np.floor(x) // j) % 2 > 0] = y(x2, ((np.floor(x2) // j)*j)+j, -1)
+
+        return np.floor(y_res)
+    
+    def measure(self):
+        self.random_keys = self.periodic_triangular_function_vectorized(np.round(np.random.normal(0, self.standard_deviations) + self.positions).astype(int), self.n_jobs-1)
+
+    def convert_permutation(self): 
+        self.permutation = self.base_permutation[np.argsort(self.random_keys)]
+
+    def rotate(self, 
+               b: object, 
+               c: int,
+               c_tot: int,
+               n_groups: int,
+               cur_group : int,
+               rotation_angles: str="[0, 0, 1, 0, 0, 0, 1, 0]",
+               std_deltas: str="[-0.3, -0.1, -0.3, -0.1]"):
+        
+        # transfer all angles into interval [0, j]
+        raw_rotation_angles = eval(rotation_angles)
+        if len(raw_rotation_angles) != 8:
+            raise ValueError("Please specify rotation angle array of length 8.")
+        
+        raw_std_deltas = eval(std_deltas)
+        if len(raw_std_deltas) != 4:
+            raise ValueError("Please specify std delta array of length 4.")
+
+        rotation_angles = np.array(raw_rotation_angles)
+        std_deltas = np.array(raw_std_deltas)
+
+        b_keys = b.random_keys
+        x_keys = self.random_keys
+        x_filtered = self.positions
+        # Check if the two angles are within the variance
+        equal_cases_overshoot = np.logical_and(b_keys == x_keys, (b_keys - x_keys) <= 0)
+        equal_cases_undershoot = np.logical_and(b_keys == x_keys, (b_keys - x_keys) >= 0)
+        unequal_cases_overshoot = np.logical_and(b_keys != x_keys, (b_keys - x_keys) < 0)
+        unequal_cases_undershoot = np.logical_and(b_keys != x_keys, (b_keys - x_keys) > 0)
+
+        x_filtered[equal_cases_overshoot] += rotation_angles[0] #np.random.uniform(0.01, 0.05)
+        x_filtered[unequal_cases_overshoot] -= rotation_angles[2] #np.random.uniform(0.01, 0.05)
+        x_filtered[equal_cases_undershoot] -= rotation_angles[4] #np.random.uniform(0.01, 0.05)
+        x_filtered[unequal_cases_undershoot] += rotation_angles[6] #np.random.uniform(0.01, 0.05)
+        # Contribute to std convergence
+        self.standard_deviations[equal_cases_overshoot] = np.abs(self.standard_deviations[equal_cases_overshoot] + std_deltas[0])
+        self.standard_deviations[unequal_cases_overshoot] = np.abs(self.standard_deviations[unequal_cases_overshoot] + std_deltas[1])
+        self.standard_deviations[equal_cases_undershoot] = np.abs(self.standard_deviations[equal_cases_undershoot] + std_deltas[2])
+        self.standard_deviations[unequal_cases_undershoot] = np.abs(self.standard_deviations[unequal_cases_undershoot] + std_deltas[3])
+        # If the standard deviaiton has become negative, make sure it is 
+        #self.standard_deviations[self.standard_deviations < 0] = 0
+        # Handle values outside the supported range
+        self.positions = np.abs(x_filtered) % self.n_jobs
+        return self.permutation
+
 
 
 if __name__=="__main__":

qga_lib/individual.py

@@ -23,7 +23,7 @@
 
 from operations import Operation
 from schedules import Schedule
-from individual import Individual, PermutationChromosome
+from individual import Individual, PermutationChromosome, EnhancedQuantumRandomKeyIndividual
 from or_benchmark import BenchmarkCollection
 import matplotlib.pyplot as plt
 from PIL import Image
@@ -294,7 +294,7 @@ def non_dominated_sorting(self):
                 # For each individual go through the rest to find the best possible individual (that dominates all solutions)
                 dominated = False
                 for j in range(cur_start, len(self.R)):
-                    # swap if J dominates the
+                    # swap if J dominates the 
                     cur_comparison = np.array(self.R[j].cur_fitness) <= np.array(self.R[i].cur_fitness)
                     if (i != j) and (cur_comparison).all():
                         # Break the loop if the individual i is dominated -> means that the individual does not belong to the current front
@@ -309,9 +309,6 @@ def non_dominated_sorting(self):
                     # Move swap position one step to the right
                     cur_swap_index += 1
 
-            # What happens when all solutions are dominated. 
-            # What happens if only one individual is in a front
-
             # Close the front 
             if cur_start == cur_swap_index:
                 # There is only one front in the set, 
@@ -323,8 +320,9 @@ def non_dominated_sorting(self):
                 cur_start = cur_swap_index
 
         # Add the last front
-        if self.front_start_index[-1] < self.N:
-            self.front_start_index.append(self.N)
+        #if self.front_start_index[-1] < self.N:
+        self.front_start_index.append(cur_start)
+
 
 
     def get_front_range(self, i: int) -> List:
@@ -898,4 +896,113 @@ def execute_quantum_update(self, c: int, c_tot: int):
                     temp_front_indexes.append(j)
 
 
+            front_indexes = temp_front_indexes
+
+
+class EnhancedQMEAPopulation(Population):
+    def __init__(self,
+                 N: int,
+                 reset_fraction: float,
+                 decoding_method: str,
+                 n_jobs: int,
+                 n_machines: int,
+                 jssp_problem: np.ndarray,
+                 individual_cfg: DictConfig,
+                 rotation_angles: str, 
+                 std_deltas: str,
+                 group_partitions: int,
+                 activate_schedule: bool=False,
+                 time_log: bool=False,
+                 individual_type="EnhancedQuantumRandomKeyIndividual"
+        ):
+        super().__init__(N, decoding_method, n_jobs, n_machines, jssp_problem, activate_schedule, time_log)
+        self.individual_type = individual_type
+        self.reset_fraction = reset_fraction
+        self.rotation_angles = rotation_angles
+        self.std_deltas = std_deltas
+        self.Individual_cfg = individual_cfg
+        self.group_partitions = group_partitions
+        self.initialize_population(time_log)
+        self.evaluate_fitness()
+
+    def evaluate_fitness(self):
+        for cur_chromosome in self.R:
+            # make measurement
+            cur_chromosome.measure()
+            # Convert bit string to operation based representation
+            cur_chromosome.convert_permutation()
+            # Create schedule to evaluate fitness
+            cur_chromosome.create_schedule(
+                self.decoding_method, 
+                self.jssp_problem,
+                self.activate_schedule
+            )
+        # Fintess values are available as self.R[i].schedule.max_completion_time
+
+    def initialize_population(self, time_log: bool=False):
+        """Method for populating the population with individuals. Generates random qubit chromosomes.
+
+        Parameters
+        ----------
+        time_log : bool, optional
+            Logging durations of different components in representation, by default False
+        """
+        # P is index 0 - N-1, while Q is index N - 2N
+        cur_individual_type = eval(self.individual_type)
+        self.R = np.empty(2*self.N, dtype=cur_individual_type)
+        for i in range(len(self.R)):
+            self.R[i] = cur_individual_type(self.n_jobs, self.n_machines, self.Individual_cfg, time_log=time_log)
+
+    def execute_quantum_update(self, c: int, c_tot: int):
+        """This method is used to perform recombination for the QMEA algorithm
+            
+        Parameters
+        ----------
+        c : int
+            The current generation number
+        c_tot : int
+            The total generation to run
+
+        Raises
+        ------
+        Exception
+            The groups of solutions should contains more solutions than 0.
+        """
+        population_size = self.N*2*(1-self.reset_fraction)
+        # Divide the parents into equal groups
+        S = int(np.floor(population_size/self.group_partitions))
+        if S <= 0:
+            raise Exception("The groups of solutions should contains more solutions than 0. Please adjust the n_groups parameter.")
+        
+        group = np.arange(1, self.group_partitions, 1)*S
+        for g in group:
+            for s in range(S):
+                # For each solution in the best group, use it to rotate the solution
+                # Solutions in other groups are given by S*group + s
+                self.R[g + s].rotate(self.R[s], c=c, c_tot=c_tot, n_groups=self.group_partitions, cur_group=g, rotation_angles=self.rotation_angles, std_deltas=self.std_deltas)
+
+        # Reset remaining solutions
+        reset_index = int(self.N*2*(1-self.reset_fraction))
+        for remaining in self.R[reset_index:]:
+            remaining.initialize_individual()
+
+        # Set the genes of the best group
+        for s in range(S):
+            self.R[s].positions = self.R[s].random_keys
+            self.R[s].standard_deviations = np.zeros_like(self.R[s].random_keys)
+
+        # Reset individuals that are duplicated
+        cur_range = self.get_front_range(0)
+        front_indexes = np.arange(cur_range[0], cur_range[1]).tolist()
+        while len(front_indexes) > 0:
+            cur_makespan, cur_flow = self.R[front_indexes[0]].cur_fitness
+            temp_front_indexes = []
+            for j in range(1, len(front_indexes)):
+                comp_makespan, comp_flow = self.R[front_indexes[j]].cur_fitness
+                if cur_makespan == comp_makespan and cur_flow == comp_flow:
+                    # Reset the duplicate to initial positions
+                    self.R[front_indexes[j]].initialize_individual()
+                    temp_front_indexes.append(j)
+                    
+
             front_indexes = temp_front_indexes

qga_lib/nsga_population.py

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+ls -la /QGA_JSSP/logdata_2
+
+#python ./alg/NSGA_II/run_experiment.py -cn experiment_qga_position.yaml
+
+for pop_size in 50
+do
+        echo 'Running with N=$pop_size'
+        python ./alg/NSGA_II/run_experiment.py -cn experiment_improved_random_key.yaml "qmea_enhanced_random_key={pop_object : {N : $pop_size}}"
+done