Update run.py

run.py

@@ -8,6 +8,7 @@ import torch.optim as optim
 from torch.utils.data import DataLoader
 import json
 
+# إعداد المسارات
 dir_path = os.path.dirname(os.path.realpath(__file__))
 sys.path.append(os.path.join(dir_path, '..'))
 
@@ -16,41 +17,27 @@ from Actor.actor import Actor
 from dataloader import VRP_Dataset
 from google_solver.google_model import evaluate_google_model
 
-# Load params
+# تحميل الإعدادات
 with open('params.json', 'r') as f:
     params = json.load(f)
 
-# Settings
+# حفظ نسخة من الإعدادات
+os.makedirs("/data", exist_ok=True)
+with open('/data/params_saved.json', 'w') as f:
+    json.dump(params, f)
+
+# إعداد المتغيرات
 device = params['device']
 run_tests = params['run_tests']
 save_results = params['save_results']
 dataset_path = params['dataset_path']
 
-# Create persistent directory
-results_dir = os.path.join('/data', 'results')
-os.makedirs(results_dir, exist_ok=True)
-
-now = datetime.now()
-dt_string = now.strftime("%d-%m-%y %H-%M-%S")
-experiment_path = os.path.join(results_dir, dt_string)
-os.makedirs(experiment_path, exist_ok=True)
-
-train_results_file = os.path.join(experiment_path, 'train_results.txt')
-test_results_file = os.path.join(experiment_path, 'test_results.txt')
-model_path = os.path.join(experiment_path, 'model_state_dict.pt')
-optimizer_path = os.path.join(experiment_path, 'optimizer_state_dict.pt')
-
-with open(train_results_file, 'w') as f: pass
-with open(test_results_file, 'w') as f: pass
-with open(os.path.join(experiment_path, 'params.json'), 'w') as f:
-    json.dump(params, f)
-
-# Dataset sizes
+# حجم البيانات
 train_dataset_size = params['train_dataset_size']
 validation_dataset_size = params['validation_dataset_size']
 baseline_dataset_size = params['baseline_dataset_size']
 
-# Problem config
+# خصائص المشكلة
 num_nodes = params['num_nodes']
 num_depots = params['num_depots']
 embedding_size = params['embedding_size']
@@ -62,23 +49,19 @@ num_movers = params['num_movers']
 learning_rate = params['learning_rate']
 batch_size = params['batch_size']
 test_batch_size = params['test_batch_size']
-baseline_update_period = params['baseline_update_period']
 
-# Datasets
+# التحميل
 validation_dataset = VRP_Dataset(validation_dataset_size, num_nodes, num_depots, dataset_path, device)
 baseline_dataset = VRP_Dataset(train_dataset_size, num_nodes, num_depots, dataset_path, device)
-
 if params['overfit_test']:
-    train_dataset = VRP_Dataset(train_dataset_size, num_nodes, num_depots, dataset_path, device)
-    baseline_dataset = train_dataset
-    validation_dataset = train_dataset
+    train_dataset = baseline_dataset = validation_dataset = VRP_Dataset(train_dataset_size, num_nodes, num_depots, dataset_path, device)
 
-# Evaluate Google solver
+# تقييم Google OR-Tools
 google_scores = evaluate_google_model(validation_dataset)
 tot_google_scores = google_scores.sum().item()
 input_size = validation_dataset.model_input_length()
 
-# Models
+# تعريف النماذج
 model = Model(input_size=input_size, embedding_size=embedding_size, decoder_input_size=params["decoder_input_size"])
 actor = Actor(model=model, num_movers=num_movers, num_neighbors_encoder=num_neighbors_encoder,
               num_neighbors_action=num_neighbors_action, device=device, normalize=False)
@@ -95,11 +78,17 @@ nn_actor.nearest_neighbors()
 
 optimizer = optim.Adam(params=actor.parameters(), lr=learning_rate)
 
+# ملفات الإخراج
+train_results_file = "/data/train_results.txt"
+test_results_file = "/data/test_results.txt"
+model_path = "/data/model_state_dict.pt"
+optimizer_path = "/data/optimizer_state_dict.pt"
+
 train_batch_record = 100
 validation_record = 100
 baseline_record = None
 
-# Training loop
+# التدريب
 for epoch in range(params['num_epochs']):
     if not params['overfit_test']:
         train_dataset = VRP_Dataset(train_dataset_size, num_nodes, num_depots, dataset_path, device)
@@ -107,7 +96,6 @@ for epoch in range(params['num_epochs']):
     train_dataloader = DataLoader(train_dataset, batch_size=batch_size, collate_fn=train_dataset.collate)
     for i, batch in enumerate(train_dataloader):
         with torch.no_grad():
-            nn_actor.nearest_neighbors()
             nn_output = nn_actor(batch)
             tot_nn_cost = nn_output['total_time'].sum().item()
 
@@ -129,75 +117,66 @@ for epoch in range(params['num_epochs']):
 
         tot_actor_cost = actor_cost.sum().item()
         tot_baseline_cost = baseline_cost.sum().item()
-
         actor_nn_ratio = tot_actor_cost / tot_nn_cost
         actor_baseline_ratio = tot_actor_cost / tot_baseline_cost
         train_batch_record = min(train_batch_record, actor_nn_ratio)
 
         result = f"{epoch}, {i}, {actor_nn_ratio:.4f}, {actor_baseline_ratio:.4f}, {train_batch_record:.4f}"
-        print(result, flush=True)
+        print(result)
         if save_results:
             with open(train_results_file, 'a') as f:
                 f.write(result + '\n')
         del batch
 
-    # Validation
+    # التحقق من الأد��ء
     if epoch % 5 == 0:
         baseline_dataloader = DataLoader(baseline_dataset, batch_size=batch_size, collate_fn=baseline_dataset.collate)
         tot_cost = []
         for batch in baseline_dataloader:
             with torch.no_grad():
                 actor.greedy_search()
-                actor_output = actor(batch)
-                cost = actor_output['total_time']
+                cost = actor(batch)['total_time']
             tot_cost.append(cost)
-        del batch
-
         tot_cost = torch.cat(tot_cost, dim=0)
         if baseline_record is None or (tot_cost < baseline_record).float().mean().item() > 0.9:
             baseline_record = tot_cost
             baseline_actor.load_state_dict(actor.state_dict())
             print('\nNew baseline record\n')
 
+    # التقييم وحفظ النموذج
+    if run_tests:
+        b = max(int(batch_size // sample_size**2), 1)
+        validation_dataloader = DataLoader(validation_dataset, batch_size=b, collate_fn=validation_dataset.collate)
 
-# Test block (اختبار النموذج بعد كل 10 epochs)
-if (epoch % 10 == 0) and run_tests:
-    b = max(int(batch_size // sample_size**2), 1)
-    validation_dataloader = DataLoader(validation_dataset, batch_size=b, collate_fn=validation_dataset.collate)
-
-    tot_cost = 0
-    tot_nn_cost = 0
-    for batch in validation_dataloader:
-        with torch.no_grad():
-            actor.beam_search(sample_size)
-            actor_output = actor(batch)
-            cost = actor_output['total_time']
-
-            nn_actor.nearest_neighbors()
-            nn_output = nn_actor(batch)
-            nn_cost = nn_output['total_time']
-
-        tot_cost += cost.sum().item()
-        tot_nn_cost += nn_cost.sum().item()
-
-    ratio = tot_cost / tot_nn_cost
-    validation_record = min(validation_record, ratio)
-    actor_google_ratio = tot_cost / tot_google_scores
+        tot_cost = 0
+        tot_nn_cost = 0
+        for batch in validation_dataloader:
+            with torch.no_grad():
+                actor.beam_search(sample_size)
+                actor_output = actor(batch)
+                cost = actor_output['total_time']
 
-    print(f"\nTest results:\nActor/Google: {actor_google_ratio:.4f}, Actor/NN: {ratio:.4f}, Best NN Ratio: {validation_record:.4f}\n")
+                nn_output = nn_actor(batch)
+                nn_cost = nn_output['total_time']
 
-# ✅ حفظ النتائج والنموذج بعد كل اختبار
-if save_results:
-    with open(test_results_file, 'a') as f:
-        f.write(f"{epoch}, {actor_google_ratio:.4f}, {ratio:.4f}, {validation_record:.4f}\n")
-    
-    # حفظ النموذج والـ optimizer دائمًا
-    torch.save(actor.state_dict(), model_path)
-    torch.save(optimizer.state_dict(), optimizer_path)
+            tot_cost += cost.sum().item()
+            tot_nn_cost += nn_cost.sum().item()
 
-    # نسخة احتياطية كل 10 epochs
-    torch.save(actor.state_dict(), f"model_epoch_{epoch}.pt")
-    torch.save(optimizer.state_dict(), f"optimizer_epoch_{epoch}.pt")
+        ratio = tot_cost / tot_nn_cost
+        validation_record = min(validation_record, ratio)
+        actor_google_ratio = tot_cost / tot_google_scores
+        print(f"\nTest results:\nActor/Google: {actor_google_ratio:.4f}, Actor/NN: {ratio:.4f}, Best NN Ratio: {validation_record:.4f}\n")
 
+        if save_results:
+            # حفظ دائم
+            with open(test_results_file, 'a') as f:
+                f.write(f"{epoch}, {actor_google_ratio:.4f}, {ratio:.4f}, {validation_record:.4f}\n")
+            torch.save(actor.state_dict(), model_path)
+            torch.save(optimizer.state_dict(), optimizer_path)
+
+            # نسخة احتياطية كل 10 epochs
+            if epoch % 10 == 0:
+                torch.save(actor.state_dict(), f"/data/model_epoch_{epoch}.pt")
+                torch.save(optimizer.state_dict(), f"/data/optimizer_epoch_{epoch}.pt")
 
 print("End.")