IGJSP 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

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}

{igjsp-0.0.7.dist-info → igjsp-0.0.9.dist-info}/METADATA

@@ -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.dist-info → igjsp-0.0.9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-IGJSP/generador.py,sha256=SCrBT8lMOHUMk6ga__yhnYKFdSZL4c38WCNupZsVsxg,21983
+IGJSP/generador.py,sha256=Cwuhy7U15OOzYJ-hpFvGutaiB1Q2PMtW6KaUt4GmoOo,27517
 IGJSP/main.py,sha256=qnpAdI9Nymfbb2t674EHKCZr1vG80tGyVT5RKMiGvZM,2727
 IGJSP/Minizinc/Models/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
 IGJSP/Minizinc/Models/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
@@ -9,7 +9,7 @@ IGJSP/Minizinc/Types/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnj
 IGJSP/Minizinc/Types/RD/type0.dzn,sha256=alo54TrPd2svp-YeOq8rNhb42Aj5w4N1y1WYRxZ-aWM,225
 IGJSP/Minizinc/Types/RD/type1.dzn,sha256=r3f1uOoDnscjpXHbpvOWPGhGN0tmwkJ3NYIRP-NGk5M,298
 IGJSP/Minizinc/Types/RD/type2.dzn,sha256=ddJxLqR_WlUpycHhA_QulxiTx3o9neIzNESEt59VUx0,344
-igjsp-0.0.7.dist-info/METADATA,sha256=UdQnruAWlMoiVnF9FJ-2V3Brpa2EI4NWUwLYITlUe4g,7406
-igjsp-0.0.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-igjsp-0.0.7.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
-igjsp-0.0.7.dist-info/RECORD,,
+igjsp-0.0.9.dist-info/METADATA,sha256=astGQyCgjsoLf8uA-25Ezh1M0qTidVN9LHZenflRWJU,7406
+igjsp-0.0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+igjsp-0.0.9.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
+igjsp-0.0.9.dist-info/RECORD,,