finish problem statement

Author: Demoren1

Udeneev2025Surrogate.pdf

@@ -445,44 +445,53 @@
    },
    "outputs": [],
    "source": [
-    "def evaluate_and_save_results(models, architectures, batch_size=1024, num_workers=6, folder_name=\"results\"):\n",
+    "def evaluate_and_save_results(\n",
+    "    models, architectures, valid_loader, folder_name=\"results\"\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Оценивает модели на валидационном наборе данных и сохраняет результаты в файлы JSON.\n",
+    "    Аргументы:\n",
+    "    models (list): Список обученных моделей.\n",
+    "    architectures (list): Список архитектур моделей.\n",
+    "    valid_loader (DataLoader): DataLoader для валидационных данных.\n",
+    "    folder_name (str, необязательно): Имя папки для сохранения результатов. По умолчанию \"results\".\n",
+    "    Исключения:\n",
+    "    ValueError: Если количество моделей и архитектур не совпадает.\n",
+    "    Результаты:\n",
+    "    Для каждой модели создается файл JSON с результатами, содержащий:\n",
+    "    - architecture: Архитектура модели.\n",
+    "    - valid_predictions: Предсказания модели на валидационном наборе данных.\n",
+    "    - valid_accuracy: Точность модели на валидационном наборе данных.\n",
+    "    \"\"\"\n",
     "    if len(models) != len(architectures):\n",
     "        raise ValueError(\"Количество моделей и архитектур должно совпадать\")\n",
     "\n",
     "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
     "    os.makedirs(folder_name, exist_ok=True)\n",
     "\n",
-    "    transform = transforms.Compose([\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)),\n",
-    "    ])\n",
-    "    test_dataset = CIFAR10(root=\"./data\", train=False, download=True, transform=transform)\n",
-    "    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers)\n",
-    "\n",
     "    for i, (model, architecture) in enumerate(zip(models, architectures)):\n",
     "        model.to(device)\n",
     "        model.eval()\n",
     "\n",
-    "        test_correct = 0\n",
-    "        test_total = 0\n",
-    "        test_preds = []\n",
+    "        valid_correct = 0\n",
+    "        valid_total = 0\n",
+    "        valid_preds = []\n",
     "\n",
-    "        # Оценка на тестовом датасете\n",
     "        with torch.no_grad():\n",
-    "            for images, labels in test_loader:\n",
+    "            for images, labels in valid_loader:\n",
     "                images, labels = images.to(device), labels.to(device)\n",
     "                outputs = model(images)\n",
     "                _, predicted = torch.max(outputs, 1)\n",
-    "                test_preds.extend(predicted.cpu().tolist())\n",
-    "                test_correct += (predicted == labels).sum().item()\n",
-    "                test_total += labels.size(0)\n",
-    "        \n",
-    "        test_accuracy = test_correct / test_total\n",
+    "                valid_preds.extend(predicted.cpu().tolist())\n",
+    "                valid_correct += (predicted == labels).sum().item()\n",
+    "                valid_total += labels.size(0)\n",
+    "\n",
+    "        valid_accuracy = valid_correct / valid_total\n",
     "\n",
     "        result = {\n",
     "            \"architecture\": architecture,\n",
-    "            \"test_predictions\": test_preds,\n",
-    "            \"test_accuracy\": test_accuracy\n",
+    "            \"valid_predictions\": valid_preds,\n",
+    "            \"valid_accuracy\": valid_accuracy,\n",
     "        }\n",
     "\n",
     "        file_name = f\"model_{i+1}_results.json\"\n",
@@ -491,7 +500,7 @@
     "        with open(file_path, \"w\") as f:\n",
     "            json.dump(result, f, indent=4)\n",
     "\n",
-    "        print(f\"Results for model_{i + 1} saved to {file_path}\")\n"
+    "        print(f\"Results for model_{i + 1} saved to {file_path}\")"
    ]
   },
   {
@@ -630,7 +639,7 @@
    "sourceType": "notebook"
   },
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "usr",
    "language": "python",
    "name": "python3"
   },
@@ -644,7 +653,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

code/train_models.ipynb

@@ -118,66 +118,52 @@ def train_model(
     return model
 
 def evaluate_and_save_results(
-    models, architectures, batch_size=512, num_workers=6, folder_name="results"
+    models, architectures, valid_loader, folder_name="results"
 ):
     """
-    Оценивает модели на тестовом наборе данных CIFAR-10 и сохраняет результаты в файлы JSON.
+    Оценивает модели на валидационном наборе данных и сохраняет результаты в файлы JSON.
     Аргументы:
     models (list): Список обученных моделей.
     architectures (list): Список архитектур моделей.
-    batch_size (int, необязательно): Размер батча для загрузчика данных. По умолчанию 1024.
-    num_workers (int, необязательно): Количество потоков для загрузчика данных. По умолчанию 6.
+    valid_loader (DataLoader): DataLoader для валидационных данных.
     folder_name (str, необязательно): Имя папки для сохранения результатов. По умолчанию "results".
     Исключения:
     ValueError: Если количество моделей и архитектур не совпадает.
     Результаты:
     Для каждой модели создается файл JSON с результатами, содержащий:
     - architecture: Архитектура модели.
-    - test_predictions: Предсказания модели на тестовом наборе данных.
-    - test_accuracy: Точность модели на тестовом наборе данных.
+    - valid_predictions: Предсказания модели на валидационном наборе данных.
+    - valid_accuracy: Точность модели на валидационном наборе данных.
     """
     if len(models) != len(architectures):
         raise ValueError("Количество моделей и архитектур должно совпадать")
 
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     os.makedirs(folder_name, exist_ok=True)
 
-    transform = transforms.Compose(
-        [
-            transforms.ToTensor(),
-            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)),
-        ]
-    )
-    test_dataset = CIFAR10(
-        root="./data", train=False, download=True, transform=transform
-    )
-    test_loader = DataLoader(
-        test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers
-    )
-
     for i, (model, architecture) in enumerate(zip(models, architectures)):
         model.to(device)
         model.eval()
 
-        test_correct = 0
-        test_total = 0
-        test_preds = []
+        valid_correct = 0
+        valid_total = 0
+        valid_preds = []
 
         with torch.no_grad():
-            for images, labels in test_loader:
+            for images, labels in valid_loader:
                 images, labels = images.to(device), labels.to(device)
                 outputs = model(images)
                 _, predicted = torch.max(outputs, 1)
-                test_preds.extend(predicted.cpu().tolist())
-                test_correct += (predicted == labels).sum().item()
-                test_total += labels.size(0)
+                valid_preds.extend(predicted.cpu().tolist())
+                valid_correct += (predicted == labels).sum().item()
+                valid_total += labels.size(0)
 
-        test_accuracy = test_correct / test_total
+        valid_accuracy = valid_correct / valid_total
 
         result = {
             "architecture": architecture,
-            "test_predictions": test_preds,
-            "test_accuracy": test_accuracy,
+            "valid_predictions": valid_preds,
+            "valid_accuracy": valid_accuracy,
         }
 
         file_name = f"model_{i+1}_results.json"
@@ -195,8 +181,6 @@ def evaluate_and_save_results(
         batch_size=BATCH_SIZE
     )  # Получаем загрузчики CIFAR10
 
-    models = []
-    architectures = []
     for architecture in tqdm(arch_dicts):
         model = train_model(  # Обучаем модель
             architecture,
@@ -205,10 +189,8 @@ def evaluate_and_save_results(
             max_epochs=MAX_EPOCHS,
             learning_rate=LEARNING_RATE,
         )
-        models.append(model)
-        architectures.append(architecture)
         clear_output(wait=True)
-
-    evaluate_and_save_results(
-        models, architectures, batch_size=BATCH_SIZE
-    )  # Оцениваем и сохраняем архитектуры, предсказания на тестовом наборе CIFAR10 и accuracy
+        
+        evaluate_and_save_results(
+            [model], [architecture], valid_loader=search_valid_loader, folder_name="results"
+        )  # Оцениваем и сохраняем архитектуры, предсказания на тестовом наборе CIFAR10 и accuracy