Gameserver update

.github/workflows/build_and_run.yaml

@@ -60,7 +60,7 @@ jobs:
       - name: Sanity check
         working-directory: ./AIAgent
         run: |
-            if ls *.pkl 1> /dev/null 2>&1; then
+            if ls report/optuna_studies/*.pkl 1> /dev/null 2>&1; then
                 echo "PKL files found."
             else
                 echo "No PKL files found."

.gitignore

@@ -163,3 +163,5 @@ cython_debug/
 # MacOS specific
 .DS_Store
 *report/
+
+.mono/

AIAgent/common/classes.py

@@ -1,11 +1,18 @@
 from collections import defaultdict
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Optional, TypeAlias
 
-from common.game import GameMap
 from dataclasses_json import dataclass_json
+from pydantic import Field, field_validator
+from pydantic.dataclasses import dataclass as pydantic_dataclass
+from connection.broker_conn.classes import SVMInfo
+from common.game import GameMap
 from ml.protocols import Named
 
+PlatformName: TypeAlias = str
+SVMInfoName: TypeAlias = str
+
 
 @dataclass_json
 @dataclass
@@ -52,12 +59,50 @@ class Map2Result:
 AgentResultsOnGameMaps: TypeAlias = defaultdict[Named, list[Map2Result]]
 
 
-@dataclass_json
-@dataclass
-class SVMInfo:
-    name: str
-    count: int
-    launch_command: str
-    min_port: int
-    max_port: int
-    server_working_dir: str
+@pydantic_dataclass
+class DatasetConfig:
+    dataset_base_path: Path  # path to dir with explored dlls
+    dataset_description: Path  # full paths to JSON-file with dataset description
+
+    @field_validator("dataset_base_path", "dataset_description", mode="before")
+    @classmethod
+    def transform(cls, input: str) -> Path:
+        return Path(input).resolve()
+
+
+@pydantic_dataclass
+class Platform:
+    name: PlatformName
+    DatasetConfigs: list[DatasetConfig]
+    SVMInfo: SVMInfo
+
+
+@pydantic_dataclass
+class OptunaConfig:
+    n_startup_trials: int  # number of optuna's trials
+    n_trials: int  # number of optuna's trials
+    n_jobs: int
+    study_direction: str
+
+
+@pydantic_dataclass
+class TrainingConfig:
+    dynamic_dataset: bool
+    train_percentage: float
+    threshold_coverage: int
+    load_to_cpu: bool
+    epochs: int
+    threshold_steps_number: Optional[int] = Field(default=None)
+
+
+@pydantic_dataclass
+class Config:
+    Platforms: list[Platform]
+    OptunaConfig: OptunaConfig
+    TrainingConfig: TrainingConfig
+    path_to_weights: Optional[Path] = Field(default=None)
+
+    @field_validator("path_to_weights", mode="before")
+    @classmethod
+    def transform(cls, input: Optional[str]) -> Optional[Path]:
+        return Path(input).absolute() if input is not None else None

AIAgent/common/game.py

@@ -1,6 +1,6 @@
-from dataclasses import dataclass
-
-from dataclasses_json import dataclass_json
+from dataclasses import dataclass, field
+from dataclasses_json import config, dataclass_json
+from connection.broker_conn.classes import SingleSVMInfo
 
 
 @dataclass_json
@@ -74,6 +74,9 @@ class GameMap:
     NameOfObjectToCover: str
     DefaultSearcher: str
     MapName: str
+    SVMInfo: SingleSVMInfo = field(
+        default=None, metadata=config(exclude=lambda x: True)
+    )
 
 
 @dataclass_json

AIAgent/config.py

@@ -21,17 +21,6 @@ class WebsocketSourceLinks:
     POST_WS = f"http://0.0.0.0:{BrokerConfig.BROKER_PORT}/post_ws"
 
 
-class TrainingConfig:
-    DYNAMIC_DATASET = True
-    TRAIN_PERCENTAGE = 1
-    THRESHOLD_COVERAGE = 100
-    THRESHOLD_STEPS_NUMBER = None
-    LOAD_TO_CPU = False
-
-    OPTUNA_N_JOBS = 1
-    STUDY_DIRECTION = "maximize"
-
-
 @dataclass(slots=True, frozen=True)
 class DumpByTimeoutFeature:
     enabled: bool

AIAgent/connection/broker_conn/classes.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Callable, TypeAlias
+from pydantic.dataclasses import dataclass as pydantic_dataclass
 
 from config import FeatureConfig
 from connection.game_server_conn.unsafe_json import asdict
@@ -18,5 +19,25 @@ class ServerInstanceInfo:
     pid: int | Undefined
 
 
+@pydantic_dataclass(config=dict(extra="ignore"))
+class SingleSVMInfo:
+    name: str
+    launch_command: str
+    min_port: int
+    max_port: int
+    server_working_dir: str
+
+    def to_dict(self):  # GameMap class requires the to_dict method for all its fields
+        return self.__dict__
+
+
+@pydantic_dataclass
+class SVMInfo(SingleSVMInfo):
+    count: int
+
+    def create_single_svm_info(self) -> SingleSVMInfo:
+        return SingleSVMInfo(**self.__dict__)
+
+
 def custom_encoder_if_disable_message_checks() -> Callable | None:
     return asdict if FeatureConfig.DISABLE_MESSAGE_CHECKS else None

AIAgent/connection/broker_conn/requests.py

@@ -3,14 +3,13 @@
 from urllib.parse import urlencode
 
 import httplib2
-from common.classes import SVMInfo
 from config import WebsocketSourceLinks
-from connection.broker_conn.classes import ServerInstanceInfo
+from connection.broker_conn.classes import ServerInstanceInfo, SingleSVMInfo
 
 
-def acquire_instance(svm_info: SVMInfo) -> ServerInstanceInfo:
+def acquire_instance(svm_info: SingleSVMInfo) -> ServerInstanceInfo:
     response, content = httplib2.Http().request(
-        WebsocketSourceLinks.GET_WS + "?" + urlencode(SVMInfo.to_dict(svm_info))
+        WebsocketSourceLinks.GET_WS + "?" + urlencode(SingleSVMInfo.to_dict(svm_info))
     )
     if response.status != 200:
         logging.error(f"{response.status} with {content=} on acquire_instance call")

AIAgent/connection/broker_conn/socket_manager.py

@@ -3,9 +3,8 @@
 from contextlib import contextmanager, suppress
 
 import websocket
-from common.classes import SVMInfo
 from config import GameServerConnectorConfig
-from connection.broker_conn.classes import ServerInstanceInfo
+from connection.broker_conn.classes import ServerInstanceInfo, SingleSVMInfo
 from connection.broker_conn.requests import acquire_instance, return_instance
 
 
@@ -38,7 +37,7 @@ def wait_for_connection(server_instance: ServerInstanceInfo):
 
 
 @contextmanager
-def game_server_socket_manager(svm_info: SVMInfo):
+def game_server_socket_manager(svm_info: SingleSVMInfo):
     server_instance = acquire_instance(svm_info)
 
     socket = wait_for_connection(server_instance)

AIAgent/epochs_statistics.py

@@ -1,9 +1,8 @@
-import multiprocessing as mp
 from dataclasses import dataclass
-from multiprocessing.managers import BaseManager
+from enum import Enum
 from pathlib import Path
 from statistics import mean
-from typing import TypeAlias
+from typing import Optional, TypeAlias
 
 import natsort
 import pandas as pd
@@ -24,7 +23,6 @@ class TrainingParams:
     num_hops_1: int
     num_hops_2: int
     num_of_state_features: int
-    epochs: int
 
 
 @dataclass
@@ -33,62 +31,116 @@ class StatsWithTable:
     df: pd.DataFrame
 
 
-class StatisticsCollector:
-    _lock = mp.Lock()
+class SVMStatus(Enum):
+    RUNNING = "running"
+    FAILED = "failed"
+    FINISHED = "finished"
+
+
+@dataclass
+class Status:
+    """
+    status : SVMStatus.RUNNING | SVMStatus.FAILED | SVMStatus.FINISHED
+    """
+
+    status: SVMStatus
+    epoch: int
+
+    def __str__(self) -> str:
+        result: str = f"status={self.status.value}"
+        if self.status == SVMStatus.FAILED:
+            result += f", on epoch = {self.epoch}"
+        return result
 
+
+class StatisticsCollector:
     def __init__(
         self,
-        SVM_count: int,
         file: Path,
     ):
-        self._SVM_count: int = SVM_count
         self._file = file
 
-        self._SVMS_info: dict[SVMName, TrainingParams] = {}
+        self._svms_info: dict[SVMName, Optional[TrainingParams]] = {}
+        self._epochs: dict[SVMName, Optional[EpochNumber]] = {}
         self._sessions_info: dict[EpochNumber, dict[SVMName, StatsWithTable]] = {}
+        self._status: dict[SVMName, Status] = {}
+
+        self._running: Optional[SVMName] = None
 
-    def register_training_session(
+    def register_new_training_session(self, svm_name: SVMName):
+        self._running = svm_name
+        self._svms_info[svm_name] = None
+        self._epochs[svm_name] = None
+        self._svms_info = sort_dict(self._svms_info)
+        self._update_file()
+
+    def start_training_session(
         self,
-        SVM_name: SVMName,
         batch_size: int,
         lr: float,
         num_hops_1: int,
         num_hops_2: int,
         num_of_state_features: int,
         epochs: int,
     ):
-        self._SVMS_info[SVM_name] = TrainingParams(
-            batch_size, lr, num_hops_1, num_hops_2, num_of_state_features, epochs
+        svm_name = self._running
+        self._epochs[svm_name] = epochs
+        self._status[svm_name] = Status(SVMStatus.RUNNING, 0)
+
+        self._svms_info[svm_name] = TrainingParams(
+            batch_size, lr, num_hops_1, num_hops_2, num_of_state_features
         )
-        self._SVMS_info = sort_dict(self._SVMS_info)
+        self._update_file()
+
+    def fail(self):
+        svm_name = self._running
+        self._status[svm_name].status = SVMStatus.FAILED
+        self._running = None
+        self._update_file()
+
+    def finish(self):
+        svm_name = self._running
+        self._status[svm_name].status = SVMStatus.FINISHED
+        self._running = None
         self._update_file()
 
     def update_results(
         self,
-        epoch: EpochNumber,
-        SVM_name: SVMName,
         average_result: float,
         map2results_list: list[Map2Result],
     ):
+        svm_name = self._running
+        epoch = self._status[svm_name].epoch
+
         results = self._sessions_info.get(epoch, {})
-        results[SVM_name] = StatsWithTable(
-            average_result, convert_to_df(SVM_name, map2results_list)
+        results[svm_name] = StatsWithTable(
+            average_result, convert_to_df(svm_name, map2results_list)
         )
         self._sessions_info[epoch] = sort_dict(results)
+        self._status[svm_name].epoch += 1
         self._update_file()
 
-    def _get_SVMS_info(self) -> str:
-        svm_info_line = lambda svm_info: (
-            f"{svm_info[0]} : "
-            f"batch_size={svm_info[1].batch_size}, "
-            f"lr={svm_info[1].lr}, "
-            f"num_hops_1={svm_info[1].num_hops_1}, "
-            f"num_hops_2={svm_info[1].num_hops_2}, "
-            f"num_of_state_features={svm_info[1].num_of_state_features}, "
-            f"epochs={svm_info[1].epochs}\n"
-        )
+    def _get_training_info(self) -> str:
+        def svm_info_line(svm_info):
+            svm_name, training_params = svm_info[0], svm_info[1]
+            epochs = self._epochs[svm_name]
+            status: Optional[Status] = self._status.get(svm_name, None)
+            if status is None:
+                return ""
+
+            svm_info_line = (
+                f"{svm_name} : "
+                f"{str(status)}, "
+                f"epochs={epochs}, "
+                f"batch_size={training_params.batch_size}, "
+                f"lr={training_params.lr}, "
+                f"num_hops_1={training_params.num_hops_1}, "
+                f"num_hops_2={training_params.num_hops_2}, "
+                f"num_of_state_features={training_params.num_of_state_features}\n"
+            )
+            return svm_info_line
 
-        return "".join(list(map(svm_info_line, self._SVMS_info.items())))
+        return "".join(list(map(svm_info_line, self._svms_info.items())))
 
     def _get_epochs_results(self) -> str:
         epochs_results = str()
@@ -113,11 +165,10 @@ def _get_epochs_results(self) -> str:
         return epochs_results
 
     def _update_file(self):
-        with self._lock:
-            SVMS_info = self._get_SVMS_info()
-            epochs_results = self._get_epochs_results()
+        svms_info = self._get_training_info()
+        epochs_results = self._get_epochs_results()
         with open(self._file, "w") as f:
-            f.write(SVMS_info)
+            f.write(svms_info)
             f.write(epochs_results)
 
 
@@ -133,10 +184,3 @@ def convert_to_df(svm_name: SVMName, map2result_list: list[Map2Result]) -> pd.Da
     df = pd.DataFrame(results, columns=["Game result"], index=maps).T
 
     return df
-
-
-class StatisticsManager(BaseManager):
-    pass
-
-
-StatisticsManager.register("StatisticsCollector", StatisticsCollector)