IGJSP 0.0.7__tar.gz → 0.0.9__tar.gz

{igjsp-0.0.7 → igjsp-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IGJSP
-Version: 0.0.7
+Version: 0.0.9
 Summary: Instance generator for JSP
 Project-URL: Homepage, https://gps.blogs.upv.es/
 Author-email: GPS-UPV <gps@dsic.upv.es>

{igjsp-0.0.7 → igjsp-0.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "IGJSP"
-version = "0.0.7"
+version = "0.0.9"
 authors = [
   { name="GPS-UPV", email="gps@dsic.upv.es" },
 ]

{igjsp-0.0.7 → igjsp-0.0.9}/src/IGJSP/generador.py

@@ -44,7 +44,7 @@ class JSP:
                 tpm = [max(10, data) for data in np.random.normal(50, 20, self.numMchs)]
             else:
                 tpm = expon(loc=10, scale=20).rvs(self.numMchs)
-       
+        
         energyPer, timePer = self._particionate_speed_space(speed)
         self._generate_standar_operation_cost(distribution)
 
@@ -67,6 +67,7 @@ class JSP:
 
         self._jobToMachine(release_date_tasks, timePer, distribution)
         self.generate_maxmin_objective_values()
+        self.vectorization()
 
     def _particionate_speed_space(self, speed):
         energyPer = np.linspace(0.5, 3, speed) if speed > 1 else [1]
@@ -277,16 +278,16 @@ class JSP:
         return new_object
 
     def generate_maxmin_objective_values(self):
-        max_makespan = sum([max(self.ProcessingTime[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
+        self.max_makespan = sum([max(self.ProcessingTime[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
         self.min_makespan = max([sum([min(self.ProcessingTime[job, machine, :]) for machine in range(self.numMchs)]) for job in range(self.numJobs)])
-        self.max_min_makespan = max_makespan - self.min_makespan
-        max_energy = sum([max(self.EnergyConsumption[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
+        self.max_min_makespan = self.max_makespan - self.min_makespan
+        self.max_energy = sum([max(self.EnergyConsumption[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
         self.min_energy = sum([min(self.EnergyConsumption[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
-        self.max_min_energy = max_energy - self.min_energy
+        self.max_min_energy = self.max_energy - self.min_energy
         if self.rddd == 1:
-            self.max_tardiness = sum([max(0, max_makespan - self.ReleaseDueDate[job, 1]) for job in range(self.numJobs)])
+            self.max_tardiness = sum([max(0, self.max_makespan - self.ReleaseDueDate[job, 1]) for job in range(self.numJobs)])
         elif self.rddd == 2:
-            self.max_tardiness = np.sum([max(0, np.int64(max_makespan - self.ReleaseDueDate[job, machine, 1])) for job in range(self.numJobs) for machine in range(self.numMchs)])
+            self.max_tardiness = np.sum([max(0, np.int64(self.max_makespan - self.ReleaseDueDate[job, machine, 1])) for job in range(self.numJobs) for machine in range(self.numMchs)])
 
     def norm_makespan(self, makespan):
         return (makespan - self.min_makespan) / self.max_min_makespan
@@ -388,7 +389,86 @@ class JSP:
 
     def generate_schedule_image(self, schedule):
         pass
-
+    
+    def vectorization(self):
+        vectorization = {}
+        # Caracteristicas básicas
+        vectorization["jobs"]           = self.numJobs
+        vectorization["machines"]       = self.numMchs
+        vectorization["rddd"]           = self.rddd
+        vectorization["speed"]          = self.speed
+        vectorization["max_makespan"]    = self.max_makespan
+        vectorization["min_makespan"]    = self.min_makespan
+        vectorization["max_sum_energy"]   = self.max_energy
+        vectorization["min_sum_energy"]   = self.min_energy
+        vectorization["max_tardiness"]   = self.max_tardiness if self.rddd != 0 else 0
+        vectorization["min_window"]     = 0
+        vectorization["max_window"]     = 0
+        vectorization["mean_window"]    = 0
+        vectorization["overlap"]        = 0
+
+        # Caracteristicas complejas
+        if self.rddd == 0:
+            vectorization["min_window"]  = -1
+            vectorization["max_window"]  = -1
+            vectorization["mean_window"]  = -1
+            vectorization["overlap"] = -1
+        else:
+            if self.rddd == 1:
+                # Ventana de cada trabajo
+                for job in range(self.numJobs):
+                    tproc_min  = np.sum(np.min(self.ProcessingTime[job,machine,:]) for machine in range(self.numMchs))
+                    tproc_max  = np.sum(np.max(self.ProcessingTime[job,machine,:]) for machine in range(self.numMchs))                    
+                    tproc_mean = np.sum(np.mean(self.ProcessingTime[job,machine,:]) for machine in range(self.numMchs)) 
+                    window     = self.ReleaseDueDate[job,1] - self.ReleaseDueDate[job,0]
+                    vectorization["min_window"]  += window / tproc_max 
+                    vectorization["max_window"]  += window / tproc_min 
+                    vectorization["mean_window"] += window / tproc_mean 
+                vectorization["min_window"]  = vectorization["min_window"]  / self.numJobs
+                vectorization["max_window"]  = vectorization["max_window"]  / self.numJobs
+                vectorization["mean_window"] = vectorization["mean_window"] / self.numJobs
+                # Overlap entre trabajos
+                for job in range(self.numJobs):
+                    for job2 in range(job + 1, self.numJobs):
+                        diff = min(self.ReleaseDueDate[job,1],self.ReleaseDueDate[job2,1])-max(self.ReleaseDueDate[job,0], self.ReleaseDueDate[job2,0])
+                        if diff > 0:
+                            vectorization["overlap"] += diff / (self.ReleaseDueDate[job,1] - self.ReleaseDueDate[job,0])
+                            vectorization["overlap"] += diff / (self.ReleaseDueDate[job2,1] - self.ReleaseDueDate[job2,0])
+                vectorization["overlap"] = vectorization["overlap"] / (self.numJobs * (self.numJobs - 1))
+            else:
+                # Ventana de cada operacion
+                for job in range(self.numJobs):
+                    for machine in range(self.numMchs):
+                        tproc_min  = np.min(self.ProcessingTime[job,machine,:])
+                        tproc_max  = np.max(self.ProcessingTime[job,machine,:])                   
+                        tproc_mean = np.mean(self.ProcessingTime[job,machine,:])
+                        window     = self.ReleaseDueDate[job,machine,1] - self.ReleaseDueDate[job,machine,0]
+                        vectorization["min_window"]  += window / tproc_max 
+                        vectorization["max_window"]  += window / tproc_min 
+                        vectorization["mean_window"] += window / tproc_mean 
+                vectorization["min_window"]  = vectorization["min_window"]  / (self.numJobs * self.numMchs)
+                vectorization["max_window"]  = vectorization["max_window"]  / (self.numJobs * self.numMchs)
+                vectorization["mean_window"] = vectorization["mean_window"] / (self.numJobs * self.numMchs)
+                # Overlap entre operaciones
+                for job1 in range(self.numJobs):
+                    for machine1 in range(self.numMchs):
+                        for job2 in range(job1 + 1, self.numJobs):
+                            diff = min(self.ReleaseDueDate[job1,machine1,1],self.ReleaseDueDate[job2,machine1,1])-max(self.ReleaseDueDate[job1,machine1,0],  self.ReleaseDueDate[job2,machine1,0])
+                            if diff > 0:
+                                vectorization["overlap"] += diff / (self.ReleaseDueDate[job1,machine1,1] - self.ReleaseDueDate[job1,machine1,0])
+                                vectorization["overlap"] += diff / (self.ReleaseDueDate[job2,machine1,1] -  self.ReleaseDueDate[job2,machine1,0])
+                vectorization["overlap"] = vectorization["overlap"] / (self.numJobs * (self.numJobs - 1) * self.numMchs)   
+        # Estadísticos de los datos
+        vectorization["max_processing_time_value"]     = np.max(self.ProcessingTime)
+        vectorization["min_processing_time_value"]     = np.min(self.ProcessingTime)
+        vectorization["mean_processing_time_value"]    = np.mean(self.ProcessingTime)
+
+        vectorization["max_energy_value"]     = np.max(self.ProcessingTime)
+        vectorization["min_energy_value"]     = np.min(self.ProcessingTime)
+        vectorization["mean_energy_value"]    = np.mean(self.ProcessingTime)
+        self.features = vectorization
+        return vectorization
+    
     def disjuntive_graph(self):
         vertex = list(range(self.numJobs * self.numMchs + 2))
         A = {v: [] for v in vertex}