sdgym 0.14.1.dev0__tar.gz → 0.14.2.dev0__tar.gz

{sdgym-0.14.1.dev0/sdgym.egg-info → sdgym-0.14.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdgym
-Version: 0.14.1.dev0
+Version: 0.14.2.dev0
 Summary: Benchmark tabular synthetic data generators using a variety of datasets
 Author-email: "DataCebo, Inc." <info@sdv.dev>
 License-Expression: BUSL-1.1

{sdgym-0.14.1.dev0 → sdgym-0.14.2.dev0}/pyproject.toml

@@ -143,11 +143,13 @@ namespaces = false
     'make.bat',
     '*.jpg',
     '*.png',
-    '*.gif'
+    '*.gif',
+    '*.yaml'
 ]
 'sdgym' = [
     'leaderboard.csv',
-    'synthesizer_descriptions.yaml'
+    'synthesizer_descriptions.yaml',
+    '_benchmark_launcher/*.yaml',
 ]
 
 [tool.setuptools.exclude-package-data]
@@ -161,7 +163,7 @@ namespaces = false
 version = {attr = 'sdgym.__version__'}
 
 [tool.bumpversion]
-current_version = "0.14.1.dev0"
+current_version = "0.14.2.dev0"
 parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<candidate>\d+))?'
 serialize = [
     '{major}.{minor}.{patch}.{release}{candidate}',

{sdgym-0.14.1.dev0 → sdgym-0.14.2.dev0}/sdgym/__init__.py

@@ -8,7 +8,7 @@ __author__ = 'DataCebo, Inc.'
 __copyright__ = 'Copyright (c) 2022 DataCebo, Inc.'
 __email__ = 'info@sdv.dev'
 __license__ = 'BSL-1.1'
-__version__ = '0.14.1.dev0'
+__version__ = '0.14.2.dev0'
 
 import logging
 

{sdgym-0.14.1.dev0 → sdgym-0.14.2.dev0}/sdgym/_benchmark/benchmark.py

@@ -9,7 +9,7 @@ from sdgym._benchmark.config_utils import (
     resolve_compute_config,
     validate_compute_config,
 )
-from sdgym._benchmark.credentials_utils import get_credentials, sdv_install_cmd
+from sdgym._benchmark.credentials_utils import sdv_install_cmd
 from sdgym.benchmark import (
     DEFAULT_MULTI_TABLE_DATASETS,
     DEFAULT_MULTI_TABLE_SYNTHESIZERS,
@@ -349,7 +349,7 @@ def _run_on_gcp(
 
 def _benchmark_compute_gcp(
     output_destination,
-    credential_filepath,
+    credentials,
     compute_config,
     synthesizers,
     sdv_datasets,
@@ -364,7 +364,6 @@ def _benchmark_compute_gcp(
 ):
     """Run the SDGym benchmark on datasets for the given modality."""
     compute_config = resolve_compute_config('gcp', compute_config)
-    credentials = get_credentials(credential_filepath)
     validate_compute_config(compute_config)
 
     s3_client = _validate_output_destination(
@@ -407,7 +406,7 @@ def _benchmark_compute_gcp(
             sdmetrics=sdmetrics,
         )
 
-    _run_on_gcp(
+    instance_name = _run_on_gcp(
         output_destination=output_destination,
         synthesizers=synthesizers,
         s3_client=s3_client,
@@ -416,10 +415,12 @@ def _benchmark_compute_gcp(
         compute_config=compute_config,
     )
 
+    return instance_name
+
 
 def _benchmark_single_table_compute_gcp(
     output_destination,
-    credential_filepath,
+    credentials,
     compute_config=None,
     synthesizers=DEFAULT_SINGLE_TABLE_SYNTHESIZERS,
     sdv_datasets=DEFAULT_SINGLE_TABLE_DATASETS,
@@ -436,8 +437,8 @@ def _benchmark_single_table_compute_gcp(
     Args:
         output_destination (str):
             The S3 URI where results will be stored.
-        credential_filepath (str or Path):
-            Path to the credentials file for AWS, GCP and SDV-Enterprise.
+        credentials (dict):
+            The credentials for AWS, GCP and SDV-Enterprise.
         compute_config (dict, optional):
             The compute configuration for the GCP instance. If None, default settings will be used.
         synthesizers (list of dict, optional):
@@ -461,7 +462,7 @@ def _benchmark_single_table_compute_gcp(
     """
     return _benchmark_compute_gcp(
         output_destination=output_destination,
-        credential_filepath=credential_filepath,
+        credentials=credentials,
         compute_config=compute_config,
         synthesizers=synthesizers,
         sdv_datasets=sdv_datasets,
@@ -478,7 +479,7 @@ def _benchmark_single_table_compute_gcp(
 
 def _benchmark_multi_table_compute_gcp(
     output_destination,
-    credential_filepath,
+    credentials,
     compute_config=None,
     synthesizers=DEFAULT_MULTI_TABLE_SYNTHESIZERS,
     sdv_datasets=DEFAULT_MULTI_TABLE_DATASETS,
@@ -494,8 +495,8 @@ def _benchmark_multi_table_compute_gcp(
     Args:
         output_destination (str):
             The S3 URI where results will be stored.
-        credential_filepath (str or Path):
-            Path to the credentials file for AWS, GCP and SDV-Enterprise.
+        credentials (dict):
+            The credentials for AWS, GCP and SDV-Enterprise.
         compute_config (dict, optional):
             The compute configuration for the GCP instance. If None, default settings will be used.
         synthesizers (list of dict, optional):
@@ -517,7 +518,7 @@ def _benchmark_multi_table_compute_gcp(
     """
     return _benchmark_compute_gcp(
         output_destination=output_destination,
-        credential_filepath=credential_filepath,
+        credentials=credentials,
         compute_config=compute_config,
         synthesizers=synthesizers,
         sdv_datasets=sdv_datasets,

sdgym-0.14.2.dev0/sdgym/_benchmark/credentials_utils.py

@@ -0,0 +1,17 @@
+import textwrap
+
+
+def sdv_install_cmd(credentials):
+    """Return the shell command to install sdv-enterprise using sdv-installer."""
+    sdv_creds = credentials.get('sdv_enterprise') or {}
+    username = sdv_creds.get('sdv_enterprise_username')
+    license_key = sdv_creds.get('sdv_enterprise_license_key')
+    if not (username and license_key):
+        return ''
+
+    return textwrap.dedent(f"""\
+pip install sdv-installer
+
+python -c "from sdv_installer.installation.installer import install_packages; \\
+install_packages(username='{username}', license_key='{license_key}')"
+""")

sdgym-0.14.2.dev0/sdgym/_benchmark_launcher/__init__.py

@@ -0,0 +1,6 @@
+"""Benchmark Launcher Module."""
+
+from sdgym._benchmark_launcher.benchmark_config import BenchmarkConfig
+from sdgym._benchmark_launcher.benchmark_launcher import BenchmarkLauncher
+
+__all__ = ('BenchmarkConfig', 'BenchmarkLauncher')

sdgym-0.14.2.dev0/sdgym/_benchmark_launcher/_instance_manager.py

@@ -0,0 +1,115 @@
+import logging
+
+from google.cloud import compute_v1
+from google.oauth2 import service_account
+
+from sdgym._benchmark_launcher._validation import _validate_gcp_credentials
+from sdgym._benchmark_launcher.utils import resolve_credentials
+
+LOGGER = logging.getLogger(__name__)
+
+
+class BaseInstanceManager:
+    """Base class for compute-service-specific instance managers."""
+
+    def list_instances(self):
+        """Return non-terminated instances."""
+        raise NotImplementedError
+
+    def update_instance_statuses(self, instance_names, instance_name_to_status):
+        """Update launcher-tracked instance statuses in place."""
+        raise NotImplementedError
+
+    def terminate_instances(self, instance_names, verbose):
+        """Terminate instances and return deleted instance names."""
+        raise NotImplementedError
+
+
+class GCPInstanceManager(BaseInstanceManager):
+    """Manage GCP benchmark instances."""
+
+    def __init__(self, credentials_filepath):
+        self.credentials_filepath = credentials_filepath
+
+    def _get_client(self):
+        """Build and return the GCP client and project id."""
+        credentials = resolve_credentials(self.credentials_filepath)
+        errors = _validate_gcp_credentials(credentials)
+        if errors:
+            error_message = '\n'.join(errors)
+            raise ValueError(f'Invalid GCP credentials:\n{error_message}')
+
+        project_id = credentials['gcp']['project_id']
+        gcp_credentials = service_account.Credentials.from_service_account_info(credentials['gcp'])
+        client = compute_v1.InstancesClient(credentials=gcp_credentials)
+
+        return client, project_id
+
+    def list_instances(self):
+        """List all non-terminated GCP instances."""
+        client, project_id = self._get_client()
+        instances = []
+        response = client.aggregated_list(project=project_id)
+        for _, scoped_list in response:
+            scoped_instances = getattr(scoped_list, 'instances', None)
+            if not scoped_instances:
+                continue
+
+            for instance in scoped_instances:
+                if instance.status == 'TERMINATED':
+                    continue
+
+                instances.append({
+                    'id': str(instance.id),
+                    'name': instance.name,
+                    'zone': instance.zone.split('/')[-1],
+                    'status': instance.status,
+                })
+
+        return instances
+
+    def update_instance_statuses(self, instance_names, instance_name_to_status):
+        """Update launcher-tracked instance statuses in place."""
+        running_instances = self.list_instances()
+        running_instance_names = {instance['name'] for instance in running_instances}
+        for instance_name in instance_names:
+            if instance_name in running_instance_names:
+                instance_name_to_status[instance_name] = 'running'
+            elif instance_name_to_status.get(instance_name) == 'running':
+                instance_name_to_status[instance_name] = 'completed'
+
+    def terminate_instances(self, instance_names, verbose):
+        """Terminate GCP instances by name."""
+        client, project_id = self._get_client()
+        running_instances = self.list_instances()
+        running_instances_by_name = {instance['name']: instance for instance in running_instances}
+        instances_to_delete = [
+            running_instances_by_name[name]
+            for name in instance_names
+            if name in running_instances_by_name
+        ]
+
+        not_running = sorted(set(instance_names) - set(running_instances_by_name))
+        if not_running:
+            not_running_str = "', '".join(not_running)
+            LOGGER.info(
+                f"Some provided instance names are not currently running: '{not_running_str}'."
+            )
+
+        deleted_instances = []
+        for instance in instances_to_delete:
+            if verbose:
+                print(  # noqa: T201
+                    f"Terminating GCP instance '{instance['name']}' "
+                    f'(id={instance["id"]}, zone={instance["zone"]})...'
+                )
+
+            operation = client.delete(
+                project=project_id,
+                zone=instance['zone'],
+                instance=instance['name'],
+            )
+            operation.result()
+            deleted_instances.append(instance['name'])
+
+        return deleted_instances

sdgym-0.14.2.dev0/sdgym/_benchmark_launcher/_storage_manager.py

@@ -0,0 +1,64 @@
+from sdgym._benchmark_launcher.utils import resolve_credentials
+from sdgym.s3 import _list_s3_bucket_contents, get_s3_client, is_s3_path, parse_s3_path
+
+
+def _validate_s3_output_destinations(instance_jobs):
+    """Validate that all output destinations are S3 paths."""
+    for instance_job in instance_jobs:
+        output_destination = instance_job['output_destination']
+        if not is_s3_path(output_destination):
+            raise ValueError(
+                f'Only S3 storage is currently supported. Found: {output_destination!r}.'
+            )
+
+
+class BaseStorageManager:
+    """Base class for storage-specific managers."""
+
+    def handles_destination(self, output_destination):
+        """Return whether this manager supports the given destination."""
+        raise NotImplementedError
+
+    def list_files(self, output_destination):
+        """Return the files currently stored under the given destination."""
+        raise NotImplementedError
+
+    def get_existing_filenames(self, output_destination):
+        """Return the existing filenames for the given destination."""
+        raise NotImplementedError
+
+
+class S3StorageManager(BaseStorageManager):
+    """Manage benchmark artifacts stored in S3."""
+
+    def __init__(self, credentials_filepath, instance_jobs):
+        _validate_s3_output_destinations(instance_jobs)
+        self.credentials_filepath = credentials_filepath
+
+    def handles_destination(self, output_destination):
+        """Return whether the destination is an S3 path."""
+        return is_s3_path(output_destination)
+
+    def _get_client(self):
+        """Build and return the S3 client."""
+        credentials = resolve_credentials(self.credentials_filepath)
+        aws_credentials = credentials.get('aws', {})
+        return get_s3_client(
+            aws_access_key_id=aws_credentials.get('aws_access_key_id'),
+            aws_secret_access_key=aws_credentials.get('aws_secret_access_key'),
+        )
+
+    def list_files(self, output_destination):
+        """List files under the provided S3 output destination."""
+        if not self.handles_destination(output_destination):
+            raise ValueError(
+                f'S3StorageManager only supports S3 paths. Found: {output_destination!r}.'
+            )
+
+        s3_client = self._get_client()
+        bucket_name, key_prefix = parse_s3_path(output_destination)
+        return _list_s3_bucket_contents(s3_client, bucket_name, key_prefix)
+
+    def get_existing_filenames(self, output_destination):
+        """Return the existing filenames for the given destination."""
+        return {obj['Key'] for obj in self.list_files(output_destination)}

sdgym-0.14.2.dev0/sdgym/_benchmark_launcher/_validation.py

@@ -0,0 +1,211 @@
+from sdgym._benchmark_launcher.utils import (
+    _AWS_CREDENTIAL_KEYS,
+    _GCP_SERVICE_ACCOUNT_REQUIRED_KEYS,
+    _is_unique_string_list,
+    resolve_credentials,
+)
+
+_INJECTED_PARAMS = {
+    'credentials',
+    'synthesizers',
+    'sdv_datasets',
+    'compute_config',
+    'output_destination',
+}
+
+
+def _as_errors(value):
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(v) for v in value if v]
+
+    return [str(value)]
+
+
+def _format_sectioned_errors(section_errors):
+    parts = ['BenchmarkConfig validation failed:\n']
+    for section, raw in section_errors.items():
+        errs = _as_errors(raw)
+        if not errs:
+            continue
+        parts.append(f'[{section}]')
+        parts.extend([f'- {e}' for e in errs])
+        parts.append('')
+
+    return '\n'.join(parts).rstrip()
+
+
+def _validate_structure(config):
+    errors = []
+    if config.modality not in ('single_table', 'multi_table'):
+        errors.append(
+            f"modality: must be 'single_table' or 'multi_table'. Found: {config.modality!r}"
+        )
+
+    if config.credentials_filepath is not None and not isinstance(config.credentials_filepath, str):
+        errors.append('credentials_filepath must be a string or None.')
+
+    expected_types = {
+        'method_params': dict,
+        'compute': dict,
+        'instance_jobs': list,
+    }
+    for key, expected_type in expected_types.items():
+        value = getattr(config, key, None)
+        if value is None:
+            errors.append(f'{key}: is a required section but missing.')
+        elif not isinstance(value, expected_type):
+            errors.append(f'{key}: must be a {expected_type.__name__}. Found: {type(value)}')
+
+    compute = getattr(config, 'compute', None)
+    if isinstance(compute, dict):
+        service = compute.get('service')
+        if service not in ('gcp',):
+            errors.append(f"compute.service: must be 'gcp'. Found: {service!r}")
+
+    return sorted(errors)
+
+
+def _validate_method_params(method_params, method_to_run):
+    errors = []
+    timeout = method_params.get('timeout')
+    if timeout is not None:
+        if not isinstance(timeout, int):
+            errors.append(
+                f'method_params.timeout: must be int seconds. Found: {timeout!r} ({type(timeout)})'
+            )
+        elif timeout <= 0:
+            errors.append('method_params.timeout: must be > 0.')
+
+    for key in ('compute_quality_score', 'compute_diagnostic_score', 'compute_privacy_score'):
+        value = method_params.get(key)
+        if value is not None and not isinstance(value, bool):
+            errors.append(f'method_params.{key}: must be bool. Found: {value!r} ({type(value)})')
+
+    illegal = _INJECTED_PARAMS & set(method_params)
+    if illegal:
+        errors.append(
+            f'method_params: must not define injected parameters {sorted(illegal)} '
+            f'(resolved from credentials/instance_jobs).'
+        )
+
+    return errors
+
+
+def _validate_instance_jobs(instance_jobs):
+    error_message = (
+        "Each job in 'instance_jobs' must be a dict with an 'output_destination' (string), "
+        "'synthesizers' (list of unique strings), and 'datasets' (list of unique strings or "
+        "dict with 'include' and optional 'exclude')."
+    )
+    invalid_jobs = []
+    for job in instance_jobs:
+        if not isinstance(job, dict):
+            invalid_jobs.append(job)
+            continue
+
+        if 'datasets' not in job or 'synthesizers' not in job or 'output_destination' not in job:
+            invalid_jobs.append(job)
+            continue
+
+        synthesizers = job['synthesizers']
+        if not _is_unique_string_list(synthesizers):
+            invalid_jobs.append(job)
+            continue
+
+        output_destination = job['output_destination']
+        if not isinstance(output_destination, str) or not output_destination:
+            invalid_jobs.append(job)
+            continue
+
+        datasets = job['datasets']
+        if isinstance(datasets, list):
+            if not _is_unique_string_list(datasets):
+                invalid_jobs.append(job)
+            continue
+
+        if isinstance(datasets, dict):
+            include = datasets.get('include')
+            exclude = datasets.get('exclude')
+            if not _is_unique_string_list(include):
+                invalid_jobs.append(job)
+                continue
+
+            if exclude is not None and not _is_unique_string_list(exclude):
+                invalid_jobs.append(job)
+            continue
+
+        invalid_jobs.append(job)
+
+    if not invalid_jobs:
+        return []
+
+    invalid_jobs_str = '\n'.join(str(job) for job in invalid_jobs)
+
+    return [f'{error_message}\nInvalid jobs:\n{invalid_jobs_str}']
+
+
+def _validate_aws_credentials(credentials):
+    errors = []
+    aws = credentials.get('aws', {})
+    if not isinstance(aws, dict):
+        errors.append("credentials['aws'] must be a dict.")
+    else:
+        if any(aws.values()):
+            for key in _AWS_CREDENTIAL_KEYS:
+                key = key.lower()
+                if aws.get(key) in (None, ''):
+                    errors.append(f"credentials['aws']['{key}'] is missing or empty.")
+
+    return sorted(errors)
+
+
+def _validate_sdv_enterprise_credentials(credentials):
+    errors = []
+    sdv = credentials.get('sdv_enterprise', {})
+    if not isinstance(sdv, dict):
+        errors.append("credentials['sdv_enterprise'] must be a dict.")
+    else:
+        username = sdv.get('sdv_enterprise_username')
+        license_key = sdv.get('sdv_enterprise_license_key')
+        message = (
+            "credentials['sdv_enterprise'] require both 'sdv_enterprise_username' and "
+            "'sdv_enterprise_license_key' to be provided and non-empty if any SDV Enterprise"
+            ' credential is provided.'
+        )
+        if bool(username) != bool(license_key):
+            errors.append(message)
+
+    return sorted(errors)
+
+
+def _validate_gcp_credentials(credentials):
+    errors = []
+    gcp = credentials.get('gcp', {})
+    if not isinstance(gcp, dict):
+        errors.append("credentials['gcp'] must be a dict.")
+    else:
+        if gcp:
+            for key in _GCP_SERVICE_ACCOUNT_REQUIRED_KEYS:
+                if gcp.get(key) in (None, ''):
+                    errors.append(f"credentials['gcp']['{key}'] is missing or empty.")
+
+    return sorted(errors)
+
+
+def _validate_resolved_credentials(credentials):
+    errors = []
+    errors.extend(_validate_aws_credentials(credentials))
+    errors.extend(_validate_sdv_enterprise_credentials(credentials))
+    errors.extend(_validate_gcp_credentials(credentials))
+
+    return sorted(errors)
+
+
+def _validate_credentials(credentials_filepath):
+    if credentials_filepath is not None and not isinstance(credentials_filepath, str):
+        return ['credentials_filepath: must be a string path to the credentials file or None.']
+
+    credentials = resolve_credentials(credentials_filepath)
+    return _validate_resolved_credentials(credentials)

sdgym-0.14.2.dev0/sdgym/_benchmark_launcher/benchmark_base.yaml

@@ -0,0 +1,9 @@
+method_params:
+  timeout: 345600
+  compute_quality_score: true
+  compute_diagnostic_score: true
+
+compute:
+  service: 'gcp'
+
+credentials_filepath: null

sdgym-0.14.2.dev0/sdgym/_benchmark_launcher/benchmark_config.py

@@ -0,0 +1,118 @@
+"""Define the BenchmarkConfig class, which represents the configuration for a benchmark."""
+
+import json
+from copy import deepcopy
+
+import yaml
+
+from sdgym._benchmark_launcher._validation import (
+    _format_sectioned_errors,
+    _validate_credentials,
+    _validate_instance_jobs,
+    _validate_method_params,
+    _validate_structure,
+)
+from sdgym._benchmark_launcher.utils import _METHODS, CONFIG_KEYS
+from sdgym.errors import BenchmarkConfigError
+
+
+class BenchmarkConfig:
+    """BenchmarkConfig class.
+
+    This class represents the configuration for a benchmark. It can be loaded from a YAML file
+    or a dictionary and provides methods for validation and conversion to different formats.
+    The expected structure of the config is as follows:
+    {
+        'modality': 'single_table' or 'multi_table',
+        'method_params': dict of parameters to pass to the benchmark method (e.g. timeout),
+        'credentials_filepath':
+            string specifying the path to the credentials file, if None,
+            credentials will be resolved from environment variables.
+        'compute': dict specifying the compute configuration (e.g. service: 'gcp'),
+        'instance_jobs': list of dicts, each specifying a combination of synthesizers
+        and datasets and output destination to run a benchmark job on. Each dict should
+        have the following structure:
+            [
+                {
+                    'synthesizers': ['synthesizer1', 'synthesizer2'],
+                    'datasets': ['dataset1', 'dataset2'] or {'include': [...], 'exclude': [...]},
+                    'output_destination': 's3://bucket/path'
+                },
+                ...
+            ]
+    }
+    """
+
+    def __init__(self):
+        self.modality = None
+        self.method_params = None
+        self.credentials_filepath = None
+        self.compute = {'service': None}
+        self.instance_jobs = []
+        self._is_validated = False
+
+    def to_dict(self):
+        """Return a python ``dict`` representation of the ``BenchmarkConfig``."""
+        config = {}
+        for key in CONFIG_KEYS:
+            value = getattr(self, f'{key}', None)
+            if value is not None:
+                config[key] = value
+
+        return deepcopy(config)
+
+    def __str__(self):
+        """Pretty print the ``BenchmarkConfig``."""
+        printed = json.dumps(self.to_dict(), indent=4)
+        return printed
+
+    def validate(self):
+        method_to_run = _METHODS[(self.modality, self.compute.get('service'))]
+        errors = _validate_structure(self)
+        if errors:
+            raise BenchmarkConfigError(_format_sectioned_errors({'structure': errors}))
+
+        section_errors = {
+            'method_params': _validate_method_params(self.method_params, method_to_run),
+            'credentials_filepath': _validate_credentials(self.credentials_filepath),
+            'instance_jobs': _validate_instance_jobs(self.instance_jobs),
+        }
+        if any(section_errors.values()):
+            raise BenchmarkConfigError(_format_sectioned_errors(section_errors))
+
+        self._is_validated = True
+
+    def _validate_no_extra_keys(self, config_dict):
+        """Validate that the config dictionary does not contain extra keys."""
+        extra_keys = set(config_dict.keys()).difference(CONFIG_KEYS)
+        if extra_keys:
+            extra_keys = "', '".join(sorted(extra_keys))
+            valid_keys = "', '".join(sorted(CONFIG_KEYS))
+            raise ValueError(
+                f"The config dictionary contains extra keys: '{extra_keys}'. "
+                f"Valid keys are: '{valid_keys}'."
+            )
+
+    @classmethod
+    def load_from_dict(cls, config_dict):
+        """Load the BenchmarkConfig from a dict."""
+        instance = cls()
+        instance._validate_no_extra_keys(config_dict)
+        for attribute_name, attribute_value in config_dict.items():
+            setattr(instance, attribute_name, attribute_value)
+
+        return instance
+
+    @classmethod
+    def load_from_yaml(cls, filepath):
+        """Load a config from a YAML file."""
+        with open(filepath, 'r') as f:
+            config_dict = yaml.safe_load(f)
+
+        return cls.load_from_dict(config_dict)
+
+    def save_to_yaml(self, filepath):
+        """Save the BenchmarkConfig in a YAML file."""
+        config_dict = self.to_dict()
+        with open(filepath, 'w') as file:
+            yaml.dump(config_dict, file)