\"\n\n\"\"\" A generic description appended to model uploads that are automatically uploaded to zenodo via Zenodo API call in medigan\"\"\"\nZENODO_GENERIC_MODEL_DESCRIPTION = (\n f\"
Usage:
This GAN is used as part of the medigan library. \"\n f\"This GANs metadata is therefore stored in and retrieved from medigan's \"\n f\"config file. medigan \"\n f\"is an open-source Python library on Github that allows developers and \"\n f\"researchers to easily add synthetic imaging data into their model training pipelines. medigan is documented \"\n f\"here and can be used via pip install:
\"\n f\"pip install mediganTo run this model in medigan, use the following commands.
\"\n f\" from medigan import Generators \"\n f\" generators = Generators() \"\n f\" generators.generate(model_id='YOUR_MODEL_ID',num_samples=10)\"\n)\n\n\"\"\" The REST API to interact with Zenodo \"\"\"\nZENODO_API_URL = \"https://zenodo.org/api/deposit/depositions\" # \"https://sandbox.zenodo.org/api/deposit/depositions\"\n\n\"\"\" The HEADER for Zenodo REST API requests\"\"\"\nZENODO_HEADERS = {\"Content-Type\": \"application/json\"}\n\n\"\"\" The title of the Github Issue when adding a model to medigan\"\"\"\nGITHUB_TITLE = \"Model Integration Request for medigan\"\n\n\"\"\" The repository of the Github Issue when adding a model to medigan\"\"\"\nGITHUB_REPO = \"RichardObi/medigan\" # \"RichardObi/medigan-models\"\n\n\"\"\" The assignee of the Github Issue when adding a model to medigan\"\"\"\nGITHUB_ASSIGNEE = \"RichardObi\"\n" }, { "path": "src/medigan/contribute_model/__init__.py", "content": "" }, { "path": "src/medigan/contribute_model/base_model_uploader.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"Base Model uploader class that uploads models to medigan associated data storage services. \"\"\"\n\nfrom __future__ import absolute_import\n\n\nclass BaseModelUploader:\n \"\"\"`BaseModelUploader` class: Uploads a user's model and metadata to third party storage to allow its inclusion into the medigan library.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n metadata: dict\n The model's corresponding metadata\n\n Attributes\n ----------\n model_id: str\n The generative model's unique id\n metadata: dict\n The model's corresponding metadata\n \"\"\"\n\n def __init__(\n self,\n model_id: str,\n metadata: dict,\n ):\n self.model_id = model_id\n self.metadata = metadata\n\n def push(self):\n raise NotImplementedError\n\n def __repr__(self):\n return f\"BaseModelUploader(model_id={self.model_id}, metadata={self.metadata})\"\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/contribute_model/github_model_uploader.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"Github Model uploader class that uploads the metadata of a new model to the medigan github repository. \"\"\"\n\nfrom __future__ import absolute_import\n\nimport json\nimport logging\n\nfrom github import Github\n\nfrom ..constants import (\n CONFIG_FILE_KEY_EXECUTION,\n CONFIG_FILE_KEY_PACKAGE_LINK,\n GITHUB_ASSIGNEE,\n GITHUB_REPO,\n GITHUB_TITLE,\n)\nfrom ..utils import Utils\nfrom .base_model_uploader import BaseModelUploader\n\n\nclass GithubModelUploader(BaseModelUploader):\n \"\"\"`GithubModelUploader` class: Pushes the metadata of a user's model to the medigan repo, where it creates a\n dedicated github issue.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n access_token: str\n a personal access token linked to your github user account, used as means of authentication\n\n Attributes\n ----------\n model_id: str\n The generative model's unique id\n access_token: str\n a personal access token linked to your github user account, used as means of authentication\n \"\"\"\n\n def __init__(\n self,\n model_id: str,\n access_token: str,\n ):\n self.model_id = model_id\n self.access_token = access_token\n\n def push(\n self,\n metadata: dict,\n package_link: str = None,\n creator_name: str = \"n.a.\",\n creator_affiliation: str = \"n.a.\",\n model_description: str = \"n.a.\",\n ):\n \"\"\"Upload the model's metadata inside a github issue to the medigan github repository.\n\n To add your model to medigan, your metadata will be reviewed on Github and added to medigan's official model metadata\n\n The medigan repository issues page: https://github.com/RichardObi/medigan/issues\n\n Get your Github access token here: https://github.com/settings/tokens\n\n Parameters\n ----------\n metadata: dict\n The model's corresponding metadata\n package_link:\n a package link\n creator_name: str\n the creator name that will appear on the corresponding github issue\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding github issue\n model_description: list\n the model_description that will appear on the corresponding github issue\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding issue on github\n \"\"\"\n\n # Check if the package_link is already in the metadata. If not, add it to metadata.\n metadata = self.add_package_link_to_metadata(\n metadata=metadata, package_link=package_link\n )\n\n # First use pyGithub to create a Github instance based on san access token\n g = Github(self.access_token)\n repo = g.get_repo(GITHUB_REPO)\n logging.debug(f\"Repo: {repo}\")\n\n # Create metadata for github issue\n title = f\"{GITHUB_TITLE}: {self.model_id}\"\n line_break = \"\\n\"\n body = (\n f\"{line_break + '**Creator:** ' if creator_name != '' else ''}{creator_name}\"\n f\"{line_break + '**Affiliation:** ' if creator_affiliation != '' else ''}{creator_affiliation}\"\n f\"{line_break + '**Description:** ' if model_description != '' else ''}{model_description}\"\n f\"{line_break} **Stored in:** {package_link}\"\n f\"{line_break} ### Model Metadata: {line_break} ```json{json.dumps(metadata, indent=3)}\"\n )\n\n # As a logged-in github user, let's now push to medigan repo using pyGithub\n github_issue = repo.create_issue(\n title=title, body=body, assignee=GITHUB_ASSIGNEE\n )\n logging.info(\n f\"{self.model_id}: Successfully created github issue in '{GITHUB_REPO}': '{github_issue.html_url}'\"\n )\n return github_issue.html_url\n\n def add_package_link_to_metadata(\n self, metadata: dict, package_link: str = None, is_update_forced: bool = False\n ) -> dict:\n \"\"\"Update `package_link` in the model's metadata if current `package_link` does not containing a valid url.\n\n Parameters\n ----------\n metadata: dict\n The model's corresponding metadata\n package_link: str\n the new package link to used to replace the old one\n is_update_forced: bool\n flag to update metadata even though metadata already contains a valid url in its `package_link`\n\n Returns\n -------\n dict\n Returns the updated metadata dict with replaced `package_link` if replacement was applicable.\n \"\"\"\n\n current_pl = None\n try:\n # Get the package link from the metadata object\n current_pl = metadata[self.model_id][CONFIG_FILE_KEY_EXECUTION][\n CONFIG_FILE_KEY_PACKAGE_LINK\n ]\n except Exception as e:\n logging.debug(\n f\"{self.model_id}: Package Link could not be located in metadata for key {self.model_id}.{CONFIG_FILE_KEY_EXECUTION}.{CONFIG_FILE_KEY_PACKAGE_LINK}: {e}\"\n )\n\n # Check if the package link in the metadata contains a valid URL\n if (\n current_pl is not None\n and not is_update_forced\n and (\n (Utils.is_url_valid(current_pl) and current_pl.startswith(\"http\"))\n or current_pl.startswith(\"models/\")\n )\n ):\n # If there is already a valid (non-local) url to a zip file,\n # we assume that this URL is validly pointing to the model.\n # Note: The package link can start with models/ indicating that the model is hosted directly in medigan\n # instead of Zenodo, see model 00007 for an example.\n pass\n else:\n # We update the metadata with the retrieved package_link. Note: Also, in case the metadata points to a path on a\n # user's machine, we avoid publishing that path to github issue by making this update.\n try:\n metadata[self.model_id][CONFIG_FILE_KEY_EXECUTION][\n CONFIG_FILE_KEY_PACKAGE_LINK\n ] = package_link\n except Exception as e:\n logging.warning(\n f\"{self.model_id}: Package Link could not be update in metadata for key {self.model_id}.{CONFIG_FILE_KEY_EXECUTION}.{CONFIG_FILE_KEY_PACKAGE_LINK}: {e}\"\n )\n logging.debug(\n f\"{self.model_id}: Before creating github issue, updated package link from '{current_pl}' to '{package_link}'\"\n )\n return metadata\n\n def __repr__(self):\n return (\n f\"GithubModelUploader(model_id={self.model_id}, metadata={self.metadata})\"\n )\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/contribute_model/model_contributor.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"Model contributor class that tests models, creates metadata entries, uploads and contributes them to medigan. \"\"\"\n\nfrom __future__ import absolute_import\n\nimport importlib\nimport logging\nimport sys\nfrom pathlib import Path\n\nfrom ..constants import (\n CONFIG_FILE_KEY_DEPENDENCIES,\n CONFIG_FILE_KEY_EXECUTION,\n CONFIG_FILE_KEY_GENERATE,\n CONFIG_FILE_KEY_GENERATE_NAME,\n CONFIG_FILE_KEY_MODEL_EXTENSION,\n CONFIG_FILE_KEY_MODEL_NAME,\n CONFIG_FILE_KEY_PACKAGE_LINK,\n CONFIG_FILE_KEY_PACKAGE_NAME,\n CONFIG_TEMPLATE_FILE_NAME_AND_EXTENSION,\n CONFIG_TEMPLATE_FILE_URL,\n INIT_PY_FILE,\n TEMPLATE_FOLDER,\n)\nfrom ..utils import Utils\nfrom .github_model_uploader import GithubModelUploader\nfrom .zenodo_model_uploader import ZenodoModelUploader\n\n\nclass ModelContributor:\n \"\"\"`ModelContributor` class: Contributes a user's local model to the public medigan library\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n init_py_path: str\n The path to the local model's `__init__.py` file needed for importing and running this model.\n\n Attributes\n ----------\n model_id: str\n The generative model's unique id\n init_py_path: str\n The path to the local model's __init__.py file needed for importing and running this model.\n package_path: str\n Path as string to the generative model's python package\n package_name: str\n Name of the model's python package i.e. the name of the model's zip file and unzipped package folder\n metadata_file_path: str\n Path as string to the generative model's metadata file e.g. default is relative path to package root.\n zenodo_model_uploader: str\n An instance of the `ZenodoModelUploader` class\n github_model_uploader: str\n An instance of the `GithubModelUploader` class.\n \"\"\"\n\n def __init__(\n self,\n model_id: str,\n init_py_path: str,\n ):\n self.validate_model_id(model_id)\n self.model_id = model_id\n self.init_py_path = init_py_path\n self.validate_init_py_path(init_py_path)\n self.package_path = self.init_py_path.replace(INIT_PY_FILE, \"\")\n self.package_name = Path(self.package_path).name\n self.metadata_file_path = \"\" # Default is relative path to package root.\n self.validate_local_model_import()\n self.zenodo_model_uploader = None\n self.github_model_uploader = None\n\n ############################ VALIDATION ############################\n\n def validate_model_id(\n self, model_id: str, max_chars: int = 30, min_chars: int = 13\n ) -> bool:\n \"\"\"Asserts if the `model_id` is in the correct format and has a valid length\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n max_chars: int\n the maximum of chars allowed in the model_id\n min_chars: int\n the minimum of chars allowed in the model_id\n\n Returns\n -------\n bool\n Returns flag indicating whether the `model_id` is correctly formatted.\n \"\"\"\n\n num_chars = len(model_id)\n assert (\n num_chars <= max_chars\n ), f\"The model_id {model_id} is too large ({num_chars}). Please reduce to a maximum of {max_chars} characters. Format Convention: '00001_GANTYPE_MODALITY'\"\n assert (\n num_chars >= min_chars\n ), f\"The model_id {model_id} is too small ({num_chars}). Please reduce to a minimum of {min_chars} characters. Format Convention: '00001_GANTYPE_MODALITY'\"\n for i in range(5):\n assert model_id[\n i\n ].isdigit(), f\"Your model_id's ({model_id}) character '{model_id[i]}' at position {i} is not a digit. The first 5 characters should be digits as in '00001_GANTYPE_MODALITY'. Please adjust.\"\n logging.info(\n f\"The provided model_id is valid and will now be used to refer to the contributed model in medigan: {model_id}\"\n )\n return True\n\n def validate_init_py_path(self, init_py_path) -> bool:\n \"\"\"Asserts whether the `init_py_path` exists and points to a valid `__init__.py` correct file.\n\n Parameters\n ----------\n init_py_path: str\n The path to the local model's __init__.py file needed for importing and running this model.\n \"\"\"\n\n assert (\n Path(init_py_path).exists() and Path(init_py_path).is_file()\n ), f\"{self.model_id}: The path to your model's __init__.py function does not exist or does not point to a file. Please revise path {init_py_path}. Note: You can find an __init__.py example in https://github.com/RichardObi/medigan/tree/main/templates\"\n assert Utils.is_file_in(\n folder_path=self.init_py_path.replace(f\"/{INIT_PY_FILE}\", \"\"),\n filename=INIT_PY_FILE,\n ), f\"{self.model_id}: No __init__.py was found in your path {init_py_path}. Please revise. Note: You can find an __init__.py example in /templates in https://github.com/RichardObi/medigan\"\n logging.info(\n f\"The provided path to your model's __init__.py function was valid and points to a __init__.py file: {init_py_path}\"\n )\n return True\n\n def validate_and_update_model_weights_path(self) -> dict:\n \"\"\"Check if the model files can be found in the `package_path` or based on the `path_to_metadata`.\n\n Ideally, the user provided `package_path` and the `path_to_metadata` should both point to the same model package\n containing weights, config, license, etc. Here we check both of these paths to find the model weights.\n\n Returns\n -------\n dict\n Returns the metadata after updating the path to the model's checkpoint's weights\n \"\"\"\n\n metadata_dir_path = Path(self.metadata_file_path).parent\n\n potential_weight_paths: list = []\n\n execution_metadata = self.metadata[self.model_id][CONFIG_FILE_KEY_EXECUTION]\n\n # package_path + package_path + file + extension\n try:\n potential_weight_paths.append(\n Path(\n self.package_path\n + f\"/{execution_metadata[CONFIG_FILE_KEY_MODEL_NAME]}{execution_metadata[CONFIG_FILE_KEY_MODEL_EXTENSION]}\"\n )\n )\n except KeyError as e:\n raise e\n\n # metadata_dir + package_path + file + extension\n try:\n potential_weight_paths.append(\n Path(\n str(metadata_dir_path)\n + f\"/{execution_metadata[CONFIG_FILE_KEY_MODEL_NAME]}{execution_metadata[CONFIG_FILE_KEY_MODEL_EXTENSION]}\"\n )\n )\n except KeyError as e:\n raise e\n\n # metadata_dir + package_path + file + extension\n try:\n potential_weight_paths.append(\n Path(\n str(metadata_dir_path)\n + \"/\"\n + self.package_path\n + f\"/{execution_metadata[CONFIG_FILE_KEY_MODEL_NAME]}{execution_metadata[CONFIG_FILE_KEY_MODEL_EXTENSION]}\"\n )\n )\n except KeyError as e:\n raise e\n\n for potential_weight_path in potential_weight_paths:\n if potential_weight_path.is_file():\n # Checking if there is a weights/checkpoint (model name + extension) file in the package /metadata path\n self.package_path = str(\n Path(potential_weight_path).parent.resolve(strict=False)\n ) # strict=False, as models might be not on user's disc.\n self.metadata[self.model_id][CONFIG_FILE_KEY_EXECUTION][\n CONFIG_FILE_KEY_PACKAGE_LINK\n ] = self.package_path\n logging.info(\n f\"The model weights path is valid and was added to the metadata of your model: {self.package_path}\"\n )\n return self.metadata\n raise FileNotFoundError(\n f\"{self.model_id}: Error validating metadata. There was no valid model weights file found. Please revise. Tested paths: '{potential_weight_paths}'\"\n )\n\n def validate_local_model_import(self):\n \"\"\"Check if the model package in the `package_path` can be imported as python library using importlib.\"\"\"\n\n # Validation: Import module as python library to check if generate function is inside the\n # path_to_script_w_generate_function python file and no errors occur.\n try:\n sys.path.insert(1, str(self.package_path).replace(self.package_name, \"\"))\n importlib.import_module(name=self.package_name)\n logging.info(\n f\"Model import test successful: The model was successfully imported using importlib: {self.package_name}\"\n )\n except Exception as e:\n raise Exception(\n f\"{self.model_id}: Error while testing importlib model import. Is your {INIT_PY_FILE} erroneous? \"\n f\"Please revise if the provided path ({self.init_py_path}) is valid and accessible and try again. \"\n f\"Exception: {e}\"\n ) from e\n\n ############################ UPLOAD ############################\n\n def push_to_zenodo(\n self,\n access_token: str,\n creator_name: str,\n creator_affiliation: str,\n model_description: str = \"\",\n ):\n \"\"\"Upload the model files as zip archive to a public Zenodo repository where the model will be persistently stored.\n\n Get your Zenodo access token here: https://zenodo.org/account/settings/applications/tokens/new/ (Enable scopes `deposit:actions` and `deposit:write`)\n\n Parameters\n ----------\n access_token: str\n a personal access token in Zenodo linked to a user account for authentication\n creator_name: str\n the creator name that will appear on the corresponding Zenodo model upload homepage\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding Zenodo model upload homepage\n model_description: list\n the model_description that will appear on the corresponding Zenodo model upload homepage\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding Zenodo model upload homepage\n \"\"\"\n\n if self.zenodo_model_uploader is None:\n self.zenodo_model_uploader = ZenodoModelUploader(\n model_id=self.model_id, access_token=access_token\n )\n # Update in case previous access token gave an error\n self.zenodo_model_uploader.access_token = access_token\n\n return self.zenodo_model_uploader.push(\n metadata=self.metadata,\n package_path=self.package_path,\n package_name=self.package_name,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n model_description=model_description,\n )\n\n def push_to_github(\n self,\n access_token: str,\n package_link: str = None,\n creator_name: str = \"\",\n creator_affiliation: str = \"\",\n model_description: str = \"\",\n ):\n \"\"\"Upload the model's metadata inside a github issue to the medigan github repository.\n\n To add your model to medigan, your metadata will be reviewed on Github and added to medigan's official model metadata\n\n The medigan repository issues page: https://github.com/RichardObi/medigan/issues\n\n Get your Github access token here: https://github.com/settings/tokens\n\n Parameters\n ----------\n access_token: str\n a personal access token linked to your github user account, used as means of authentication\n package_link:\n a package link\n creator_name: str\n the creator name that will appear on the corresponding github issue\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding github issue\n model_description: list\n the model_description that will appear on the corresponding github issue\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding issue on github\n \"\"\"\n\n if self.github_model_uploader is None:\n self.github_model_uploader = GithubModelUploader(\n model_id=self.model_id, access_token=access_token\n )\n # Update in case previous access token gave an error\n self.github_model_uploader.access_token = access_token\n\n return self.github_model_uploader.push(\n metadata=self.metadata,\n package_link=package_link,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n model_description=model_description,\n )\n\n ############################ METADATA ############################\n\n def load_metadata_template(self) -> dict:\n \"\"\"Loads and parses (json to dict) a default medigan metadata template.\n\n Returns\n -------\n dict\n Returns the metadata template as dict\n \"\"\"\n\n path_to_metadata_template = Path(\n f\"{TEMPLATE_FOLDER}/{CONFIG_TEMPLATE_FILE_NAME_AND_EXTENSION}\"\n )\n Utils.mkdirs(TEMPLATE_FOLDER)\n Utils.is_file_located_or_downloaded(\n download_link=CONFIG_TEMPLATE_FILE_URL,\n path_as_string=path_to_metadata_template,\n )\n metadata_template = Utils.read_in_json(path_as_string=path_to_metadata_template)\n if self.model_id is not None:\n # Replacing the placeholder id of template with model_id\n metadata_template[self.model_id] = metadata_template[\n list(metadata_template)[0]\n ]\n del metadata_template[list(metadata_template)[0]]\n return metadata_template\n\n def add_metadata_from_file(self, metadata_file_path) -> dict:\n \"\"\"Read and parse the metadata of a local model, identified by `model_id`, from a metadata file in json format.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n metadata_file_path: str\n the path pointing to the metadata file\n\n Returns\n -------\n dict\n Returns a dict containing the contents of parsed metadata json file.\n \"\"\"\n\n if Path(metadata_file_path).is_file():\n self.metadata = Utils.read_in_json(path_as_string=metadata_file_path)\n self.metadata_file_path = metadata_file_path\n elif Path(metadata_file_path + \"/metadata.json\").is_file():\n self.metadata = Utils.read_in_json(\n path_as_string=metadata_file_path + \"/metadata.json\"\n )\n self.metadata_file_path = metadata_file_path + \"/metadata.json\"\n else:\n raise FileNotFoundError(\n f\"{self.model_id}: No metadata json file was found in the path you provided ({metadata_file_path}). \"\n f\"If you do not have a metadata file, create one using the add_metadata_from_input() function.\"\n )\n self.validate_and_update_model_weights_path()\n return self.metadata\n\n def add_metadata_from_input(\n self,\n model_weights_name: str = None,\n model_weights_extension: str = None,\n generate_method_name: str = None,\n dependencies: list = [],\n fill_more_fields_interactively: bool = True,\n output_path: str = \"config\",\n ):\n \"\"\"Create a metadata dict for a local model, identified by `model_id`, given the necessary minimum metadata contents.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n model_weights_name: str\n the name of the checkpoint file containing the model's weights\n model_weights_extension: str\n the extension (e.g. .pt) of the checkpoint file containing the model's weights\n generate_method_name: str\n the name of the sample generation method inside the models __init__.py file\n dependencies: list\n the list of dependencies that need to be installed via pip to run the model.\n fill_more_fields_interactively: bool\n flag indicating whether a user will be interactively asked via command line for further input to fill out missing metadata content\n output_path: str\n the path where the created metadata json file will be stored.\n\n Returns\n -------\n dict\n Returns a dict containing the contents of the metadata json file.\n \"\"\"\n\n # Get the metadata template to guide data structure and formatting of metadata.\n self.metadata_template = self.load_metadata_template()\n\n # Generate metadata with variables provided as parameters\n metadata = self.metadata_template[self.model_id][CONFIG_FILE_KEY_EXECUTION]\n metadata.update({CONFIG_FILE_KEY_PACKAGE_LINK: self.package_path})\n metadata.update({CONFIG_FILE_KEY_PACKAGE_NAME: self.package_name})\n metadata.update({CONFIG_FILE_KEY_MODEL_NAME: model_weights_name})\n metadata.update({CONFIG_FILE_KEY_MODEL_EXTENSION: model_weights_extension})\n metadata.update({CONFIG_FILE_KEY_DEPENDENCIES: dependencies})\n metadata[CONFIG_FILE_KEY_GENERATE][\n CONFIG_FILE_KEY_GENERATE_NAME\n ] = generate_method_name\n metadata_final = self.metadata_template\n metadata_final[self.model_id].update({CONFIG_FILE_KEY_EXECUTION: metadata})\n\n Utils.store_dict_as(\n dictionary=metadata_final,\n extension=\".json\",\n output_path=output_path,\n filename=self.model_id,\n )\n logging.info(\n f\"{self.model_id}: Your model's metadata was stored in {output_path}.\"\n )\n\n if fill_more_fields_interactively:\n # Add more information to the metadata dict via user prompts\n metadata_final = self._recursively_fill_metadata(metadata=metadata_final)\n # Store again as additional fields should have now been filled\n Utils.store_dict_as(\n dictionary=metadata_final,\n extension=\".json\",\n output_path=output_path,\n filename=self.model_id,\n )\n logging.info(\n f\"{self.model_id}: Your model's metadata was updated. Find it in {output_path}/{self.model_id}.json\"\n )\n\n self.metadata = metadata_final\n self.validate_and_update_model_weights_path()\n\n return self.metadata\n\n def is_value_for_key_already_set(\n self, key: str, metadata: dict, nested_key\n ) -> bool:\n \"\"\"Check if the value of a `key` in a `metadata` dictionary is already set and e.g. not an empty string, dict or list.\n\n Parameters\n ----------\n key: str\n The key in the currently traversed part of the model's metadata dictionary\n metadata: dict\n The currently traversed part of the model's metadata dictionary\n nested_key: str\n the `nested_key` indicates which subpart of the model's metadata we are currently traversing\n\n Returns\n -------\n bool\n Flag indicating whether a value exists for the `key` in the dict\n \"\"\"\n\n if (\n metadata.get(key) is None\n or metadata.get(key) == \"\"\n or (isinstance(metadata.get(key), list) and not metadata.get(key))\n or isinstance(metadata.get(key), dict)\n ):\n # Note: If metadata.get(key) is referencing a dict, we always want to go inside the dict and add values.\n return False\n else:\n logging.debug(\n f\"{self.model_id}: Key value pair ({key}:{metadata.get(key)}) already exists in metadata for key \"\n f\"'{nested_key}'. Not prompting user to insert value for this key.\"\n )\n return True\n\n def _recursively_fill_metadata(\n self, metadata_template: dict = None, metadata: dict = {}, nested_key: str = \"\"\n ) -> dict:\n \"\"\"Filling a model metadata template with values retrieved via user input prompts and by traversing nested dicts and list recursively.\n\n Parameters\n ----------\n metadata_template: dict\n The template containing all keys expected in a model's metadata dictionary.\n metadata: dict\n The currently traversed part of the model's metadata dictionary\n nested_key: str\n the `nested_key` indicates which subpart of the model's metadata we are currently traversing\n\n Returns\n -------\n dict\n The final fully filled metadata dictionary.\n \"\"\"\n\n if metadata_template is None:\n metadata_template = self.metadata_template\n # Prompt user for optional metadata input\n retrieved_nested_key = nested_key\n for key in metadata_template:\n # nested_key to know where we are inside the metadata dict.\n nested_key = (\n key if retrieved_nested_key == \"\" else f\"{retrieved_nested_key}.{key}\"\n )\n if not self.is_value_for_key_already_set(\n key=key, metadata=metadata, nested_key=nested_key\n ):\n value_template = metadata_template.get(key)\n if value_template is None:\n input_value = input(\n f\"{self.model_id}: Please enter value of type float or int for your model for key '{nested_key}': \"\n )\n try:\n value_assigned = float(input_value.replace(\",\", \".\"))\n except ValueError:\n value_assigned = (\n int(input_value) if input_value.isdigit() else None\n )\n elif isinstance(value_template, list):\n input_value = input(\n f\"{self.model_id}: Please enter a comma-separated list of values for your model for key: '{nested_key}': \"\n )\n value_assigned = (\n [value.strip() for value in input_value.split(\",\")]\n if input_value != \"\"\n else []\n )\n elif isinstance(value_template, str):\n value_assigned = str(\n input(\n f\"{self.model_id}: Please enter value of type string for your model for key '{nested_key}': \"\n )\n )\n elif isinstance(value_template, dict):\n if len(value_template) == 0:\n # If dict is empty, no recursion. Instead, we ask the user directly for input.\n iterations = int(\n input(\n f\"{self.model_id}: How many key-value pairs do you want to nest below key '{nested_key}' \"\n f\"in your model's metadata. Type a number: \"\n )\n or \"0\"\n )\n nested_metadata: dict = {}\n for i in range(iterations):\n nested_key_input = str(\n input(f\"{self.model_id}: Enter key {i + 1}: \")\n )\n nested_value_input = input(\n f\"{self.model_id}: For key{i + 1}={nested_key_input}, enter value: \"\n )\n nested_metadata.update(\n {nested_key_input: nested_value_input}\n )\n value_assigned = nested_metadata\n else:\n # From metadata, get the nested dict below the key. If metadata has no nested dict, get the\n # template's nested dict instead, which is stored in value_template\n temp_metadata = (\n metadata.get(key)\n if metadata.get(key) is not None\n else value_template\n )\n # Filling nested dicts via recursion. value_assigned is of type dict in this case.\n value_assigned = self._recursively_fill_metadata(\n metadata_template=value_template,\n nested_key=nested_key,\n metadata=temp_metadata,\n )\n logging.debug(\n f\"{self.model_id}: You provided this key-value pair: {key}={value_assigned}\"\n )\n metadata.update({key: value_assigned})\n return metadata\n\n def __repr__(self):\n return f\"ModelContributor(model_id={self.model_id}, metadata={self.metadata})\"\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/contribute_model/zenodo_model_uploader.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"Zenodo Model uploader class that uploads models to medigan associated data storage on Zenodo. \"\"\"\n\nfrom __future__ import absolute_import\n\nimport json\nimport logging\nimport shutil\nfrom pathlib import Path\n\nimport requests\n\nfrom ..constants import (\n CONFIG_FILE_KEY_DESCRIPTION,\n CONFIG_FILE_KEY_SELECTION,\n CONFIG_FILE_KEY_TAGS,\n ZENODO_API_URL,\n ZENODO_GENERIC_MODEL_DESCRIPTION,\n ZENODO_HEADERS,\n ZENODO_LINE_BREAK,\n)\nfrom .base_model_uploader import BaseModelUploader\n\n\nclass ZenodoModelUploader(BaseModelUploader):\n \"\"\"`ZenodoModelUploader` class: Uploads a user's model via API to Zenodo, here it is permanently stored with DOI.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n access_token: str\n a personal access token in Zenodo linked to a user account for authentication\n\n Attributes\n ----------\n model_id: str\n The generative model's unique id\n access_token: str\n a personal access token in Zenodo linked to a user account for authentication\n \"\"\"\n\n def __init__(\n self,\n model_id,\n access_token,\n ):\n self.model_id = model_id\n self.params = {\"access_token\": access_token}\n\n ############################ UPLOAD ############################\n def create_upload_description(\n self, metadata: dict, model_description: str = \"\"\n ) -> str:\n \"\"\"Create a string containing the textual description that will accompany the upload model files.\n\n The string contains tags and a text retrieved from the description subsection of the model metadata.\n\n Parameters\n ----------\n metadata: dict\n The model's corresponding metadata\n model_description: str\n the model_description that will appear on the corresponding Zenodo model upload homepage\n\n Returns\n -------\n str\n Returns the textual description of the model upload\n \"\"\"\n\n try:\n tags = f\"{ZENODO_LINE_BREAK}
Tags:
{metadata[self.model_id][CONFIG_FILE_KEY_SELECTION][CONFIG_FILE_KEY_TAGS]}\"\n except:\n tags = \"\"\n try:\n description_from_config = f\"Description from model config:
: {json.dumps(metadata[self.model_id][CONFIG_FILE_KEY_DESCRIPTION])}\"\n except:\n description_from_config = \"\"\n\n return f\"{model_description}Model ID:
{self.model_id}. {ZENODO_LINE_BREAK}Uploaded via:
API {tags} {ZENODO_LINE_BREAK} {ZENODO_GENERIC_MODEL_DESCRIPTION.replace('YOUR_MODEL_ID', self.model_id)} {description_from_config} {ZENODO_LINE_BREAK}\"\n\n def create_upload_json_data(\n self, creator_name: str, creator_affiliation: str, description: str = \"\"\n ) -> dict:\n \"\"\"Create some descriptive data in dict format to be uploaded and stored alongside the model files.\n\n Parameters\n ----------\n creator_name: str\n the creator name that will appear on the corresponding Zenodo model upload homepage\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding Zenodo model upload homepage\n description: str\n the model_description that will appear on the corresponding Zenodo model upload homepage\n\n Returns\n -------\n dict\n Returns the descriptive data in dictionary structure describing the model upload.\n \"\"\"\n\n return {\n \"metadata\": {\n \"title\": f\"MEDIGAN MODEL UPLOAD: {self.model_id}\",\n \"upload_type\": \"software\",\n \"description\": description,\n \"creators\": [\n {\n \"name\": f\"{creator_name}\",\n \"affiliation\": f\"{creator_affiliation}\",\n }\n ],\n }\n }\n\n def locate_or_create_model_zip_file(\n self, package_path: str, package_name: str\n ) -> (str, str):\n \"\"\"If not possible to locate, create a zipped python package of the model.\n\n Parameters\n ----------\n package_path: str\n Path as string to the generative model's python package containing an `__init__.py` file\n package_name: str\n Name of the model's python package i.e. the name of the model's zip file and unzipped package folder\n\n Returns\n -------\n tuple\n Returns a tuple containing two strings: The `filename` and the `file_path` of and to the zipped python package\n \"\"\"\n\n # Check if zip file already exists\n if not (Path(package_path).is_file() and package_path.endswith(\".zip\")):\n # Create a zip archive containing the model package and store that zip file inside the\n # folder of the model package\n package_parent_path = str(Path(package_path).parent)\n logging.info(\n f\"Archiving the model package as zip archive: base_name={package_parent_path+ '/' + package_name}, root_dir={package_path + '/'} \"\n )\n filename = shutil.make_archive(\n base_name=package_parent_path + \"/\" + package_name,\n format=\"zip\",\n root_dir=package_path,\n )\n file_path = filename\n filename = Path(file_path).name\n else:\n filename = Path(package_path).name\n file_path = package_path\n logging.info(\n f\"Model was successfully archived as zip archive: filename={filename}, file_path={file_path} \"\n )\n return filename, file_path\n\n def empty_upload(self) -> dict:\n \"\"\"Upload an empty placeholder entry to Zenodo as is required to retrieve a `deposition_id` and `bucket_url`.\n\n deposition_id and bucket_url aare needed for file upload and publishing in the subsequent upload steps.\n\n Returns\n -------\n dict\n Returns the response retrieved via the Zenodo API\n \"\"\"\n\n r = requests.post(\n ZENODO_API_URL,\n params=self.params,\n json={},\n headers=ZENODO_HEADERS,\n )\n if not r.status_code == 201:\n raise Exception(\n f\"{self.model_id}: Error ({r.status_code}!=201) during Zenodo ('{ZENODO_API_URL}') upload (step 1: creating empty upload template): {r.json()}.\"\n )\n return r\n\n def upload(self, file_path: str, filename: str, bucket_url: str) -> dict:\n \"\"\"Upload a file to Zenodo entry of the uploaded model files.\n\n Parameters\n ----------\n file_path: str\n The path of the file that is uploaded to Zenodo\n filename: str\n The name of the file that is uploaded to Zenodo\n bucket_url: str\n The bucket url used in the PUT request to upload the data file.\n\n Returns\n -------\n dict\n Returns the response retrieved via the Zenodo API\n \"\"\"\n with open(file_path, \"rb\") as fp:\n r = requests.put(\n \"%s/%s\" % (bucket_url, filename),\n data=fp,\n params=self.params,\n )\n\n if not r.status_code == 200 and not r.status_code == 201:\n raise Exception(\n f\"{self.model_id}: Error ({r.status_code}!= any of (200, 201) ) during Zenodo ('{bucket_url}') upload (step 2: uploading model as zip file): {r.json()}\"\n )\n return r\n\n def upload_descriptive_data(self, deposition_id: str, data: dict) -> dict:\n \"\"\"Upload textual descriptive data to be associated and added to the Zenodo entry of the uploaded model files.\n\n Parameters\n ----------\n deposition_id: str\n The deposition id assigned by Zenodo to the uploaded model file\n data: dict\n The descriptive information that will to be uploaded to Zenodo and associated with the desposition_id\n\n Returns\n -------\n dict\n Returns the response retrieved via the Zenodo API\n \"\"\"\n deposition_url = f\"{ZENODO_API_URL}/{deposition_id}\"\n r = requests.put(\n deposition_url,\n params=self.params,\n data=json.dumps(data),\n headers=ZENODO_HEADERS,\n )\n if not r.status_code == 200 and not r.status_code == 201:\n raise Exception(\n f\"{self.model_id}: Error ({r.status_code}!= any of (200, 201) ) during Zenodo ('{deposition_url}') upload (step 3: updating metadata): {r.json()}\"\n )\n return r\n\n def publish(self, deposition_id: str) -> dict:\n \"\"\"Publish a zenodo upload.\n\n This makes the upload official, as it will then be publicly accessible and persistently stored on Zenodo with associated DOI.\n\n Parameters\n ----------\n deposition_id: str\n The deposition id assigned by Zenodo to the uploaded model file\n\n Returns\n -------\n dict\n Returns the response retrieved via the Zenodo API\n \"\"\"\n\n # Get explicit user approval to publish on Zenodo. Published files cannot be deleted.\n is_user_sure = str(\n input(\n f\"You are about to publish model {self.model_id} with Zenodo-ID {deposition_id} permanently on {ZENODO_API_URL.replace('/api/deposit/depositions','')}. To proceed, type 'Yes': \"\n )\n )\n publish_url = f\"{ZENODO_API_URL}/{deposition_id}/actions/publish\"\n if is_user_sure == \"Yes\":\n r = requests.post(\n publish_url,\n params=self.params,\n )\n else:\n raise Exception(\n f\"{self.model_id}: Error during Zenodo ('{publish_url}') upload (step 4: publishing uploaded model) due to user opt-out: You typed '{is_user_sure}' instead of 'Yes'. Model was not published. Try again. Your Zenodo deposition ID (if retrieved): '{deposition_id}'.\"\n )\n if not r.status_code == 202:\n raise Exception(\n f\"{self.model_id}: Error ({r.status_code}!=202) during Zenodo ('{publish_url}') upload (step 4: publishing uploaded model): {r.json()}\"\n )\n logging.info(\n f\"{self.model_id}: Successfully pushed model to Zenodo with DOI '{r.json()['doi']}': '{r.json()['links']['record_html']}\"\n )\n logging.debug(\n f\"{self.model_id}: Full Zenodo API response after successful publishing of model: {r.json()}\"\n )\n return r\n\n def push(\n self,\n metadata: dict,\n package_path: str,\n package_name: str,\n creator_name: str,\n creator_affiliation: str,\n model_description: str = \"\",\n ):\n \"\"\"Upload the model files as zip archive to a public Zenodo repository where the model will be persistently stored.\n\n Get your Zenodo access token here: https://zenodo.org/account/settings/applications/tokens/new/ (Enable scopes `deposit:actions` and `deposit:write`)\n\n Parameters\n ----------\n metadata: dict\n The model's corresponding metadata\n package_path: dict\n The path to the packaged model files\n package_name: dict\n The name of the packaged model files\n creator_name: str\n the creator name that will appear on the corresponding Zenodo model upload homepage\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding Zenodo model upload homepage\n model_description: list\n the model_description that will appear on the corresponding Zenodo model upload homepage\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding Zenodo model upload homepage\n \"\"\"\n\n # Check if zip file exists, else create new one for upload.\n filename, file_path = self.locate_or_create_model_zip_file(\n package_path=package_path, package_name=package_name\n )\n\n # create empty upload to Zenodo to get deposition_id and bucket_url\n response = self.empty_upload()\n logging.debug(f\"API Response after creating empty upload template: {response}\")\n\n # Get the deposition id from the response\n deposition_id = response.json()[\"id\"]\n\n # Using bucket as defined by Zenodo API for zip file model upload\n bucket_url = response.json()[\"links\"][\"bucket\"]\n\n logging.info(\n f\"Starting Zenodo upload of model with deposition_id {deposition_id} to {bucket_url}\"\n )\n response = self.upload(\n file_path=file_path,\n filename=filename,\n bucket_url=bucket_url,\n )\n logging.debug(\n f\"API Response after uploading model to '{bucket_url}': {response}\"\n )\n\n # get the model description i.e. model type, metadata info, etc.\n description = self.create_upload_description(\n metadata=metadata, model_description=model_description\n )\n\n # get the data that includes description, but also creator information\n data = self.create_upload_json_data(\n description=description,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n )\n\n # upload the model zip file and its descriptive data\n response = self.upload_descriptive_data(deposition_id=deposition_id, data=data)\n logging.debug(\n f\"API Response after uploading descriptive model data: {response}\"\n )\n\n # publish to Zenodo. Model will get DOI after this step and become part of Zenodo's permanent record.\n response = self.publish(deposition_id=deposition_id)\n logging.debug(\n f\"API Response after publishing the deposition {deposition_id} on Zenodo: {response}\"\n )\n return response.json()[\"links\"][\"record_html\"] # zenodo_record_url\n\n def __repr__(self):\n return f\"ZenodoModelUploader(model_id={self.model_id}, zenodo_url={ZENODO_API_URL})\"\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/exceptions.py", "content": "# -*- coding: utf-8 -*-\n#! /usr/bin/env python\n\"\"\"Custom exceptions to handle module specific error and facilitate bug fixes and debugging.\"\"\"\n\n# TODO Add custom exceptions for improved exception handling.\n# See requests.exceptions for reference.\n" }, { "path": "src/medigan/execute_model/__init__.py", "content": "" }, { "path": "src/medigan/execute_model/install_model_dependencies.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" Functionality for automated installation of a model's python package dependencies. \"\"\"\n\nimport argparse\nimport subprocess\nimport sys\n\ntry:\n # if called as script (__main__) or from inside medigan\n from ..config_manager import ConfigManager\n from ..constants import CONFIG_FILE_KEY_DEPENDENCIES, CONFIG_FILE_KEY_EXECUTION\nexcept:\n # if called from outside medigan\n from medigan.config_manager import ConfigManager\n from medigan.constants import (\n CONFIG_FILE_KEY_DEPENDENCIES,\n CONFIG_FILE_KEY_EXECUTION,\n )\n\n\ndef parse_args() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--model_id\",\n type=str,\n default=None,\n nargs=\"+\",\n help=\"Model ids to install dependencies for\",\n )\n args = parser.parse_args()\n return args\n\n\ndef install_model(\n model_id: str, config_manager: ConfigManager = None, execution_config: dict = None\n):\n \"\"\"installing the dependencies required for this model as stated in config\"\"\"\n\n if execution_config is None:\n if config_manager is None:\n config_manager = ConfigManager()\n config = config_manager.get_config_by_id(model_id)\n execution_config = config[CONFIG_FILE_KEY_EXECUTION]\n dependencies = execution_config[CONFIG_FILE_KEY_DEPENDENCIES]\n for package in dependencies:\n subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", package])\n\n\nif __name__ == \"__main__\":\n \"\"\"\n This script is used to install dependencies for models.\n If no model_id is provided, all models from the config file are installed.\n \"\"\"\n args = parse_args()\n\n config_manager = ConfigManager()\n\n if args.model_id:\n for model_id in args.model_id:\n install_model(model_id)\n else:\n for model_id in config_manager.config_dict.keys():\n install_model(model_id)\n" }, { "path": "src/medigan/execute_model/model_executor.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"Model executor class that downloads models, loads them as python packages, and runs their generate functions. \"\"\"\n\n# Import python native libs\nfrom __future__ import absolute_import\n\nimport importlib\nimport logging\nimport os\nimport time\n\n# Import pypi libs\nfrom pathlib import Path\n\nimport pkg_resources\nfrom tqdm import tqdm\n\n# Import library internal modules\nfrom ..constants import (\n CONFIG_FILE_KEY_DEPENDENCIES,\n CONFIG_FILE_KEY_GENERATE,\n CONFIG_FILE_KEY_GENERATE_ARGS,\n CONFIG_FILE_KEY_GENERATE_ARGS_BASE,\n CONFIG_FILE_KEY_GENERATE_ARGS_CUSTOM,\n CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE,\n CONFIG_FILE_KEY_GENERATE_ARGS_MODEL_FILE,\n CONFIG_FILE_KEY_GENERATE_ARGS_NUM_SAMPLES,\n CONFIG_FILE_KEY_GENERATE_ARGS_OUTPUT_PATH,\n CONFIG_FILE_KEY_GENERATE_ARGS_SAVE_IMAGES,\n CONFIG_FILE_KEY_GENERATE_NAME,\n CONFIG_FILE_KEY_IMAGE_SIZE,\n CONFIG_FILE_KEY_MODEL_EXTENSION,\n CONFIG_FILE_KEY_MODEL_NAME,\n CONFIG_FILE_KEY_PACKAGE_LINK,\n CONFIG_FILE_KEY_PACKAGE_NAME,\n DEFAULT_OUTPUT_FOLDER,\n MODEL_FOLDER,\n PACKAGE_EXTENSION,\n)\nfrom ..utils import Utils\nfrom .install_model_dependencies import install_model\n\n\nclass ModelExecutor:\n \"\"\"`ModelExecutor` class: Find config links to download models, init models as python packages, run generate methods.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n execution_config: dict\n The part of the config below the 'execution' key\n download_package: bool\n Flag indicating, if True, that the model's package should be downloaded instead of using an existing one that\n was downloaded previously\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n\n\n Attributes\n ----------\n model_id: str\n The generative model's unique id\n execution_config: dict\n The part of the config below the 'execution' key\n download_package: bool\n Flag indicating, if True, that the model's package should be downloaded instead of using an existing one that\n was downloaded previously\n image_size: int\n Pixel dimension of the generated samples, where images are assumed to have the same width and height\n dependencies: list\n List of the dependencies of a models python package.\n model_name: str\n Name of the generative model\n model_extension: str\n File extension of the generative model's weights file.\n package_name: str\n Name of the model's python package i.e. the name of the model's zip file and unzipped package folder\n package_link: str\n The link to the zipped model package. Note: Convention is to host models on Zenodo (reason: static doi content)\n generate_method_name: str\n The name of the model's generate method inside the model package. This method is called to generate samples.\n generate_method_args: dict\n The args of the model's generate method inside the model package\n serialised_model_file_path: str\n Path as string to the generative model's weights file\n package_path: str\n Path as string to the generative model's python package containing an `__init__.py` file\n deserialized_model_as_lib\n The generative model's package imported as python library. Generate method inside this library can be called.\n \"\"\"\n\n def __init__(\n self,\n model_id: str,\n execution_config: dict,\n download_package: bool = True,\n install_dependencies: bool = False,\n ):\n self.model_id = model_id\n self.execution_config = execution_config\n self.download_package = download_package\n self.install_dependencies = install_dependencies\n self.image_size = None\n self.dependencies = None\n self.model_name = None\n self.model_extension = None\n self.package_name = None\n self.package_link = None\n self.generate_method_name = None\n self.generate_method_args = None\n self.generate_method_input_latent_vector_size = None\n self.serialised_model_file_path = None\n self.package_path = None\n self.deserialized_model_as_lib = None\n self._setup_model_package()\n\n def _setup_model_package(self):\n \"\"\"Use specific keys to retrieve needed model config values and load and initialize the model as package.\"\"\"\n\n self.image_size = self.execution_config[CONFIG_FILE_KEY_IMAGE_SIZE]\n self.dependencies = self.execution_config[CONFIG_FILE_KEY_DEPENDENCIES]\n self.model_name = self.execution_config[CONFIG_FILE_KEY_MODEL_NAME]\n self.model_extension = self.execution_config[CONFIG_FILE_KEY_MODEL_EXTENSION]\n self.package_name = self.execution_config[CONFIG_FILE_KEY_PACKAGE_NAME]\n self.package_link = self.execution_config[CONFIG_FILE_KEY_PACKAGE_LINK]\n self.generate_method_name = self.execution_config[CONFIG_FILE_KEY_GENERATE][\n CONFIG_FILE_KEY_GENERATE_NAME\n ]\n self.generate_method_args = self.execution_config[CONFIG_FILE_KEY_GENERATE][\n CONFIG_FILE_KEY_GENERATE_ARGS\n ]\n if (\n CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE\n in self.execution_config[CONFIG_FILE_KEY_GENERATE]\n ):\n self.generate_method_input_latent_vector_size = self.execution_config[\n CONFIG_FILE_KEY_GENERATE\n ][CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE]\n\n self._check_package_resources()\n if not self.is_model_already_unpacked():\n self._get_and_store_package()\n self._import_package_as_lib()\n\n def _check_package_resources(self):\n \"\"\"Check if the dependencies inside the generative model's package are installed in the current setup.\"\"\"\n\n logging.debug(\n f\"{self.model_id}: Now checking availability of dependencies of model: {self.dependencies}\"\n )\n try:\n pkg_resources.require(self.dependencies)\n logging.debug(\n f\"{self.model_id}: All necessary dependencies for model are available: {self.dependencies}\"\n )\n except Exception as e:\n if self.install_dependencies:\n logging.info(\n f\"{self.model_id}: Now installing dependencies using pip for model {self.dependencies}. This may take a few minutes.\"\n )\n install_model(\n model_id=self.model_id, execution_config=self.execution_config\n )\n else:\n raise Exception(\n f\"{self.model_id}: Some of the necessary dependencies ({self.dependencies}) for this model \"\n f\"are missing. Either set install_dependencies=True or manually run 'python src/medigan/install_model_dependencies.py --model_id {self.model_id}' to install them. Error: {e}\"\n )\n\n def _get_and_store_package(self):\n \"\"\"Load and store the generative model's python package using the link from the model's `execution_config`.\"\"\"\n\n if self.package_path is None:\n assert Utils.mkdirs(path_as_string=f\"{MODEL_FOLDER}/{self.model_id}\"), (\n f\"{self.model_id}: The model folder was not found nor created \"\n f\"in {MODEL_FOLDER}/{self.model_id}.\"\n )\n package_path = Path(\n f\"{MODEL_FOLDER}/{self.model_id}/{self.package_name}{PACKAGE_EXTENSION}\"\n )\n try:\n if not Utils.is_file_located_or_downloaded(\n path_as_string=package_path,\n download_if_not_found=True,\n download_link=self.package_link,\n ):\n error_string = (\n f\"{self.model_id}: The package archive ({self.package_name}{PACKAGE_EXTENSION}) \"\n f\"was not found in {package_path} nor downloaded from {self.package_link}.\"\n )\n raise FileNotFoundError(error_string)\n except Exception as e:\n raise e\n self.package_path = package_path\n logging.info(\n f\"{self.model_id}: Model package should now be available in: {self.package_path}.\"\n )\n\n def is_model_already_unpacked(self) -> bool:\n \"\"\"Check if a valid path to the model files exists and, if so, set the `package_path`\"\"\"\n\n path_option_1 = Path(\n f\"{MODEL_FOLDER}/{self.model_id}/{self.package_name}/{self.model_name}{self.model_extension}\"\n )\n\n path_option_2 = Path(\n f\"{MODEL_FOLDER}/{self.model_id}/{self.model_name}{self.model_extension}\"\n )\n\n if path_option_1.is_file():\n self.package_path = path_option_1\n return True\n\n if path_option_2.is_file():\n self.package_path = path_option_2\n return True\n\n return False\n\n def _import_package_as_lib(self):\n \"\"\"Unzip and import the generative model's python package using importlib.\"\"\"\n\n logging.debug(\n f\"{self.model_id}: Now importing model package ({self.package_name}) as lib using \"\n f\"importlib from {self.package_path}.\"\n )\n is_model_already_unpacked = self.is_model_already_unpacked()\n # if is_model_already_unpacked == True, then the package was already unzipped previously.\n\n if (\n self.package_path.is_file()\n and PACKAGE_EXTENSION == \".zip\"\n and not is_model_already_unpacked\n ):\n # Unzip the model package in {MODEL_FOLDER}/{model_id}/{MODEL_PACKAGE}{PACKAGE_EXTENSION}\n Utils.unzip_archive(\n source_path=self.package_path,\n target_path=f\"{MODEL_FOLDER}/{self.model_id}\",\n )\n else:\n logging.debug(\n f\"{self.model_id}: Either no file found (== {self.package_path.is_file()}) or package \"\n f\"already unarchived (=={is_model_already_unpacked}) in {self.package_path}. \"\n f\"No action was taken.\"\n )\n try:\n # Installing generative model as python library\n self.deserialized_model_as_lib = importlib.import_module(\n name=f\"{MODEL_FOLDER}.{self.model_id}.{self.package_name}\"\n )\n if not hasattr(\n self.deserialized_model_as_lib, f\"{self.generate_method_name}\"\n ):\n # if generate method is not in lib path, generating samples will not work. Next: Check fallback folder.\n raise ModuleNotFoundError\n self.serialised_model_file_path = f\"{MODEL_FOLDER}/{self.model_id}/{self.package_name}/{self.model_name}{self.model_extension}\"\n except ModuleNotFoundError:\n try:\n # Fallback: The zip's content might have been unzipped in the model_id folder without generating the package_name subfolder.\n self.deserialized_model_as_lib = importlib.import_module(\n name=f\"{MODEL_FOLDER}.{self.model_id}\"\n )\n if not hasattr(\n self.deserialized_model_as_lib, f\"{self.generate_method_name}\"\n ):\n # if generate method is not in lib path, generating samples will not work. Next: Check fallback folder.\n raise AttributeError(\n f\"Module '{MODEL_FOLDER}.{self.model_id}' has no attribute \"\n f\"'{self.generate_method_name}' (generate method). We also tried module \"\n f\"'{MODEL_FOLDER}.{self.model_id}.{self.package_name}'. Please check if \"\n f\"generate_method_name and package_name are correct for this model in its \"\n f\"global.json entry.\"\n )\n self.serialised_model_file_path = f\"{MODEL_FOLDER}/{self.model_id}/{self.model_name}{self.model_extension}\"\n except Exception as e:\n logging.error(\n f\"{self.model_id}: Error occurred while trying to import \"\n f\"'{MODEL_FOLDER}.{self.model_id}.{self.package_name}'.\"\n f\"Fallback import of '{MODEL_FOLDER}.{self.model_id}' also failed. \"\n f\"Please make sure the module '{MODEL_FOLDER}' is not imported from elsewhere in your syspath: {e}\"\n )\n raise e\n\n def generate(\n self,\n num_samples: int = 20,\n output_path: str = None,\n save_images: bool = True,\n is_gen_function_returned: bool = False,\n batch_size: int = 32,\n **kwargs,\n ):\n \"\"\"Generate samples using the generative model or return the model's generate function.\n\n The name amd additional parameters of the generate function of the respective generative model are retrieved\n from the model's `execution_config`.\n\n Parameters\n ----------\n num_samples: int\n the number of samples that will be generated\n output_path: str\n the path as str to the output folder where the generated samples will be stored\n save_images: bool\n flag indicating whether generated samples are returned (i.e. as list of numpy arrays) or rather stored in file system (i.e in `output_path`)\n is_gen_function_returned: bool\n flag indicating whether, instead of generating samples, the sample generation function will be returned\n batch_size: int\n the batch size for the sample generation function\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n\n Returns\n -------\n list\n Returns images as list of numpy arrays if `save_images` is False. However, if `is_gen_function_returned` is True, it returns the internal generate function of the model.\n\n Raises\n ------\n Exception\n If the generate method of the model does not exist, cannot be called, or is called with missing params, or\n if the sample generation inside the model package returns an exception.\n \"\"\"\n\n if output_path is None:\n output_path = f\"{DEFAULT_OUTPUT_FOLDER}/{self.model_id}/{time.time()}/\"\n assert Utils.mkdirs(\n path_as_string=output_path\n ), f\"{self.model_id}: The output folder was not found nor created in {output_path}.\"\n try:\n generate_method = getattr(\n self.deserialized_model_as_lib, f\"{self.generate_method_name}\"\n )\n prepared_kwargs = self._prepare_generate_method_args(\n model_file=self.serialised_model_file_path,\n num_samples=num_samples,\n output_path=output_path,\n save_images=save_images,\n **kwargs,\n )\n logging.debug(f\"The generate function's parameters are: {prepared_kwargs}\")\n if is_gen_function_returned:\n\n def gen(**some_other_kwargs):\n logging.debug(\n f\"Generate method called with the following params. (i) default: {prepared_kwargs}, \"\n f\"(ii) custom: {some_other_kwargs}\"\n )\n prepared_kwargs.update(some_other_kwargs)\n return generate_method(**prepared_kwargs)\n\n return gen\n elif save_images:\n sample_index = 1\n prepared_kwargs.update({\"num_samples\": batch_size})\n for batch_num in tqdm(range(0, num_samples // batch_size + 1)):\n if batch_num == num_samples // batch_size:\n batch_size = num_samples % batch_size\n prepared_kwargs.update({\"num_samples\": batch_size})\n\n batch_path = (\n os.path.join(output_path, \"batch_\" + str(batch_num)) + \"/\"\n )\n\n # Generate the path in case it is not yet available.\n assert Utils.mkdirs(\n path_as_string=batch_path\n ), f\"{self.model_id}: The batch path was not found nor created in {batch_path}.\"\n\n prepared_kwargs.update({\"output_path\": batch_path})\n\n generate_method(**prepared_kwargs)\n\n for filename in os.listdir(batch_path):\n os.rename(\n os.path.join(batch_path, filename),\n os.path.join(\n output_path, \"batch_\" + str(batch_num) + \"_\" + filename\n ),\n )\n sample_index += 1\n\n os.rmdir(batch_path)\n else:\n return generate_method(**prepared_kwargs)\n\n except Exception as e:\n logging.error(\n f\"{self.model_id}: Error while trying to generate images with model \"\n f\"{self.serialised_model_file_path}: {e}\"\n )\n raise e\n\n def _prepare_generate_method_args(\n self,\n model_file: str,\n num_samples: int,\n output_path: str,\n save_images: bool,\n **kwargs,\n ):\n \"\"\"Prepare the keyword arguments that will be passed to the models generate function.\n\n Prepares the keyword arguments that need to be passed to the generative model's generate function to generate\n samples. This contains the steps:\n\n - Update keyword args dict with default values for all params from model config\n\n - Update keyword args dict with the `**args` provided by user thus overwriting the previously set default\n values for which user has provided key-value pairs.\n\n - Checking if all mandatory 'base' values are set in model config.\n\n - Update keyword args dict with 'base' key-value pairs, which i.e. are the param values for `model_file`,\n `num_samples` and `output_path`, thus overwriting any previously set value for these keys.\n\n - Returning the updated and prepared keyword args dict\n\n Parameters\n ----------\n model_file : str\n the path to the serialized weights of the generative model.\n num_samples: int\n the number of samples that will be generated\n output_path: str\n the path as str to the output folder where the generated samples will be stored\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n\n Returns\n -------\n dict\n kwargs as dictionary containing both user input params (prioritized) and config input params of the model\n \"\"\"\n\n prepared_kwargs: dict = {}\n # get keys of mandatory custom dictionary input args and assign the default value from config to values of keys\n prepared_kwargs.update(\n self.generate_method_args[CONFIG_FILE_KEY_GENERATE_ARGS_CUSTOM]\n )\n\n # update: If one of these keys was provided in **kwargs, then change default value to value provided in **kwargs\n prepared_kwargs.update(kwargs)\n\n try:\n # validating that these specific keys are available in the config. also retrieving default values\n base_config_list = [\n self.generate_method_args[CONFIG_FILE_KEY_GENERATE_ARGS_BASE][0],\n self.generate_method_args[CONFIG_FILE_KEY_GENERATE_ARGS_BASE][1],\n self.generate_method_args[CONFIG_FILE_KEY_GENERATE_ARGS_BASE][2],\n self.generate_method_args[CONFIG_FILE_KEY_GENERATE_ARGS_BASE][3],\n ]\n if not all(\n x in base_config_list\n for x in [\n CONFIG_FILE_KEY_GENERATE_ARGS_MODEL_FILE,\n CONFIG_FILE_KEY_GENERATE_ARGS_NUM_SAMPLES,\n CONFIG_FILE_KEY_GENERATE_ARGS_OUTPUT_PATH,\n CONFIG_FILE_KEY_GENERATE_ARGS_SAVE_IMAGES,\n ]\n ):\n raise KeyError\n except KeyError as e:\n logging.warning(\n f\"{self.model_id}: Warning: In this model's generate args ({self.generate_method_args}), some \"\n f\"required generate method keys ({CONFIG_FILE_KEY_GENERATE_ARGS_MODEL_FILE}, \"\n f\"{CONFIG_FILE_KEY_GENERATE_ARGS_NUM_SAMPLES}, {CONFIG_FILE_KEY_GENERATE_ARGS_OUTPUT_PATH}, \"\n f\"{CONFIG_FILE_KEY_GENERATE_ARGS_SAVE_IMAGES}) are missing: {e}. A value for this key will be \"\n f\"provided nevertheless when calling the model's generate method ({self.generate_method_name})'. \"\n f\"This could hence cause an error.\"\n )\n # Adding the always necessary base parameters to kwargs. They are updated if erroneously\n # introduced via the user-provided kwargs.\n prepared_kwargs.update(\n {\n CONFIG_FILE_KEY_GENERATE_ARGS_MODEL_FILE: model_file,\n CONFIG_FILE_KEY_GENERATE_ARGS_NUM_SAMPLES: num_samples,\n CONFIG_FILE_KEY_GENERATE_ARGS_OUTPUT_PATH: output_path,\n CONFIG_FILE_KEY_GENERATE_ARGS_SAVE_IMAGES: save_images,\n }\n )\n return prepared_kwargs\n\n def __repr__(self):\n return (\n f\"ModelExecutor(model_id={self.model_id}, name={self.model_name}, package={self.package_name}, \"\n f\"image_size={self.image_size}, dependencies={self.dependencies}, link={self.package_link}, \"\n f\"path={self.serialised_model_file_path}, generate_method={self.generate_method_name}, \"\n f\"generate_method_args={self.generate_method_args})\"\n )\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/execute_model/synthetic_dataset.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" `SyntheticDataset` allows to return a generative model as torch dataset. \"\"\"\n\nfrom torch.utils.data import Dataset\n\n\nclass SyntheticDataset(Dataset):\n \"\"\"A synthetic dataset containing data generated by a model of medigan\n\n Parameters\n ----------\n samples: list\n List of data points in the dataset e.g. generated images as numpy array.\n masks: list\n List of segmentation masks, if applicable, pertaining to the `samples` items\n other_imaging_output: list\n List of other imaging output produced by the generative model (e.g. specific types of other masks/modalities)\n labels: list\n list of labels, if applicable, pertaining to the `samples` items\n transform:\n torch compose transform functions that are applied to the torch dataset.\n\n Attributes\n ----------\n samples: list\n List of data points in the dataset e.g. generated images as numpy array.\n masks: list\n List of segmentation masks, if applicable, pertaining to the `samples` items\n other_imaging_output: list\n List of other imaging output produced by the generative model (e.g. specific types of other masks/modalities)\n labels: list\n list of labels, if applicable, pertaining to the `samples` items\n transform:\n torch compose transform functions that are applied to the torch dataset.\n \"\"\"\n\n def __init__(\n self,\n samples,\n masks=None,\n other_imaging_output=None,\n labels=None,\n transform=None,\n ):\n self.samples = samples\n self.masks = masks\n self.other_imaging_output = other_imaging_output\n self.labels = labels\n self.transform = transform\n\n def __getitem__(self, index):\n x = self.samples[index]\n y = self.labels[index] if self.labels is not None else None\n mask = self.masks[index] if self.masks is not None else None\n other_imaging_output = (\n self.other_imaging_output[index]\n if self.other_imaging_output is not None\n else None\n )\n\n if self.transform:\n if mask is not None:\n if other_imaging_output is not None:\n x, mask, other_imaging_output = self.transform(\n x, mask, other_imaging_output\n )\n # transform needs to be applied to both mask and image.\n x, mask = self.transform(x, mask)\n elif other_imaging_output is not None:\n x, other_imaging_output = self.transform(x, other_imaging_output)\n else:\n x = self.transform(x)\n item = {\"sample\": x} # extendable dictionary\n if y is not None:\n item[\"label\"] = y\n if mask is not None:\n item[\"mask\"] = mask\n if other_imaging_output is not None:\n item[\"other_imaging_output\"] = other_imaging_output\n return item\n\n def __len__(self):\n return len(self.samples)\n" }, { "path": "src/medigan/generators.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" Base class providing user-library interaction methods for config management, and model selection and execution. \"\"\"\n\n# Import python native libs\nfrom __future__ import absolute_import\n\nimport logging\n\nfrom torch.utils.data import DataLoader, Dataset\n\n# Import library internal modules\nfrom .config_manager import ConfigManager\nfrom .constants import CONFIG_FILE_KEY_EXECUTION, MODEL_ID\nfrom .contribute_model.model_contributor import ModelContributor\nfrom .execute_model.model_executor import ModelExecutor\nfrom .execute_model.synthetic_dataset import SyntheticDataset\nfrom .model_visualizer import ModelVisualizer\nfrom .select_model.model_selector import ModelSelector\nfrom .utils import Utils\n\n# Import pypi libs\n\n\nclass Generators:\n \"\"\"`Generators` class: Contains medigan's public methods to facilitate users' automated sample generation workflows.\n\n Parameters\n ----------\n config_manager: ConfigManager\n Provides the config dictionary, based on which `model_ids` are retrieved and models are selected and executed\n model_selector: ModelSelector\n Provides model comparison, search, and selection based on keys/values in the selection part of the config dict\n model_executors: list\n List of initialized `ModelExecutor` instances that handle model package download, init, and sample generation\n initialize_all_models: bool\n Flag indicating, if True, that one `ModelExecutor` for each `model_id` in the config dict should be\n initialized triggered by creation of `Generators` class instance. Note that, if False, the `Generators` class\n will only initialize a `ModelExecutor` on the fly when need be i.e. when the generate method for the respective\n model is called.\n\n Attributes\n ----------\n config_manager: ConfigManager\n Provides the config dictionary, based on which model_ids are retrieved and models are selected and executed\n model_selector: ModelSelector\n Provides model comparison, search, and selection based on keys/values in the selection part of the config dict\n model_executors: list\n List of initialized `ModelExecutor` instances that handle model package download, init, and sample generation\n \"\"\"\n\n def __init__(\n self,\n config_manager: ConfigManager = None,\n model_selector: ModelSelector = None,\n model_executors: list = None,\n model_contributors: list = None,\n initialize_all_models: bool = False,\n ):\n if config_manager is None:\n self.config_manager = ConfigManager()\n logging.debug(f\"Initialized ConfigManager instance: {self.config_manager}\")\n else:\n self.config_manager = config_manager\n\n if model_selector is None:\n self.model_selector = ModelSelector(config_manager=self.config_manager)\n logging.debug(f\"Initialized ModelSelector instance: {self.model_selector}\")\n else:\n self.model_selector = model_selector\n\n if model_executors is None:\n self.model_executors = []\n else:\n self.model_executors = model_executors\n\n if model_contributors is None:\n self.model_contributors = []\n else:\n self.model_contributors = model_contributors\n\n if initialize_all_models:\n self.add_all_model_executors()\n\n ############################ CONFIG MANAGER METHODS ############################\n\n def get_config_by_id(self, model_id: str, config_key: str = None) -> dict:\n \"\"\"Get and return the part of the config below a `config_key` for a specific `model_id`.\n\n The config_key parameters can be separated by a '.' (dot) to allow for retrieval of nested config keys, e.g,\n 'execution.generator.name'\n\n This function calls an identically named function in a `ConfigManager` instance.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n config_key: str\n A key of interest present in the config dict\n\n Returns\n -------\n dict\n a dictionary from the part of the config file corresponding to `model_id` and `config_key`.\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n return self.config_manager.get_config_by_id(\n model_id=model_id, config_key=config_key\n )\n\n def is_model_metadata_valid(\n self, model_id: str, metadata: dict, is_local_model: bool = True\n ) -> bool:\n \"\"\"Checking if a model's corresponding metadata is valid.\n\n Specific fields in the model's metadata are mandatory. It is asserted if these key value pairs are present.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n metadata: dict\n The model's corresponding metadata\n is_local_model: bool\n flag indicating whether the tested model is a new local user model i.e not yet part of medigan's official models\n\n Returns\n -------\n bool\n Flag indicating whether the specific model's metadata format and fields are valid\n \"\"\"\n\n return self.config_manager.is_model_metadata_valid(\n model_id=model_id, metadata=metadata, is_local_model=is_local_model\n )\n\n def add_model_to_config(\n self,\n model_id: str,\n metadata: dict,\n is_local_model: bool = None,\n overwrite_existing_metadata: bool = False,\n store_new_config: bool = True,\n ) -> bool:\n \"\"\"Adding or updating a model entry in the global metadata.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n metadata: dict\n The model's corresponding metadata\n is_local_model: bool\n flag indicating whether the tested model is a new local user model i.e not yet part of medigan's official models\n overwrite_existing_metadata: bool\n in case of `is_local_model`, flag indicating whether existing metadata for this model in medigan's `config/global.json` should be overwritten.\n store_new_config: bool\n flag indicating whether the current model metadata should be stored on disk i.e. in config/\n\n Returns\n -------\n bool\n Flag indicating whether model metadata update was successfully concluded\n \"\"\"\n\n if is_local_model is None:\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n # if no model contributor can be found the model is assumed to be not a local model.\n is_local_model = not is_local_model == self.get_model_contributor_by_id(\n model_id=model_id\n )\n\n return self.config_manager.add_model_to_config(\n model_id=model_id,\n metadata=metadata,\n is_local_model=is_local_model,\n overwrite_existing_metadata=overwrite_existing_metadata,\n store_new_config=store_new_config,\n )\n\n ############################ MODEL SELECTOR METHODS ############################\n\n def list_models(self) -> list:\n \"\"\"Return the list of model_ids as strings based on config.\n\n Returns\n -------\n list\n \"\"\"\n\n return [model_id for model_id in self.config_manager.model_ids]\n\n def get_selection_criteria_by_id(\n self, model_id: str, is_model_id_removed: bool = True\n ) -> dict:\n \"\"\"Get and return the selection config dict for a specific model_id.\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n is_model_id_removed: bool\n flag to to remove the model_ids from first level of dictionary.\n\n Returns\n -------\n dict\n a dictionary corresponding to the selection config of a model\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n return self.model_selector.get_selection_criteria_by_id(model_id=model_id)\n\n def get_selection_criteria_by_ids(\n self, model_ids: list = None, are_model_ids_removed: bool = True\n ) -> list:\n \"\"\"Get and return a list of selection config dicts for each of the specified model_ids.\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n model_ids: list\n A list of generative models' unique ids or ids abbreviated as integers (e.g. 1, 2, .. 21)\n are_model_ids_removed: bool\n flag to remove the model_ids from first level of dictionary.\n\n Returns\n -------\n list\n a list of dictionaries each corresponding to the selection config of a model\n \"\"\"\n\n mapped_model_ids = []\n for model_id in model_ids:\n mapped_model_ids.append(\n self.config_manager.match_model_id(provided_model_id=model_id)\n )\n\n return self.model_selector.get_selection_criteria_by_ids(\n model_ids=mapped_model_ids, are_model_ids_removed=are_model_ids_removed\n )\n\n def get_selection_values_for_key(self, key: str, model_id: str = None) -> list:\n \"\"\"Get and return the value of a specified key of the selection dict in the config for a specific model_id.\n\n The key param can contain '.' (dot) separations to allow for retrieval of nested config keys such as\n 'execution.generator.name'\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n key: str\n The key in the selection dict\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n list\n a list of the values that correspond to the key in the selection config of the `model_id`.\n \"\"\"\n\n return self.model_selector.get_selection_values_for_key(\n key=key, model_id=model_id\n )\n\n def get_selection_keys(self, model_id: str = None) -> list:\n \"\"\"Get and return all first level keys from the selection config dict for a specific model_id.\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n list\n a list containing the keys as strings of the selection config of the `model_id`.\n \"\"\"\n\n return self.model_selector.get_selection_keys(model_id=model_id)\n\n def get_models_by_key_value_pair(\n self, key1: str, value1: str, is_case_sensitive: bool = False\n ) -> list:\n \"\"\"Get and return a list of model_id dicts that contain the specified key value pair in their selection config.\n\n The key param can contain '.' (dot) separations to allow for retrieval of nested config keys such as\n 'execution.generator.name'\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n key1: str\n The key in the selection dict\n value1: str\n The value in the selection dict that corresponds to key1\n is_case_sensitive: bool\n flag to evaluate keys and values with case sensitivity if set to True\n\n Returns\n -------\n list\n a list of the dictionaries each containing a models id and the found key-value pair in the models config\n \"\"\"\n\n return self.model_selector.get_models_by_key_value_pair(\n key1=key1, value1=value1, is_case_sensitive=is_case_sensitive\n )\n\n def rank_models_by_performance(\n self, model_ids: list = None, metric: str = \"SSIM\", order: str = \"asc\"\n ) -> list:\n \"\"\"Rank model based on a provided metric and return sorted list of model dicts.\n\n The metric param can contain '.' (dot) separations to allow for retrieval of nested metric config keys such as\n 'downstream_task.CLF.accuracy'\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n model_ids: list\n only evaluate the `model_ids` in this list. If none, evaluate all available `model_ids`\n metric: str\n The key in the selection dict that corresponds to the metric of interest\n order: str\n the sorting order of the ranked results. Should be either \"asc\" (ascending) or \"desc\" (descending)\n\n Returns\n -------\n list\n a list of model dictionaries containing metric and `model_id`, sorted by metric.\n \"\"\"\n\n return self.model_selector.rank_models_by_performance(\n model_ids=model_ids, metric=metric, order=order\n )\n\n def find_matching_models_by_values(\n self,\n values: list,\n target_values_operator: str = \"AND\",\n are_keys_also_matched: bool = False,\n is_case_sensitive: bool = False,\n ) -> list:\n \"\"\"Search for values (and keys) in model configs and return a list of each matching `ModelMatchCandidate`.\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n values: list\n list of values used to search and find models corresponding to these `values`\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of model search results.\n Should be either \"AND\", \"OR\", or \"XOR\".\n are_keys_also_matched: bool\n flag indicating whether, apart from values, the keys in the model config should also be searchable\n is_case_sensitive: bool\n flag indicating whether the search for values (and) keys in the model config should be case-sensitive.\n\n Returns\n -------\n list\n a list of `ModelMatchCandidate` class instances each of which was successfully matched against the search\n values.\n \"\"\"\n\n return self.model_selector.find_matching_models_by_values(\n values=values,\n target_values_operator=target_values_operator,\n are_keys_also_matched=are_keys_also_matched,\n is_case_sensitive=is_case_sensitive,\n )\n\n def find_models_and_rank(\n self,\n values: list,\n target_values_operator: str = \"AND\",\n are_keys_also_matched: bool = False,\n is_case_sensitive: bool = False,\n metric: str = \"SSIM\",\n order: str = \"asc\",\n ) -> list:\n \"\"\"Search for values (and keys) in model configs, rank results and return sorted list of model dicts.\n\n This function calls an identically named function in a `ModelSelector` instance.\n\n Parameters\n ----------\n values: list`\n list of values used to search and find models corresponding to these `values`\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of model search results.\n Should be either \"AND\", \"OR\", or \"XOR\".\n are_keys_also_matched: bool\n flag indicating whether, apart from values, the keys in the model config should also be searchable\n is_case_sensitive: bool\n flag indicating whether the search for values (and) keys in the model config should be case-sensitive.\n metric: str\n The key in the selection dict that corresponds to the metric of interest\n order: str\n the sorting order of the ranked results. Should be either \"asc\" (ascending) or \"desc\" (descending)\n\n Returns\n -------\n list\n a list of the searched and matched model dictionaries containing metric and model_id, sorted by metric.\n \"\"\"\n ranked_models = []\n matching_models = self.model_selector.find_matching_models_by_values(\n values=values,\n target_values_operator=target_values_operator,\n are_keys_also_matched=are_keys_also_matched,\n is_case_sensitive=is_case_sensitive,\n )\n if len(matching_models) < 1:\n logging.warning(\n f\"For your input, there were {len(matching_models)} matching models, while at least 1 is needed. \"\n f\"Please adjust either your metric your search value inputs {values} to find at least one match.\"\n )\n else:\n matching_model_ids = [model.model_id for model in matching_models]\n logging.debug(f\"matching_model_ids: {matching_model_ids}\")\n ranked_models = self.model_selector.rank_models_by_performance(\n model_ids=matching_model_ids, metric=metric, order=order\n )\n if len(ranked_models) < 1:\n logging.warning(\n f\"None ({len(ranked_models)}) of the {len(matching_model_ids)} found matching models, had a valid metric entry for {metric}. \"\n f\"Please adjust your metric to enable ranking of the found models.\"\n )\n return ranked_models\n\n def find_models_rank_and_generate(\n self,\n values: list,\n target_values_operator: str = \"AND\",\n are_keys_also_matched: bool = False,\n is_case_sensitive: bool = False,\n metric: str = \"SSIM\",\n order: str = \"asc\",\n num_samples: int = 30,\n output_path: str = None,\n is_gen_function_returned: bool = False,\n install_dependencies: bool = False,\n **kwargs,\n ):\n \"\"\"Search for values (and keys) in model configs, rank results to generate samples with highest ranked model.\n\n Parameters\n ----------\n values: list\n list of values used to search and find models corresponding to these `values`\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of model search results.\n Should be either \"AND\", \"OR\", or \"XOR\".\n are_keys_also_matched: bool\n flag indicating whether, apart from values, the keys in the model config should also be searchable\n is_case_sensitive: bool\n flag indicating whether the search for values (and) keys in the model config should be case-sensitive.\n metric: str\n The key in the selection dict that corresponds to the metric of interest\n order: str\n the sorting order of the ranked results. Should be either \"asc\" (ascending) or \"desc\" (descending)\n num_samples: int\n the number of samples that will be generated\n output_path: str\n the path as str to the output folder where the generated samples will be stored\n is_gen_function_returned: bool\n flag indicating whether, instead of generating samples, the sample generation function will be returned\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n\n Returns\n -------\n None\n However, if `is_gen_function_returned` is True, it returns the internal generate function of the model.\n \"\"\"\n ranked_models = self.find_models_and_rank(\n values=values,\n target_values_operator=target_values_operator,\n are_keys_also_matched=are_keys_also_matched,\n is_case_sensitive=is_case_sensitive,\n metric=metric,\n order=order,\n )\n\n assert ranked_models is not None and len(ranked_models) > 0, (\n f\"None of the models fulfilled both, the matching (values: {values}) AND \"\n f\"ranking (metric: {metric}) criteria you provided.\"\n )\n\n # Get the ID of the highest ranking model to generate() with that model\n highest_ranking_model_id = ranked_models[0][MODEL_ID]\n\n # Let's generate with the best-ranked model\n logging.info(\n f\"For your input, there were {len(ranked_models)} models found and ranked. \"\n f\"The highest ranked model ({highest_ranking_model_id}) will now be used for generation: \"\n f\"{ranked_models[0]}\"\n )\n\n return self.generate(\n model_id=highest_ranking_model_id,\n num_samples=num_samples,\n output_path=output_path,\n is_gen_function_returned=is_gen_function_returned,\n install_dependencies=install_dependencies,\n **kwargs,\n )\n\n def find_model_and_generate(\n self,\n values: list,\n target_values_operator: str = \"AND\",\n are_keys_also_matched: bool = False,\n is_case_sensitive: bool = False,\n num_samples: int = 30,\n output_path: str = None,\n is_gen_function_returned: bool = False,\n install_dependencies: bool = False,\n **kwargs,\n ):\n \"\"\"Search for values (and keys) in model configs to generate samples with the found model.\n\n Note that the number of found models should be ==1. Else no samples will be generated and a error is logged to\n console.\n\n Parameters\n ----------\n values: list\n list of values used to search and find models corresponding to these `values`\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of model search results.\n Should be either \"AND\", \"OR\", or \"XOR\".\n are_keys_also_matched: bool\n flag indicating whether, apart from values, the keys in the model config should also be searchable\n is_case_sensitive: bool\n flag indicating whether the search for values (and) keys in the model config should be case-sensitive.\n num_samples: int\n the number of samples that will be generated\n output_path: str\n the path as str to the output folder where the generated samples will be stored\n is_gen_function_returned: bool\n flag indicating whether, instead of generating samples, the sample generation function will be returned\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n\n Returns\n -------\n None\n However, if `is_gen_function_returned` is True, it returns the internal generate function of the model.\n \"\"\"\n\n matching_models: list = self.model_selector.find_matching_models_by_values(\n values=values,\n target_values_operator=target_values_operator,\n are_keys_also_matched=are_keys_also_matched,\n is_case_sensitive=is_case_sensitive,\n )\n if len(matching_models) > 1:\n logging.error(\n f\"For your input, there were more than 1 matching model ({len(matching_models)}). \"\n f\"Please choose one of the models (see model_ids below) or use find_models_rank_and_generate() instead.\"\n f\"Alternatively, you may also further specify additional search values apart from the provided ones \"\n f\"to find exactly one model: {values}. The matching models were the following: \\n {matching_models}\"\n )\n elif len(matching_models) < 1:\n logging.error(\n f\"For your input, there were {len(matching_models)} matching models, while 1 is needed. \"\n f\"Please adjust your search value inputs {values} to find at least one match.\"\n )\n else:\n # Exactly one matching model. Let's generate with this model\n logging.info(\n f\"For your input, there was {len(matching_models)} model matched. \"\n f\"This model will now be used for generation: {matching_models}\"\n )\n matched_model_id = matching_models[0].model_id\n return self.generate(\n model_id=matched_model_id,\n num_samples=num_samples,\n output_path=output_path,\n is_gen_function_returned=is_gen_function_returned,\n install_dependencies=install_dependencies,\n **kwargs,\n )\n\n ############################ MODEL EXECUTOR METHODS ############################\n\n def add_all_model_executors(self):\n \"\"\"Add `ModelExecutor` class instances for all models available in the config.\n\n Returns\n -------\n None\n \"\"\"\n\n for model_id in self.config_manager.model_ids:\n execution_config = self.config_manager.get_config_by_id(\n model_id=model_id, config_key=CONFIG_FILE_KEY_EXECUTION\n )\n self._add_model_executor(\n model_id=model_id, execution_config=execution_config\n )\n\n def add_model_executor(self, model_id: str, install_dependencies: bool = False):\n \"\"\"Add one `ModelExecutor` class instance corresponding to the specified `model_id`.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n\n\n Returns\n -------\n None\n \"\"\"\n\n if not self.is_model_executor_already_added(model_id):\n execution_config = self.config_manager.get_config_by_id(\n model_id=model_id, config_key=CONFIG_FILE_KEY_EXECUTION\n )\n self._add_model_executor(\n model_id=model_id,\n execution_config=execution_config,\n install_dependencies=install_dependencies,\n )\n\n def _add_model_executor(\n self, model_id: str, execution_config: dict, install_dependencies: bool = False\n ):\n \"\"\"Add one `ModelExecutor` class instance corresponding to the specified `model_id` and `execution_config`.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n execution_config: dict\n The part of the config below the 'execution' key\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n\n Returns\n -------\n None\n \"\"\"\n\n if not self.is_model_executor_already_added(model_id):\n model_executor = ModelExecutor(\n model_id=model_id,\n execution_config=execution_config,\n download_package=True,\n install_dependencies=install_dependencies,\n )\n self.model_executors.append(model_executor)\n\n def is_model_executor_already_added(self, model_id) -> bool:\n \"\"\"Check whether the `ModelExecutor` instance of this model_id is already in `self.model_executors` list.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n bool\n indicating whether this `ModelExecutor` had been already previously added to `self.model_executors`\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n if self.find_model_executor_by_id(model_id=model_id) is None:\n logging.debug(\n f\"{model_id}: The model has not yet been added to the model_executor list.\"\n )\n return False\n return True\n\n def find_model_executor_by_id(self, model_id: str) -> ModelExecutor:\n \"\"\"Find and return the `ModelExecutor` instance of this model_id in the `self.model_executors` list.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n ModelExecutor\n `ModelExecutor` class instance corresponding to the `model_id`\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n for idx, model_executor in enumerate(self.model_executors):\n if model_executor.model_id == model_id:\n return model_executor\n return None\n\n def get_model_executor(\n self, model_id: str, install_dependencies: bool = False\n ) -> ModelExecutor:\n \"\"\"Add and return the `ModelExecutor` instance of this model_id from the `self.model_executors` list.\n\n Relies on `self.add_model_executor` and `self.find_model_executor_by_id` functions.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n\n Returns\n -------\n ModelExecutor\n `ModelExecutor` class instance corresponding to the `model_id`\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n try:\n self.add_model_executor(\n model_id=model_id,\n install_dependencies=install_dependencies,\n ) # only adds after checking that is not already added\n return self.find_model_executor_by_id(model_id=model_id)\n except Exception as e:\n logging.error(\n f\"{model_id}: This model could not be added to model_executor list: {e}\"\n )\n raise e\n\n def generate(\n self,\n model_id: str,\n num_samples: int = 30,\n output_path: str = None,\n save_images: bool = True,\n is_gen_function_returned: bool = False,\n install_dependencies: bool = False,\n **kwargs,\n ):\n \"\"\"Generate samples with the model corresponding to the `model_id` or return the model's generate function.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n num_samples: int\n the number of samples that will be generated\n output_path: str\n the path as str to the output folder where the generated samples will be stored\n save_images: bool\n flag indicating whether generated samples are returned (i.e. as list of numpy arrays) or rather stored in file system (i.e in `output_path`)\n is_gen_function_returned: bool\n flag indicating whether, instead of generating samples, the sample generation function will be returned\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n\n Returns\n -------\n list\n Returns images as list of numpy arrays if `save_images` is False. However, if `is_gen_function_returned` is True, it returns the internal generate function of the model.\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n model_executor = self.get_model_executor(\n model_id=model_id, install_dependencies=install_dependencies\n )\n return model_executor.generate(\n num_samples=num_samples,\n output_path=output_path,\n save_images=save_images,\n is_gen_function_returned=is_gen_function_returned,\n **kwargs,\n )\n\n def get_generate_function(\n self,\n model_id: str,\n num_samples: int = 30,\n output_path: str = None,\n install_dependencies: bool = False,\n **kwargs,\n ):\n \"\"\"Return the model's generate function.\n\n Relies on the `self.generate` function.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n num_samples: int\n the number of samples that will be generated\n output_path: str\n the path as str to the output folder where the generated samples will be stored\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n\n Returns\n -------\n function\n The internal reusable generate function of the generative model.\n \"\"\"\n\n return self.generate(\n model_id=model_id,\n num_samples=num_samples,\n output_path=output_path,\n is_gen_function_returned=True,\n install_dependencies=install_dependencies,\n **kwargs,\n )\n\n ############################ MODEL CONTRIBUTOR METHODS ############################\n\n def add_model_contributor(\n self,\n model_id: str,\n init_py_path: str = None,\n ) -> ModelContributor:\n \"\"\"Add a `ModelContributor` instance of this model_id to the `self.model_contributors` list.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n init_py_path: str\n The path to the local model's __init__.py file needed for importing and running this model.\n\n Returns\n -------\n ModelContributor\n `ModelContributor` class instance corresponding to the `model_id`\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n model_contributor = self.get_model_contributor_by_id(model_id=model_id)\n if model_contributor is not None:\n logging.warning(\n f\"{model_id}: For this model_id, there already exists a ModelContributor. None was added. Returning the existing one.\"\n )\n else:\n model_contributor = ModelContributor(\n model_id=model_id, init_py_path=init_py_path\n )\n self.model_contributors.append(model_contributor)\n return model_contributor\n\n def get_model_contributor_by_id(self, model_id: str) -> ModelContributor:\n \"\"\"Find and return the `ModelContributor` instance of this model_id in the `self.model_contributors` list.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n ModelContributor\n `ModelContributor` class instance corresponding to the `model_id`\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n for idx, model_contributor in enumerate(self.model_contributors):\n if model_contributor.model_id == model_id:\n return model_contributor\n return None\n\n def add_metadata_from_file(self, model_id: str, metadata_file_path: str) -> dict:\n \"\"\"Read and parse the metadata of a local model, identified by `model_id`, from a metadata file in json format.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n metadata_file_path: str\n the path pointing to the metadata file\n\n Returns\n -------\n dict\n Returns a dict containing the contents of parsed metadata json file.\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n model_contributor = self.get_model_contributor_by_id(model_id=model_id)\n assert (\n model_contributor is not None\n ), f\"{model_id}: No model_contributor is initialized for this model_id in Generators. Add a model_contributor first by running 'add_model_contributor()'.\"\n return model_contributor.add_metadata_from_file(\n metadata_file_path=metadata_file_path\n )\n\n def add_metadata_from_input(\n self,\n model_id: str,\n model_weights_name: str,\n model_weights_extension: str,\n generate_method_name: str,\n dependencies: list,\n fill_more_fields_interactively: bool = True,\n output_path: str = \"config\",\n ) -> dict:\n \"\"\"Create a metadata dict for a local model, identified by `model_id`, given the necessary minimum metadata contents.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n model_weights_name: str\n the name of the checkpoint file containing the model's weights\n model_weights_extension: str\n the extension (e.g. .pt) of the checkpoint file containing the model's weights\n generate_method_name: str\n the name of the sample generation method inside the models __init__.py file\n dependencies: list\n the list of dependencies that need to be installed via pip to run the model\n fill_more_fields_interactively: bool\n flag indicating whether a user will be interactively asked via command line for further input to fill out missing metadata content\n output_path: str\n the path where the created metadata json file will be stored\n\n Returns\n -------\n dict\n Returns a dict containing the contents of the metadata json file.\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n model_contributor = self.get_model_contributor_by_id(model_id=model_id)\n assert (\n model_contributor is not None\n ), f\"{model_id}: No model_contributor is initialized for this model_id in Generators. Add a model_contributor first by running 'add_model_contributor()'.\"\n return model_contributor.add_metadata_from_input(\n model_weights_name=model_weights_name,\n model_weights_extension=model_weights_extension,\n generate_method_name=generate_method_name,\n dependencies=dependencies,\n fill_more_fields_interactively=fill_more_fields_interactively,\n output_path=output_path,\n )\n\n def push_to_zenodo(\n self,\n model_id: str,\n zenodo_access_token: str,\n creator_name: str = \"unknown name\",\n creator_affiliation: str = \"unknown affiliation\",\n model_description: str = \"\",\n ) -> str:\n \"\"\"Upload the model files as zip archive to a public Zenodo repository where the model will be persistently stored.\n\n Get your Zenodo access token here: https://zenodo.org/account/settings/applications/tokens/new/ (Enable scopes `deposit:actions` and `deposit:write`)\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n zenodo_access_token: str\n a personal access token in Zenodo linked to a user account for authentication\n creator_name: str\n the creator name that will appear on the corresponding Zenodo model upload homepage\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding Zenodo model upload homepage\n model_description: list\n the model_description that will appear on the corresponding Zenodo model upload homepage\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding Zenodo model upload homepage\n \"\"\"\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n model_contributor = self.get_model_contributor_by_id(model_id=model_id)\n assert (\n model_contributor is not None\n ), f\"{model_id}: No model_contributor is initialized for this model_id in Generators. Add a model_contributor first by running 'add_model_contributor()'.\"\n\n return model_contributor.push_to_zenodo(\n access_token=zenodo_access_token,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n model_description=model_description,\n )\n\n def push_to_github(\n self,\n model_id: str,\n github_access_token: str,\n package_link: str = None,\n creator_name: str = \"\",\n creator_affiliation: str = \"\",\n model_description: str = \"\",\n ):\n \"\"\"Upload the model's metadata inside a github issue to the medigan github repository.\n\n To add your model to medigan, your metadata will be reviewed on Github and added to medigan's official model metadata\n\n The medigan repository issues page: https://github.com/RichardObi/medigan/issues\n\n Get your Github access token here: https://github.com/settings/tokens\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n github_access_token: str\n a personal access token linked to your github user account, used as means of authentication\n package_link:\n a package link\n creator_name: str\n the creator name that will appear on the corresponding github issue\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding github issue\n model_description: list\n the model_description that will appear on the corresponding github issue\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding issue on github\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n model_contributor = self.get_model_contributor_by_id(model_id=model_id)\n assert (\n model_contributor is not None\n ), f\"{model_id}: No model_contributor is initialized for this model_id in Generators. Add a model_contributor first by running 'add_model_contributor()'.\"\n\n return model_contributor.push_to_github(\n access_token=github_access_token,\n package_link=package_link,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n model_description=model_description,\n )\n\n def test_model(\n self,\n model_id: str,\n is_local_model: bool = True,\n overwrite_existing_metadata: bool = False,\n store_new_config: bool = True,\n num_samples: int = 3,\n install_dependencies: bool = False,\n ):\n \"\"\"Test if a model generates and returns a specific number of samples in the correct format\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n is_local_model: bool\n flag indicating whether the tested model is a new local user model i.e not yet part of medigan's official models\n overwrite_existing_metadata: bool\n in case of `is_local_model`, flag indicating whether existing metadata for this model in medigan's `config/global.json` should be overwritten.\n store_new_config: bool\n flag indicating whether the current model metadata should be stored on disk i.e. in config/\n num_samples: int\n the number of samples that will be generated\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed.\n Else error is raised if missing dependencies are detected.\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n if is_local_model:\n model_contributor = self.get_model_contributor_by_id(model_id=model_id)\n\n assert model_contributor is not None, (\n f\"{model_id}: No model_contributor is initialized for this model_id. Try to set 'is_local_model=False'\"\n f\"or add a model_contributor first by running 'add_model_contributor(model_id, init_py_path)' .\"\n )\n\n self.add_model_to_config(\n model_id=model_id,\n metadata=model_contributor.metadata,\n is_local_model=is_local_model,\n overwrite_existing_metadata=overwrite_existing_metadata,\n store_new_config=store_new_config,\n )\n samples = self.generate(\n model_id=model_id,\n save_images=False,\n install_dependencies=install_dependencies,\n num_samples=num_samples,\n )\n assert (\n samples is not None\n and isinstance(samples, list)\n and (\n (len(samples) == num_samples) or (len(samples) > num_samples)\n ) # e.g., len(samples) = num_samples + 1, as sample generation can be restricted to be balanced among classes\n ), (\n f\"{model_id}: Model test was not successful. The generated samples {'is None, but ' if samples is None else ''}\"\n f\"should be a list (actual type: {type(samples)}) and of length {num_samples} (actual length: \"\n f\"{'None' if samples is None else len(samples)}). Check if input params (e.g. input_path) to model are valid. \"\n ) # {f'Generated samples: {samples}' if samples is not None else ''}\"\n\n logging.info(\n f\"{model_id}: The test of \"\n f\"{'this new local user model' if is_local_model else 'this existing medigan model'} \"\n f\"was successful, as model created the expected number ({num_samples}) of synthetic \"\n f\"samples.\"\n )\n\n def contribute(\n self,\n model_id: str,\n init_py_path: str,\n github_access_token: str,\n zenodo_access_token: str,\n metadata_file_path: str = None,\n model_weights_name: str = None,\n model_weights_extension: str = None,\n generate_method_name: str = None,\n dependencies: list = None,\n fill_more_fields_interactively: bool = True,\n overwrite_existing_metadata: bool = False,\n output_path: str = \"config\",\n creator_name: str = \"unknown name\",\n creator_affiliation: str = \"unknown affiliation\",\n model_description: str = \"\",\n install_dependencies: bool = False,\n ):\n \"\"\"Implements the full model contribution workflow including model metadata generation, model test, model Zenodo upload, and medigan github issue creation.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n init_py_path: str\n The path to the local model's __init__.py file needed for importing and running this model.\n github_access_token: str\n a personal access token linked to your github user account, used as means of authentication\n zenodo_access_token: str\n a personal access token in Zenodo linked to a user account for authentication\n metadata_file_path: str\n the path pointing to the metadata file\n model_weights_name: str\n the name of the checkpoint file containing the model's weights\n model_weights_extension: str\n the extension (e.g. .pt) of the checkpoint file containing the model's weights\n generate_method_name: str\n the name of the sample generation method inside the models __init__.py file\n dependencies: list\n the list of dependencies that need to be installed via pip to run the model\n fill_more_fields_interactively: bool\n flag indicating whether a user will be interactively asked via command line for further input to fill out missing metadata content\n overwrite_existing_metadata: bool\n flag indicating whether existing metadata for this model in medigan's `config/global.json` should be overwritten.\n output_path: str\n the path where the created metadata json file will be stored\n creator_name: str\n the creator name that will appear on the corresponding github issue\n creator_affiliation: str\n the creator affiliation that will appear on the corresponding github issue\n model_description: list\n the model_description that will appear on the corresponding github issue\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed.\n Else error is raised if missing dependencies are detected.\n\n Returns\n -------\n str\n Returns the url pointing to the corresponding issue on github\n \"\"\"\n\n # Create model contributor\n self.add_model_contributor(model_id=model_id, init_py_path=init_py_path)\n\n # Adding the metadata of the model from input\n if metadata_file_path is not None:\n # Using an existing metadata json\n metadata = self.add_metadata_from_file(\n model_id=model_id, metadata_file_path=metadata_file_path\n )\n else:\n # Creating the metadata json\n metadata = self.add_metadata_from_input(\n model_id=model_id,\n model_weights_name=model_weights_name,\n model_weights_extension=model_weights_extension,\n generate_method_name=generate_method_name,\n dependencies=dependencies,\n fill_more_fields_interactively=fill_more_fields_interactively,\n output_path=output_path,\n )\n logging.debug(\n f\"{model_id}: The following model metadata was created: {metadata}\"\n )\n\n try:\n self.test_model(\n model_id=model_id,\n is_local_model=True,\n overwrite_existing_metadata=overwrite_existing_metadata,\n install_dependencies=install_dependencies,\n )\n except Exception as e:\n logging.error(\n f\"{model_id}: Error while testing this local model. \"\n f\"Please revise and run model contribute() again. {e}\"\n )\n raise e\n\n # Model Upload to Zenodo\n zenodo_record_url = self.push_to_zenodo(\n model_id=model_id,\n zenodo_access_token=zenodo_access_token,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n model_description=model_description,\n )\n\n # Creating and returning an issue with model metadata in medigan's Github\n return self.push_to_github(\n model_id=model_id,\n package_link=zenodo_record_url,\n github_access_token=github_access_token,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n model_description=model_description,\n )\n\n ############################ OTHER METHODS ############################\n\n def get_as_torch_dataloader(\n self,\n dataset=None,\n model_id: str = None,\n num_samples: int = 1000,\n install_dependencies: bool = False,\n transform=None,\n batch_size=None,\n shuffle=None,\n sampler=None,\n batch_sampler=None,\n num_workers=None,\n collate_fn=None,\n pin_memory=None,\n drop_last=None,\n timeout=None,\n worker_init_fn=None,\n prefetch_factor: int = None,\n persistent_workers: bool = None,\n pin_memory_device: str = None,\n **kwargs,\n ) -> DataLoader:\n \"\"\"Get torch Dataloader sampling synthetic data from medigan model.\n\n Dataloader combines a dataset and a sampler, and provides an iterable over\n the given torch dataset. Dataloader is created for synthetic data for the specified medigan model.\n Pytorch native parameters are set to ``None`` per default. Only those params are are passed to the Dataloader()\n initialization function that are not ``None``.\n\n Args:\n dataset (Dataset): dataset from which to load the data.\n model_id: str\n The generative model's unique id\n num_samples: int\n the number of samples that will be generated\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed.\n Else error is raised if missing dependencies are detected.\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function\n (e.g. the input path for image-to-image translation models in medigan).\n transform\n the torch data transformation functions to be applied to the data in the dataset.\n batch_size (int, optional): how many samples per batch to load\n (default: ``None``).\n shuffle (bool, optional): set to ``True`` to have the data reshuffled\n at every epoch (default: ``None``).\n sampler (Sampler or Iterable, optional): defines the strategy to draw\n samples from the dataset. Can be any ``Iterable`` with ``__len__``\n implemented. If specified, :attr:`shuffle` must not be specified. (default: ``None``)\n batch_sampler (Sampler or Iterable, optional): like :attr:`sampler`, but\n returns a batch of indices at a time. Mutually exclusive with\n :attr:`batch_size`, :attr:`shuffle`, :attr:`sampler`,\n and :attr:`drop_last`. (default: ``None``)\n num_workers (int, optional): how many subprocesses to use for data\n loading. ``0`` means that the data will be loaded in the main process.\n (default: ``None``)\n collate_fn (callable, optional): merges a list of samples to form a\n mini-batch of Tensor(s). Used when using batched loading from a\n map-style dataset. (default: ``None``)\n pin_memory (bool, optional): If ``True``, the data loader will copy Tensors\n into CUDA pinned memory before returning them. If your data elements\n are a custom type, or your :attr:`collate_fn` returns a batch that is a custom type,\n see the example below. (default: ``None``)\n drop_last (bool, optional): set to ``True`` to drop the last incomplete batch,\n if the dataset size is not divisible by the batch size. If ``False`` and\n the size of dataset is not divisible by the batch size, then the last batch\n will be smaller. (default: ``None``)\n timeout (numeric, optional): if positive, the timeout value for collecting a batch\n from workers. Should always be non-negative. (default: ``None``)\n worker_init_fn (callable, optional): If not ``None``, this will be called on each\n worker subprocess with the worker id (an int in ``[0, num_workers - 1]``) as\n input, after seeding and before data loading. (default: ``None``)\n prefetch_factor (int, optional, keyword-only arg): Number of batches loaded\n in advance by each worker. ``2`` means there will be a total of\n 2 * num_workers batches prefetched across all workers. (default: ``None``).\n persistent_workers (bool, optional): If ``True``, the data loader will not shutdown\n the worker processes after a dataset has been consumed once. This allows to\n maintain the workers `Dataset` instances alive. (default: ``None``)\n pin_memory_device (str, optional): the device to pin memory to if ``pin_memory`` is ``True`` (default: ``None``).\n\n Returns\n -------\n DataLoader\n a torch.utils.data.DataLoader object with data generated by model corresponding to inputted `Dataset` or `model_id`.\n \"\"\"\n\n dataset = (\n self.get_as_torch_dataset(\n model_id=model_id,\n num_samples=num_samples,\n install_dependencies=install_dependencies,\n transform=transform,\n **kwargs,\n )\n if dataset is None\n else dataset\n )\n\n # Reducing dependency on torch.util.data.DataLoader param default values by passing\n # only the ones specified by the user.\n dataloader = Utils.call_without_removable_params(\n my_callable=DataLoader,\n removable_param_values=[None],\n dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n sampler=sampler,\n batch_sampler=batch_sampler,\n num_workers=num_workers,\n collate_fn=collate_fn,\n pin_memory=pin_memory,\n drop_last=drop_last,\n timeout=timeout,\n worker_init_fn=worker_init_fn,\n prefetch_factor=prefetch_factor,\n persistent_workers=persistent_workers,\n pin_memory_device=pin_memory_device,\n )\n\n return dataloader\n\n def get_as_torch_dataset(\n self,\n model_id: str,\n num_samples: int = 100,\n install_dependencies: bool = False,\n transform=None,\n **kwargs,\n ) -> Dataset:\n \"\"\"Get synthetic data in a torch Dataset for specified medigan model.\n\n The dataset returns a dict with keys sample (== image), labels (== condition), and mask (== segmentation mask).\n While key 'sample' is mandatory, the other key value pairs are only returned if applicable to generative model.\n\n Args:\n model_id: str\n The generative model's unique id\n num_samples: int\n the number of samples that will be generated\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n transform\n the torch data transformation functions to be applied to the data in the dataset.\n **kwargs\n arbitrary number of keyword arguments passed to the model's sample generation function (e.g. the input path for image-to-image translation models in medigan).\n\n Returns\n -------\n Dataset\n a torch.utils.data.Dataset object with data generated by model corresponding to `model_id`.\n \"\"\"\n\n data = self.generate(\n model_id=model_id,\n num_samples=num_samples,\n is_gen_function_returned=False,\n install_dependencies=install_dependencies,\n save_images=False, # design decision: temporary storage in memory instead of I/O from disk\n **kwargs,\n )\n\n logging.debug(f\"data: {data}\")\n\n (\n samples,\n masks,\n other_imaging_output,\n labels,\n ) = Utils.split_images_masks_and_labels(data=data, num_samples=num_samples)\n logging.debug(\n f\"samples: {samples} \\n masks: {masks} \\n other_imaging_output: {other_imaging_output} \\n labels: {labels}\"\n )\n\n return SyntheticDataset(\n samples=samples,\n masks=masks,\n other_imaging_output=other_imaging_output,\n labels=labels,\n transform=transform,\n )\n\n def visualize(\n self,\n model_id: str,\n slider_grouper: int = 10,\n auto_close: bool = False,\n install_dependencies: bool = False,\n ) -> None:\n \"\"\"Initialize and run `ModelVisualizer` of this model_id if it is available.\n It allows to visualize a sample from the model's output.\n UI window will pop up allowing the user to control the generation parameters (conditional and unconditional ones).\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id to visualize.\n slider_grouper: int\n Number of input parameters to group together within one slider.\n auto_close: bool\n Flag for closing the user interface automatically after time. Used while testing.\n install_dependencies: bool\n flag indicating whether a generative model's dependencies are automatically installed. Else error is raised if missing dependencies are detected.\n\n \"\"\"\n\n model_id = self.config_manager.match_model_id(provided_model_id=model_id)\n\n config = self.get_config_by_id(model_id=model_id)\n model_executor = self.get_model_executor(\n model_id=model_id, install_dependencies=install_dependencies\n )\n\n ModelVisualizer(model_executor=model_executor, config=config).visualize(\n slider_grouper=slider_grouper, auto_close=auto_close\n )\n\n def __repr__(self):\n return (\n f\"Generators(model_ids={self.config_manager.model_ids}, model_executors={self.model_executors}, \"\n f\"model_selector: {self.model_selector})\"\n )\n\n def __len__(self):\n return len(self.model_executors)\n\n def __getitem__(self, idx: int):\n return self.model_executors[idx]\n" }, { "path": "src/medigan/model_visualizer.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" `ModelVisualizer` class providing visualizing corresponding model input and model output changes. \"\"\"\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom matplotlib.widgets import Button, Slider\n\n\nclass ModelVisualizer:\n \"\"\"`ModelVisualizer` class: Visualises synthetic data through a user interface. Depending on a model,\n it is possible to control the input latent vector values and conditional input.\n\n Parameters\n ----------\n model_executor: ModelExecutor\n The generative model's executor object\n config: dict\n The config dict containing the model metadata\n\n\n Attributes\n ----------\n model_executor: ModelExecutor\n The generative model's executor object\n input_latent_vector_size: int\n Size of the latent vector used as an input for generation\n conditional: bool\n Flag for models with conditional input\n condition: Union[int, float]\n Value of the conditinal input to the model\n max_input_value: float\n Absolute value used for setting latent values input range\n \"\"\"\n\n def __init__(self, model_executor, config: None):\n self.model_executor = model_executor\n self.model_id = self.model_executor.model_id\n self.config = config\n self.num_samples = 1\n self.max_input_value = 3\n self.conditional = False\n self.condition = None\n\n self.input_latent_vector_size = (\n self.model_executor.generate_method_input_latent_vector_size\n )\n if not self.input_latent_vector_size:\n raise ValueError(\n f\"{self.model_id}: Visualization of this model is not supported. Reason: This model does not use a random vector 'z' as input, which is needed for visualization. This is determined via the absence of the 'input_latent_vector_size' variable in this model's metadata in config/global.json.\"\n )\n\n self.gen_function = self.model_executor.generate(\n num_samples=1,\n save_images=False,\n is_gen_function_returned=True,\n )\n if \"condition\" in self.model_executor.generate_method_args[\"custom\"]:\n self.conditional = True\n self.condition = self.model_executor.generate_method_args[\"custom\"][\n \"condition\"\n ]\n\n def visualize(self, slider_grouper: int = 10, auto_close=False):\n \"\"\"\n Visualize the model's output. This method is called by the user.\n It opens up a user interface with available controls.\n\n Parameters\n ----------\n slider_grouper: int\n Number of input parameters to group together within one slider.\n auto_close: bool\n Flag for closing the user interface automatically after time. Used while testing.\n\n Returns\n -------\n None\n \"\"\"\n z = np.random.randn(\n self.num_samples, self.input_latent_vector_size, 1, 1\n ).astype(np.float32)\n\n mask = None\n\n if self.conditional:\n output = self.gen_function(condition=self.condition, input_latent_vector=z)\n else:\n output = self.gen_function(input_latent_vector=z)\n\n image, mask = self._unpack_output(output)\n\n images_to_show = 1\n if mask is not None:\n images_to_show += 1\n\n fig, ax = plt.subplots(ncols=images_to_show)\n\n if images_to_show == 1:\n ax.axis(\"off\")\n ax.set_title(\"Generated image\")\n display = ax.imshow(image, cmap=\"gray\", vmin=0, vmax=255)\n if images_to_show == 2:\n ax[0].axis(\"off\")\n ax[0].set_title(\"Generated image\")\n display = ax[0].imshow(image, cmap=\"gray\", vmin=0, vmax=255)\n ax[1].axis(\"off\")\n ax[1].set_title(\"Generated mask\")\n display_mask = ax[1].imshow(mask, cmap=\"gray\", vmin=0, vmax=255)\n\n fig.suptitle(\n \"Model \" + self.model_id,\n fontsize=15,\n # fontweight=\"bold\",\n )\n if self.config:\n plt.text(\n x=0.5,\n y=0.88,\n s=self.config[\"description\"][\"title\"],\n fontsize=8,\n ha=\"center\",\n transform=fig.transFigure,\n wrap=True,\n )\n # adjust the main plot to make room for the sliders\n plt.subplots_adjust(left=0.45, bottom=0.3, top=0.8)\n\n padding = 0.03\n sliders_x = 0.1\n sliders_y = 0.75\n sliders_width = 0.25\n sliders_height = 0.02\n sliders = []\n row_index = 0\n\n if self.conditional:\n condition_ax = plt.axes(\n (sliders_x, sliders_y, sliders_width, sliders_height)\n )\n condition_slider = Slider(\n condition_ax,\n None,\n 0,\n 1,\n valinit=0.0,\n valstep=1,\n initcolor=\"none\",\n # valfmt=\"%.2f\",\n )\n condition_ax.set_title(\"Input condition: \" + output[0][1])\n row_index += 5\n\n offset_ax = plt.axes(\n (sliders_x, sliders_y - row_index * padding, sliders_width, sliders_height)\n )\n offset_ax.set_title(\"Input latent vector\")\n offset_slider = Slider(\n offset_ax,\n \"offset\",\n -self.max_input_value * 2,\n self.max_input_value * 2,\n valinit=0.0,\n initcolor=\"none\",\n valfmt=\"%.2f\",\n )\n row_index += 2\n # for i in range(int(self.input_latent_vector_size)):\n for i in range(int(self.input_latent_vector_size / slider_grouper)):\n axfreq = plt.axes(\n (\n sliders_x,\n sliders_y - (i + row_index) * padding,\n sliders_width,\n sliders_height,\n )\n )\n slider = Slider(\n axfreq,\n \"z{}\".format(i + 1),\n -self.max_input_value,\n self.max_input_value,\n valinit=float(z[0][i]),\n initcolor=\"none\",\n valfmt=\"%.2f\",\n )\n sliders.append(slider)\n\n text = \"Offset: Add constant value to each latent variable \\\n \\nInput vector: Modify latent values used to generate image \\\n \\nSeed: Initialize new random seed for latent vector \\\n \\nReset: Revert user changes to initial seed values\"\n\n ax_legend = plt.axes(\n (\n 0.45,\n 0.19,\n 0.5,\n 0.5,\n )\n )\n ax_legend.axis(\"off\")\n\n ax_legend.text(0.0, 0.0, text, fontsize=8, va=\"top\", linespacing=2)\n\n # The function to be called anytime a slider's value changes\n def update(val):\n for i, slider in enumerate(sliders):\n for j in range(10):\n z[0][i + j] = slider.val\n\n if self.conditional:\n self.condition = condition_slider.val\n output = self.gen_function(\n condition=self.condition, input_latent_vector=z\n )\n condition_ax.set_title(\"Input condition: \" + output[0][1])\n else:\n output = self.gen_function(input_latent_vector=z)\n\n image, mask = self._unpack_output(output)\n if mask is not None:\n display_mask.set_data(mask)\n display.set_data(image)\n fig.canvas.draw_idle()\n\n # register the update function with each slider\n for slider in sliders:\n slider.on_changed(update)\n if self.conditional:\n condition_slider.on_changed(update)\n\n self.offset_old = 0\n\n def update_offset(val):\n diff = offset_slider.val - self.offset_old\n self.offset_old = offset_slider.val\n\n for i, slider in enumerate(sliders):\n if slider.val + diff > self.max_input_value:\n slider.set_val(self.max_input_value)\n elif slider.val + diff < -self.max_input_value:\n slider.set_val(-self.max_input_value)\n else:\n slider.set_val(slider.val + diff)\n\n for j in range(10):\n z[0][i + j] = slider.val\n\n offset_slider.on_changed(update_offset)\n\n # Create a `matplotlib.widgets.Button` to reset the sliders to initial values.\n resetax = plt.axes([0.77, 0.220, 0.1, 0.04])\n reset_button = Button(resetax, \"Reset\", hovercolor=\"0.975\")\n seedax = plt.axes([0.62, 0.220, 0.1, 0.04])\n seed_button = Button(seedax, \"Seed\", hovercolor=\"0.975\")\n\n def reset(event):\n offset_slider.reset()\n for slider in sliders:\n slider.reset()\n\n def new_seed(event):\n z = np.random.randn(\n self.num_samples, self.input_latent_vector_size, 1, 1\n ).astype(np.float32)\n for slider in sliders:\n slider.valinit = z[0][sliders.index(slider)]\n reset(event)\n\n reset_button.on_clicked(reset)\n seed_button.on_clicked(new_seed)\n update(0)\n if auto_close:\n plt.show(block=False)\n plt.pause(1)\n plt.close()\n else:\n plt.show()\n\n def _unpack_output(self, output) -> tuple:\n \"\"\"\n Unpack the output of the generator function\n\n Parameters\n ----------\n output: Union[tuple, np.ndarray]\n Output of the generator function to unpack into an image and optional mask\n\n Returns\n ----------\n tuple[image, mask]\n Tuple of the image and mask. Mask is None if no mask was available\n \"\"\"\n mask = None\n if type(output[0]) is tuple:\n image = output[0][0].squeeze()\n if type(output[0][1]) is not str:\n mask = output[0][1].squeeze()\n else:\n image = output[0].squeeze()\n\n return image, mask\n" }, { "path": "src/medigan/select_model/__init__.py", "content": "" }, { "path": "src/medigan/select_model/matched_entry.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"MatchedEntry class that represents one match of a key value pair of a model's config against a search query. \"\"\"\n\n# Import python native libs\nfrom __future__ import absolute_import\n\nimport json\n\n\nclass MatchedEntry:\n \"\"\"`MatchedEntry` class: One target key-value pair that matches with a model's selection config.\n\n Parameters\n ----------\n key: str\n string that represents the matched key in model selection dict\n value\n represents the key's matched value in the model selection dict\n matching_element: str\n string that was used to match the search value\n\n Attributes\n ----------\n key: str\n string that represents the matched key in model selection dict\n value\n represents the key's matched value in the model selection dict\n matching_element: str\n string that was used to match the search value\n \"\"\"\n\n def __init__(\n self,\n key: str,\n value,\n matching_element: str = None,\n ):\n self.key = key\n self.value = value\n if matching_element is None:\n self.matching_element = str(value)\n else:\n self.matching_element = matching_element\n\n def __str__(self):\n return json.dumps(\n {\n \"key\": self.key,\n \"value\": self.value,\n \"matching_element\": self.matching_element,\n }\n )\n\n def __repr__(self):\n return f\"MatchedEntry(key={self.key}, value={self.value}, matching_element={self.matching_element})\"\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/select_model/model_match_candidate.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\"ModelMatchCandidate class that holds data to evaluate if a generative model matches against a search query. \"\"\"\n\n# Import python native libs\nfrom __future__ import absolute_import\n\nimport json\nimport logging\n\n# Import library internal modules\nfrom .matched_entry import MatchedEntry\n\n\nclass ModelMatchCandidate:\n \"\"\"`ModelMatchCandidate` class: A prospectively matching model given the target values as model search params.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n target_values: list\n list of target values used to evaluate if a `ModelMatchCandidate` instance is a match\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of `ModelMatchCandidate` instances.\n Should be either \"AND\", \"OR\", or \"XOR\".\n is_case_sensitive: bool\n flag indicating whether the matching of `values` (and) keys should be case-sensitive\n are_keys_also_matched: bool\n flag indicating whether, apart from `values`, keys should also be matched\n is_match: bool\n flag indicating whether the `ModelMatchCandidate` instance is a match\n\n Attributes\n ----------\n model_id: str\n The generative model's unique id\n target_values: list\n list of target values used to evaluate if a `ModelMatchCandidate` instance is a match\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of `ModelMatchCandidate` instances.\n Should be either \"AND\", \"OR\", or \"XOR\".\n is_case_sensitive: bool\n flag indicating whether the matching of `values` (and) keys should be case-sensitive\n are_keys_also_matched: bool\n flag indicating whether, apart from values, keys should also be matched\n matched_entries: list\n contains iteratively added `MatchedEntry` class instances. Each of the `MatchedEntry` instances indicates a match\n between one of the user specified values in `self.target_values` and the selection config keys or `values` of the\n model of this `ModelMatchCandidate`.\n is_match: bool\n flag indicating whether the `ModelMatchCandidate` instance is a match\n \"\"\"\n\n def __init__(\n self,\n model_id: str,\n target_values: list,\n target_values_operator: str = \"AND\",\n is_case_sensitive: bool = False,\n are_keys_also_matched: bool = False,\n is_match: bool = False,\n ):\n # Descriptive variables\n self.model_id = model_id\n self.target_values = target_values\n self.target_values_operator = target_values_operator\n self.is_case_sensitive = is_case_sensitive\n self.are_keys_also_matched = are_keys_also_matched\n\n # Dynamically filled/changed variables\n self.matched_entries = []\n self.is_match = is_match\n\n def add_matched_entry(self, matched_entry: MatchedEntry) -> None:\n \"\"\"Add a `MatchedEntry` instance to the `matched_entries` list.\"\"\"\n self.matched_entries.append(matched_entry)\n\n def get_all_matching_elements(self) -> list:\n \"\"\"Get the matching element from each of the `MatchedEntry` instances in the `matched_entries` list.\n\n Returns\n -------\n list\n list of all matching elements (i.e. string that matched a search value) from each `MatchedEntry` in\n `matched_entries`\n \"\"\"\n\n matching_elements = []\n for matched_entry in self.matched_entries:\n matching_elements.append(matched_entry.matching_element)\n return matching_elements\n\n def check_if_is_match(self) -> bool:\n \"\"\"Evaluates whether the model represented by this instance is a match given search values and operator.\n\n The matching element from each `MatchEntry` of this instance ('self.matched_entries') are retrieved. To be a\n match, this instance ('self') needs to fulfill the requirement of the operator, which can be of value 'AND',\n or 'OR', or 'XOR'. For example, the default 'AND' requires that each search value ('self.target_values') has at\n least one corresponding `MatchEntry`, while in 'OR' only one of the search values needs to have been matched by a\n corresponding `MatchedEntry`.\n\n Returns\n -------\n bool\n flag that, only if True, indicates that this instance is a match given the search values and operator.\n \"\"\"\n\n if self is not None and len(self) > 0:\n if self.target_values_operator == \"OR\":\n self.is_match = True\n elif self.target_values_operator == \"AND\":\n # removing duplicates via set conversion\n found_target_values = set(self.get_all_matching_elements())\n if all(elem in found_target_values for elem in self.target_values):\n logging.debug(\n f\"values: {self.target_values} AND found_target_values_list: {found_target_values}\"\n )\n self.is_match = True\n elif self.target_values_operator == \"XOR\":\n # removing duplicates via set conversion\n if (\n len(\n list(\n set(self.get_all_matching_elements()).intersection(\n self.target_values\n )\n )\n )\n == 1\n ):\n self.is_match = True\n logging.debug(f\"This ModelMatchCandidate was found to be a match: ({self}).\")\n return self.is_match\n\n def __str__(self):\n matched_entry_dicts = {\n f\"{idx}\": json.loads(str(match))\n for idx, match in enumerate(self.matched_entries)\n }\n return json.dumps(\n {\n \"model_id\": self.model_id,\n \"is_match\": self.is_match,\n \"target_values\": self.target_values,\n \"operator\": self.target_values_operator,\n \"are_keys_also_matched\": self.are_keys_also_matched,\n \"is_case_sensitive\": self.is_case_sensitive,\n \"matched_entries\": matched_entry_dicts,\n }\n )\n\n def __repr__(self):\n return f\"ModelMatchCandidate(model_id={self.model_id}, is_match={self.is_match}, operator: {self.target_values_operator}, target_values={self.target_values})\"\n\n def __len__(self):\n return len(self.matched_entries)\n\n def __getitem__(self, idx: int):\n return self.matched_entries[idx]\n" }, { "path": "src/medigan/select_model/model_selector.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" Model selection class that describes, finds, compares, and ranks generative models. \"\"\"\n\n# Import python native libs\nfrom __future__ import absolute_import\n\nimport logging\n\n# Import library internal modules\nfrom ..config_manager import ConfigManager\nfrom ..constants import CONFIG_FILE_KEY_PERFORMANCE, CONFIG_FILE_KEY_SELECTION, MODEL_ID\nfrom ..utils import Utils\nfrom .matched_entry import MatchedEntry\nfrom .model_match_candidate import ModelMatchCandidate\n\n\nclass ModelSelector:\n \"\"\"`ModelSelector` class: Given a config dict, gets, searches, and ranks matching models.\n\n Parameters\n ----------\n config_manager: ConfigManager\n Provides the config dictionary, based on which models are selected and compared.\n\n Attributes\n ----------\n config_manager: ConfigManager\n Provides the config dictionary, based on which models are selected and compared.\n model_selection_dicts: list\n Contains a dictionary for each model id that consists of the `model_id` and the selection config of that model\n \"\"\"\n\n def __init__(\n self,\n config_manager: ConfigManager = None,\n ):\n if config_manager is None:\n self.config_manager = ConfigManager()\n logging.debug(f\"Initialized ConfigManager instance: {self.config_manager}\")\n else:\n self.config_manager = config_manager\n self.model_selection_dicts = []\n self._init_model_selector_data()\n\n def _init_model_selector_data(self):\n \"\"\"Initialize class data structure: List of dicts containing two keys each: `model_id` and `selection`.\"\"\"\n for model_id in self.config_manager.model_ids:\n selection_config = self.config_manager.get_config_by_id(\n model_id=model_id, config_key=CONFIG_FILE_KEY_SELECTION\n )\n model_selector_dict = {\n MODEL_ID: model_id,\n CONFIG_FILE_KEY_SELECTION: selection_config,\n }\n self.model_selection_dicts.append(model_selector_dict)\n logging.debug(\n f\"These were the available model selection dicts that were added to the ModelSelector: \"\n f\"{self.model_selection_dicts}.\"\n )\n\n def get_selection_criteria_by_id(\n self, model_id: str, is_model_id_removed: bool = True\n ) -> dict:\n \"\"\"Get and return the selection config dict for a specific `model_id`.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n is_model_id_removed: bool\n flag to to remove the `model_id` from first level of each dictionary.\n\n Returns\n -------\n dict\n a dictionary corresponding to the selection config of a model\n \"\"\"\n for idx, selection_dict in enumerate(self.model_selection_dicts):\n if selection_dict[MODEL_ID] == model_id:\n if is_model_id_removed:\n logging.debug(\n f\"For model {model_id}, the following selection dicts was found:\"\n f\" {selection_dict[CONFIG_FILE_KEY_SELECTION]}.\"\n )\n return selection_dict[CONFIG_FILE_KEY_SELECTION]\n else:\n logging.debug(\n f\"For model {model_id}, the following selection dicts was found:\"\n f\" {selection_dict}.\"\n )\n return selection_dict\n return None\n\n def get_selection_criteria_by_ids(\n self, model_ids: list = None, are_model_ids_removed: bool = True\n ) -> list:\n \"\"\"Get and return a list of selection config dicts for each of the specified `model_ids`.\n\n Parameters\n ----------\n model_ids: list\n A list of generative models' unique ids\n are_model_ids_removed: bool\n flag to remove the `model_ids` from first level of dictionary.\n\n Returns\n -------\n list\n a list of dictionaries each corresponding to the selection config of a model\n \"\"\"\n # Create list of models that contain a value for the metric of interest\n selection_dict_list = []\n for idx, selection_dict in enumerate(self.model_selection_dicts):\n if model_ids is None or selection_dict[MODEL_ID] in model_ids:\n # if model_ids is None, we consider all models\n if are_model_ids_removed:\n selection_dict_list.append(\n selection_dict[CONFIG_FILE_KEY_SELECTION]\n )\n else:\n selection_dict_list.append(selection_dict)\n logging.debug(\n f\"The following selection dicts were found: {selection_dict_list}.\"\n )\n return selection_dict_list\n\n def get_selection_keys(self, model_id: str = None) -> list:\n \"\"\"Get and return all first level keys from the selection config dict for a specific `model_id`.\n\n Parameters\n ----------\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n list\n a list containing the keys as strings of the selection config of the `model_id`.\n \"\"\"\n\n key_list = []\n if model_id is not None:\n selection_config = self.get_selection_criteria_by_id(model_id)\n for key in selection_config:\n key_list.append(key)\n else:\n for selection_dict in self.model_selection_dicts:\n selection_config = selection_dict[CONFIG_FILE_KEY_SELECTION]\n for key in selection_config:\n if key not in key_list:\n key_list.append(key)\n logging.debug(\n f\"For model {model_id}, the following selection keys were in its selection config: {key_list}.\"\n )\n return key_list\n\n def get_selection_values_for_key(self, key: str, model_id: str = None) -> list:\n \"\"\"Get and return the value of a specified key of the selection dict in the config for a specific `model_id`.\n\n The key param can contain '.' (dot) separations to allow for retrieval of nested config keys such as\n 'execution.generator.name'\n\n Parameters\n ----------\n key: str\n The key in the selection dict\n model_id: str\n The generative model's unique id\n\n Returns\n -------\n list\n a list of the values that correspond to the key in the selection config of the `model_id`.\n \"\"\"\n\n values_for_key = []\n if model_id is not None:\n selection_config = self.get_selection_criteria_by_id(model_id)\n values_for_key.append(selection_config[key])\n else:\n for selection_dict in self.model_selection_dicts:\n selection_config = selection_dict[CONFIG_FILE_KEY_SELECTION]\n # if applicable, split key by \".\" and get value in nested dict in selection_config\n selection_config = Utils.deep_get(base_dict=selection_config, key=key)\n values_for_key.append(selection_config)\n logging.debug(\n f\"For key {key}, the following values were found across the models' selection \"\n f\"dicts {values_for_key}.\"\n )\n return values_for_key\n\n def get_models_by_key_value_pair(\n self, key1: str, value1: str, is_case_sensitive: bool = False\n ) -> list:\n \"\"\"Get and return a list of `model_id` dicts that contain the specified key value pair in their selection config.\n\n The key param can contain '.' (dot) separations to allow for retrieval of nested config keys such as\n 'execution.generator.name'. If `key1` points to a list, any value in the list that matches value1` is accepted.\n\n Parameters\n ----------\n key1: str`\n The key in the selection dict\n value1: str\n The value in the selection dict that corresponds to key1\n is_case_sensitive: bool\n flag to evaluate keys and values with case sensitivity if set to True\n\n Returns\n -------\n list\n a list of the dictionaries each containing a model's `model_id` and the found key-value pair in the models config\n \"\"\"\n\n model_dict_list = []\n for selection_dict in self.model_selection_dicts:\n is_model_match: bool = False\n # Now, for each model, we want to get the respective value for the key\n try:\n key_value = selection_dict[CONFIG_FILE_KEY_SELECTION]\n key_value = Utils.deep_get(base_dict=key_value, key=key1)\n if key_value is not None:\n # If key value is None, the model is not added to the model\n if isinstance(key_value, dict):\n # If the value of the key is a dict, we cannot evaluate a dict and continue the loop.\n continue\n if isinstance(key_value, list):\n # If the value of the key is a list, we check if the provided value1 is in that list.\n # Convert list of arbitrary type to list of strings\n key_value = list(map(str, key_value))\n if not is_case_sensitive:\n key_value = Utils.list_to_lowercase(key_value)\n value1 = value1.lower()\n if str(value1) in key_value:\n is_model_match = True\n else:\n # If the value of the key is something else (str, float, int, etc), we check if equal to value1\n if (str(key_value) == str(value1)) or (\n not is_case_sensitive\n and str(key_value).lower() == str(value1).lower()\n ):\n is_model_match = True\n except KeyError as e:\n logging.debug(\n f\"Model {selection_dict[MODEL_ID]} was discarded as it does not have the specified keys \"\n f\"in its selection dict: {selection_dict}\"\n )\n pass\n if is_model_match:\n model_id = selection_dict[MODEL_ID]\n model_dict = {MODEL_ID: model_id, key1: value1}\n logging.debug(\n f\"Model {model_id} was a match for the specified key value pair: {model_dict}\"\n )\n model_dict_list.append(model_dict)\n return model_dict_list\n\n def rank_models_by_performance(\n self, model_ids: list = None, metric: str = \"SSIM\", order: str = \"asc\"\n ) -> list:\n \"\"\"Rank model based on a provided metric and return sorted list of model dicts.\n\n The metric param can contain '.' (dot) separations to allow for retrieval via nested metric config keys such as\n 'downstream_task.CLF.accuracy'. If the value found for the metric key is of type list, then the largest value in\n the list is used for ranking if `order` is descending, while the smallest value is used if `order` is ascending.\n\n Parameters\n ----------\n model_ids: list\n only evaluate the model_ids in this list. If none, evaluate all available `model_ids`\n metric: str\n The key in the selection dict that corresponds to the metric of interest\n order: str\n the sorting order of the ranked results. Should be either \"asc\" (ascending) or \"desc\" (descending)\n\n Returns\n -------\n list\n a list of model dictionaries containing metric and `model_id`, sorted by `metric`.\n \"\"\"\n\n model_metric_dict_list = []\n if model_ids is not None and len(model_ids) == 0:\n # empty model_ids list -> return empty list.\n return model_metric_dict_list\n # First, get all selection criteria for the model_ids\n selection_dict_list = self.get_selection_criteria_by_ids(\n model_ids=model_ids, are_model_ids_removed=False\n )\n for selection_dict in selection_dict_list:\n # Now, for each model, we want to get the respective value for the metric\n try:\n # Maybe remove the case-sensitivity for metric here.\n metric_value = selection_dict[CONFIG_FILE_KEY_SELECTION][\n CONFIG_FILE_KEY_PERFORMANCE\n ]\n metric_value = Utils.deep_get(base_dict=metric_value, key=metric)\n if metric_value is not None:\n # If metric value is None, the model is not added to the model_metric_dict_list\n # TODO Maybe add further validation of metric_value here, e.g. string to float conversion, etc.\n if isinstance(metric_value, list) and order == \"asc\":\n # Assumption: As order is ascending (smallest item at top of list), we want to get the\n # smallest (=best) possible value from our metric_value list.\n metric_value = min(metric_value)\n elif isinstance(metric_value, list):\n # Assumption: As order is descending (largest item at top of list), we want to get the\n # largest (=best) possible value from our metric_value list.\n metric_value = max(metric_value)\n model_id = selection_dict[MODEL_ID]\n model_metric_dict = {MODEL_ID: model_id, metric: metric_value}\n logging.debug(\n f\"Model {model_id} was a match for the specified metric value: {model_metric_dict}\"\n )\n model_metric_dict_list.append(model_metric_dict)\n except KeyError as e:\n logging.debug(\n f\"Model {selection_dict[MODEL_ID]} was discarded as it does not have the specified keys \"\n f\"in its selection dict: {selection_dict}\"\n )\n pass\n if order == \"asc\":\n # ascending -> the smallest item appears at the top of the list\n model_metric_dict_list.sort(key=lambda x: x.get(metric))\n else:\n # descending -> the largest item appears at the top of the list\n model_metric_dict_list.sort(key=lambda x: x.get(metric), reverse=True)\n return model_metric_dict_list\n\n def find_models_and_rank(\n self,\n values: list,\n target_values_operator: str = \"AND\",\n are_keys_also_matched: bool = False,\n is_case_sensitive: bool = False,\n metric: str = \"SSIM\",\n order: str = \"asc\",\n ) -> list:\n \"\"\"Search for values (and keys) in model configs, rank results and return sorted list of model dicts.\n\n Parameters\n ----------\n values: list\n list of values used to search and find models corresponding to these `values`\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of model search results.\n Should be either \"AND\", \"OR\", or \"XOR\".\n are_keys_also_matched: bool\n flag indicating whether, apart from `values`, the keys in the model config should also be searchable\n is_case_sensitive: bool\n flag indicating whether the search for values (and) keys in the model config should be case-sensitive.\n metric: str\n The key in the selection dict that corresponds to the `metric` of interest\n order: str\n the sorting order of the ranked results. Should be either \"asc\" (ascending) or \"desc\" (descending)\n\n Returns\n -------\n list\n a list of the searched and matched model dictionaries containing `metric` and `model_id`, sorted by `metric`.\n \"\"\"\n\n matching_models = self.find_matching_models_by_values(\n values=values,\n target_values_operator=target_values_operator,\n are_keys_also_matched=are_keys_also_matched,\n is_case_sensitive=is_case_sensitive,\n )\n matching_model_ids = [model.model_id for model in matching_models]\n logging.debug(f\"matching_model_ids: {matching_model_ids}\")\n return self.rank_models_by_performance(\n model_ids=matching_model_ids, metric=metric, order=order\n )\n\n def find_matching_models_by_values(\n self,\n values: list,\n target_values_operator: str = \"AND\",\n are_keys_also_matched: bool = False,\n is_case_sensitive: bool = False,\n ) -> list:\n \"\"\"Search for values (and keys) in model configs and return a list of each matching `ModelMatchCandidate`.\n\n Uses `self.recursive_search_for_values` to recursively populate each `ModelMatchCandidate` with `MatchedEntry`\n instances. After populating, each `ModelMatchCandidate` is evaluated based on the provided\n `target_values_operator` and `values` list using `ModelMatchCandidate.check_if_is_match`.\n\n Parameters\n ----------\n values: list\n list of values used to search and find models corresponding to these values\n target_values_operator: str\n the operator indicating the relationship between `values` in the evaluation of model search results.\n Should be either \"AND\", \"OR\", or \"XOR\".\n are_keys_also_matched: bool\n flag indicating whether, apart from values, the keys in the model config should also be searchable\n is_case_sensitive: bool\n flag indicating whether the search for values (and) keys in the model config should be case-sensitive.\n\n Returns\n -------\n list\n a list of `ModelMatchCandidate` class instances each of which was successfully matched against the search\n values.\n \"\"\"\n\n assert (\n values is not None and len(values) > 0\n ), f\"Please specify a list of values to search for. You specified: {values}.\"\n matching_models = []\n if not is_case_sensitive:\n # Removing case-sensitivity search requirement by replacing with lowercase values list\n values = Utils.list_to_lowercase(target_list=values)\n logging.debug(f\"Processed search values: {values}\")\n for selection_dict in self.model_selection_dicts:\n selection_config = selection_dict[CONFIG_FILE_KEY_SELECTION]\n model_match_candidate = ModelMatchCandidate(\n model_id=selection_dict[MODEL_ID],\n target_values_operator=target_values_operator,\n is_case_sensitive=is_case_sensitive,\n target_values=values,\n are_keys_also_matched=are_keys_also_matched,\n )\n model_match_candidate = self.recursive_search_for_values(\n search_dict=selection_config,\n model_match_candidate=model_match_candidate,\n )\n if model_match_candidate.check_if_is_match():\n logging.debug(\n f\"Found a matching ModelMatchCandidate: {model_match_candidate}\"\n )\n matching_models.append(model_match_candidate)\n return matching_models\n\n def recursive_search_for_values(\n self, search_dict: dict, model_match_candidate: ModelMatchCandidate\n ):\n \"\"\"Do a recursive search to match values in the `search_dict` with values (and keys) in a model's config.\n\n The provided `ModelMatchCandidate` instance is recursively populated with `MatchedEntry` instances. A\n `MatchedEntry` instance contains a key-value pair found in the model's config that matches with one search\n term of interest.\n\n The search terms of interest are stored in `ModelMatchCandidate.target_values`. The model's selection config\n is provided in the 'search_dict'.\n\n To traverse the `search_dict`, the value for each key in the `search_dict` is retrieved.\n\n - If that value is of type dictionary, the function calls itself with that nested dictionary as new `search_dict`.\n\n - If that value is of type list, each value in the list is compared with each search term of interest in `ModelMatchCandidate.target_values`.\n\n - If the value of the `search_dict` is of another type (i.e. str), it is compared with each search term of interest in `ModelMatchCandidate.target_values`.\n\n Parameters\n ----------\n search_dict: dict\n contains keys and values from a model's config that are matched against a set of search values.\n model_match_candidate: ModelMatchCandidate\n a class instance representing a model to be prepared for evaluation (populated with `MatchedEntry` objects),\n as to whether it is a match given its search values (`self.target_values`).\n\n Returns\n -------\n list\n a `ModelMatchCandidate` class instance that has been populated with `MatchedEntry` class instances.\n \"\"\"\n\n if search_dict is not None:\n counter = 0\n for key in search_dict:\n if model_match_candidate.are_keys_also_matched and not isinstance(\n search_dict, list\n ):\n # Treating the key as a match due to a matching string in target_values.\n if (\n not model_match_candidate.is_case_sensitive\n and key.lower() in model_match_candidate.target_values\n ):\n matched_entry = MatchedEntry(\n key=\"key\", value=key, matching_element=key.lower()\n )\n model_match_candidate.add_matched_entry(\n matched_entry=matched_entry\n )\n elif key in model_match_candidate.target_values:\n matched_entry = MatchedEntry(\n key=\"key\", value=key, matching_element=key\n )\n model_match_candidate.add_matched_entry(\n matched_entry=matched_entry\n )\n if isinstance(search_dict, list):\n # if we have a list we want the counter to get index position in list\n key_or_counter = counter\n else:\n # if we have something else i.e. a dict, we want to get the key to get nested dict\n key_or_counter = key\n if isinstance(search_dict[key_or_counter], dict):\n # The value of the key is of type dict, we thus search recursively inside that dictionary\n model_match_candidate = self.recursive_search_for_values(\n search_dict=search_dict[key_or_counter],\n model_match_candidate=model_match_candidate,\n )\n elif isinstance(search_dict[key_or_counter], list):\n for item in search_dict[key_or_counter]:\n if not model_match_candidate.is_case_sensitive:\n item = str(item).lower()\n if str(item) in model_match_candidate.target_values:\n matched_entry = MatchedEntry(\n key=key, value=item, matching_element=str(item)\n )\n model_match_candidate.add_matched_entry(\n matched_entry=matched_entry\n )\n else:\n item = search_dict[key_or_counter]\n if not model_match_candidate.is_case_sensitive:\n item = str(item).lower()\n if str(item) in model_match_candidate.target_values:\n matched_entry = MatchedEntry(\n key=key, value=item, matching_element=str(item)\n )\n model_match_candidate.add_matched_entry(\n matched_entry=matched_entry\n )\n counter += counter\n return model_match_candidate\n\n def __repr__(self):\n return f\"ModelSelector(model_ids={self.config_manager.model_ids})\"\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "src/medigan/utils.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" `Utils` class providing generalized reusable functions for I/O, parsing, sorting, type conversions, etc. \"\"\"\n# Import python native libs\nimport json\nimport logging\nimport os\nimport shutil\nimport time\nimport zipfile\nfrom distutils.dir_util import copy_tree\nfrom pathlib import Path\nfrom urllib.parse import urlparse # python3\n\nimport numpy as np\n\n# Import pypi libs\nimport requests\nfrom tqdm import tqdm\n\n\nclass Utils:\n \"\"\"Utils class containing reusable static methods.\"\"\"\n\n def __init__(\n self,\n ):\n pass\n\n @staticmethod\n def mkdirs(path_as_string: str) -> bool:\n \"\"\"create folder in `path_as_string` if not already created.\"\"\"\n\n if not os.path.exists(path_as_string):\n try:\n os.makedirs(path_as_string)\n return True\n except Exception as e:\n logging.error(\n f\"Error while creating folders for path {path_as_string}: {e}\"\n )\n return False\n return True\n\n @staticmethod\n def is_file_located_or_downloaded(\n path_as_string: str,\n download_if_not_found: bool = True,\n download_link: str = None,\n is_new_download_forced: bool = False,\n allow_local_path_as_url: bool = True,\n ) -> bool:\n \"\"\"check if is file in `path_as_string` and optionally download the file (again).\"\"\"\n\n if not path_as_string.is_file() or is_new_download_forced:\n if not download_if_not_found:\n # download_if_not_found is prioritized over is_new_download_forced in this case, as users likely\n # prefer to avoid automated downloads altogether when setting download_if_not_found to False.\n logging.warning(\n f\"File {path_as_string} was not found ({not path_as_string.is_file()}) or download \"\n f\"was forced ({is_new_download_forced}). However, downloading it from {download_link} \"\n f\"was not allowed: download_if_not_found == {download_if_not_found}. This may cause an \"\n f\"error, as the file might be outdated or missing, while being used in subsequent \"\n f\"workflows.\"\n )\n return False\n else:\n try:\n if allow_local_path_as_url and not Utils.is_url_valid(\n the_url=download_link\n ):\n Utils.copy(\n source_path=download_link,\n target_path=os.path.split(path_as_string)[0],\n )\n else:\n Utils.download_file(\n path_as_string=path_as_string, download_link=download_link\n )\n except Exception as e:\n raise e\n return True\n\n @staticmethod\n def download_file(\n download_link: str, path_as_string: str, file_extension: str = \".json\"\n ):\n \"\"\"download a file using the `requests` lib and store in `path_as_string`\"\"\"\n\n logging.debug(f\"Now downloading file {path_as_string} from {download_link} ...\")\n try:\n for i in range(10):\n response = requests.get(\n download_link, allow_redirects=True, stream=True\n )\n total_size_in_bytes = int(\n response.headers.get(\"content-length\", 0)\n ) # / (32 * 1024) # 32*1024 bytes received by requests.\n logging.debug(total_size_in_bytes)\n block_size = 1024\n progress_bar = tqdm(\n total=total_size_in_bytes,\n unit=\"B\",\n unit_scale=True,\n position=0,\n leave=True,\n ascii=True,\n )\n progress_bar.set_description(f\"Downloading {download_link}\")\n with open(path_as_string, \"wb\") as file:\n for data in response.iter_content(block_size):\n progress_bar.update(len(data))\n file.write(data)\n logging.debug(\n f\"Received response {response}: Retrieved file from {download_link} and wrote it \"\n f\"to {path_as_string}.\"\n )\n try:\n if not (\n download_link.endswith(file_extension)\n and Path(path_as_string).is_file()\n and str(path_as_string).endswith(file_extension)\n ):\n # If we do not download a json file (global.json), we assume a zip and want to check if the downloaded zip is valid.\n zipfile.ZipFile(path_as_string, \"r\")\n break\n except Exception as e:\n print(e)\n logging.debug(\n f\"Download failed. Retrying download from {download_link}\"\n )\n\n except Exception as e:\n logging.error(\n f\"Error while trying to download/copy from {download_link} to {path_as_string}:{e}\"\n )\n raise e\n\n @staticmethod\n def read_in_json(path_as_string) -> dict:\n \"\"\"read a .json file and return as dict\"\"\"\n\n try:\n with open(path_as_string) as f:\n json_file = json.load(f)\n return json_file\n except Exception as e:\n logging.error(\n f\"Error while reading in json file from {path_as_string}: {e}\"\n )\n raise e\n\n @staticmethod\n def unzip_archive(source_path: Path, target_path: str = \"./\"):\n \"\"\"unzip a .zip archive in the `target_path`\"\"\"\n\n try:\n with zipfile.ZipFile(source_path, \"r\") as zip_ref:\n zip_ref.extractall(target_path)\n except Exception as e:\n logging.error(f\"Error while unzipping {source_path}: {e}\")\n raise e\n\n @staticmethod\n def unzip_and_return_unzipped_path(package_path: str):\n \"\"\"if not already dir, unzip an archive with `Utils.unzip_archive`. Return path to unzipped dir/file\"\"\"\n\n if Path(package_path).is_file() and package_path.endswith(\".zip\"):\n # Get the source_path without .zip extension to unzip.\n package_path_unzipped = package_path[0:-4]\n # We have a zip. Let's unzip and do the same operation (with new path)\n Utils.unzip_archive(\n source_path=package_path, target_path_as_string=package_path_unzipped\n )\n return package_path_unzipped\n elif Path(package_path).is_dir():\n logging.info(\n f\"Your package path ({package_path}) does already point to a directory. It was not unzipped.\"\n )\n return package_path\n else:\n raise Exception(\n f\"Your package path ({package_path}) does not point to a zip file nor directory. Please adjust and try again.\"\n )\n\n @staticmethod\n def copy(source_path: Path, target_path: str = \"./\"):\n \"\"\"copy a folder or file from `source_path` to `target_path`\"\"\"\n\n try:\n if Path(source_path).is_file():\n shutil.copy2(src=source_path, dst=target_path)\n else:\n copy_tree(src=source_path, dst=target_path)\n except Exception as e:\n logging.error(f\"Error while copying {source_path} to {target_path}: {e}\")\n raise e\n\n @staticmethod\n def dict_to_lowercase(target_dict: dict, string_conversion: bool = True) -> dict:\n \"\"\"transform values and keys in dict to lowercase, optionally with string conversion of the values.\n\n Warning: Does not convert nested dicts in the `target_dict`, but rather removes them from return object.\n \"\"\"\n\n if string_conversion:\n # keys should always be strings per default. values might differ in type.\n return dict((k.lower(), str(v).lower()) for k, v in target_dict.items())\n else:\n return dict((k.lower(), v.lower()) for k, v in target_dict.items())\n\n @staticmethod\n def list_to_lowercase(target_list: list) -> list:\n \"\"\"string conversion and lower-casing of values in list.\n\n trade-off: String conversion for increased robustness > type failure detection\n \"\"\"\n\n return [str(x).lower() for x in target_list]\n\n @staticmethod\n def deep_get(base_dict: dict, key: str):\n \"\"\"Split the key by \".\" to get value in nested dictionary.\"\"\"\n try:\n key_split = key.split(\".\")\n for key_ in key_split:\n base_dict = base_dict[key_]\n return base_dict\n except TypeError as e:\n logging.debug(\n f\"No key ({key}) found in base_dict ({base_dict}) for this model. Fallback: Returning None.\"\n )\n return None\n\n @staticmethod\n def is_url_valid(the_url: str) -> bool:\n \"\"\"Checks if a url is valid using urllib.parse.urlparse\"\"\"\n\n try:\n result = urlparse(the_url)\n # testing if both result.scheme and result.netloc are non-empty strings (empty strings evaluate to False).\n return all([result.scheme, result.netloc])\n except Exception:\n return False\n\n @staticmethod\n def has_more_than_n_diff_pixel_values(img: np.ndarray, n: int = 4) -> bool:\n \"\"\"This function checks whether an image contains more than n different pixel values.\n\n This helps to differentiate between segmentation masks and actual images.\n \"\"\"\n\n import torch\n\n torch_img = torch.from_numpy(img)\n pixel_values_set = set(torch_img.flatten().tolist())\n if len(pixel_values_set) > n:\n return True\n else:\n return False\n\n @staticmethod\n def split_images_masks_and_labels(\n data: list, num_samples: int, max_nested_arrays: int = 2\n ) -> [list, list, list, list]:\n \"\"\"Separates the data (sample, mask, other_imaging_data, label) returned by a generative model\n\n This functions expects a list of tuples as input `data` and assumes that each\n tuple contains sample, mask, other_imaging_data, label at index positions [0], [1], [2], and [3] respectively.\n\n samples, masks, and imaging data are expected to be of type np.ndarray and labels of type \"str\".\n\n For example, this extendable function assumes that, in data, a mask follows the image that it\n corresponds to or vice versa.\n \"\"\"\n\n samples = []\n masks = []\n other_imaging_output = []\n labels = []\n # if data is smaller than the number of samples that should have been generated, then data likely contains a nested array.\n # We go a maximum of max_nested_arrays deep into the data.\n counter = 0\n while len(data) < num_samples and isinstance(data, list):\n data = data[0]\n counter = counter + 1\n if counter >= max_nested_arrays:\n break\n\n for data_point in data:\n logging.debug(f\"data_point: {data_point}\")\n if isinstance(data_point, tuple):\n for i, item in enumerate(data_point):\n if isinstance(item, np.ndarray) and i == 0:\n samples.append(item)\n elif isinstance(item, np.ndarray) and i == 1:\n masks.append(item)\n elif isinstance(item, np.ndarray) and i == 2:\n other_imaging_output.append(item)\n elif isinstance(item, str):\n labels.append(item)\n elif isinstance(data_point, np.ndarray):\n # An image is expected in the case no tuple is returned\n samples.append(data_point)\n masks = None if len(masks) == 0 else masks\n other_imaging_output = (\n None if len(other_imaging_output) == 0 else other_imaging_output\n )\n labels = None if len(labels) == 0 else labels\n return samples, masks, other_imaging_output, labels\n\n @staticmethod\n def split_images_and_masks_no_ordering(\n data: list, num_samples: int, max_nested_arrays: int = 2\n ) -> [np.ndarray, np.ndarray]:\n \"\"\"Extracts and separates the masks from the images if a model returns both in the same np.ndarray.\n\n This extendable function assumes that, in data, a mask follows the image that it corresponds to or vice versa.\n\n - This function is deprecated. Please use `split_images_masks_and_labels` instead.\n \"\"\"\n\n images = []\n masks = []\n # if data is smaller than the number of samples that should have been generated, then data likely contains a nested array.\n # We go a maximum of max_nested_arrays deep into the data.\n counter = 0\n while len(data) < num_samples:\n data = data[0]\n counter = counter + 1\n if counter >= max_nested_arrays:\n break\n\n for data_point in data:\n logging.debug(f\"data_point {data_point}\")\n if isinstance(data_point, tuple):\n for i, sample in enumerate(data_point):\n if (\n isinstance(i, np.ndarray)\n and \"int\" in str(i.dtype)\n and not Utils.has_more_than_n_diff_pixel_values(i)\n ):\n # Check if numpy array that contains integers instead of floats indicates the presence of a mask\n masks.append(i)\n elif Utils.has_more_than_n_diff_pixel_values(i):\n images.append(i)\n elif (\n isinstance(data_point, np.ndarray)\n and \"int\" in str(data_point.dtype)\n and not Utils.has_more_than_n_diff_pixel_values(data_point)\n ):\n masks.append(data_point)\n else:\n images.append(data_point)\n masks = None if len(masks) == 0 else masks\n return images, masks\n\n @staticmethod\n def order_dict_by_value(\n dict_list, key: str, order: str = \"asc\", sort_algorithm=\"bubbleSort\"\n ) -> list:\n \"\"\"Sorting a list of dicts by the values of a specific key in the dict using a sorting algorithm.\n\n - This function is deprecated. You may use Python List sort() with key=lambda function instead.\n\n \"\"\"\n\n if sort_algorithm == \"bubbleSort\":\n for i in range(len(dict_list)):\n for j in range(len(dict_list) - i - 1):\n if dict_list[j][key] > dict_list[j + 1][key]:\n # no need for a temp variable holder\n dict_list[j][key], dict_list[j + 1][key] = (\n dict_list[j + 1][key],\n dict_list[j][key],\n )\n return dict_list\n\n @staticmethod\n def is_file_in(folder_path: str, filename: str) -> bool:\n \"\"\"Checks if a file is inside a folder\"\"\"\n\n try:\n if (\n Path(folder_path).is_dir()\n and Path(f\"{folder_path}/{filename}\").is_file()\n ):\n return True\n except Exception as e:\n logging.warning(f\"File ({filename}) was not found in {folder_path}: {e}\")\n return False\n\n @staticmethod\n def store_dict_as(\n dictionary,\n extension: str = \".json\",\n output_path: str = \"config/\",\n filename: str = \"metadata.json\",\n ):\n \"\"\"store a Python dictionary in file system as variable filetype.\"\"\"\n\n if extension not in output_path:\n Utils.mkdirs(path_as_string=output_path)\n if extension not in filename:\n filename = filename + extension\n output_path = f\"{output_path}/{filename}\"\n json_object = json.dumps(dictionary, indent=4)\n with open(output_path, \"w\") as outfile:\n outfile.write(json_object)\n\n @staticmethod\n def call_without_removable_params(\n my_callable, removable_param_values: list = [None], **params\n ):\n \"\"\"call a callable without passing parameters that contain any of the removable_param_values as value.\"\"\"\n\n not_removed_params = params\n for removable_param_value in removable_param_values:\n if removable_param_value is None:\n not_removed_params = {\n k: v\n for k, v in not_removed_params.items()\n if v is not removable_param_value\n }\n else:\n not_removed_params = {\n k: v\n for k, v in not_removed_params.items()\n if v != removable_param_value\n }\n logging.debug(\n f\"call_without_removable_params final params: {not_removed_params}\"\n )\n return my_callable(**not_removed_params)\n\n def __len__(self):\n raise NotImplementedError\n\n def __getitem__(self, idx: int):\n raise NotImplementedError\n" }, { "path": "templates/examples/500.pt.txt", "content": "Download 500.pt file from: https://drive.google.com/file/d/1C9vVPymsKJ5i5gpwQM6cpX0y1G89vcpk/view?usp=sharing" }, { "path": "templates/examples/LICENSE", "content": "MIT License\n\nCopyright (c) 2021 Richard Osuala, Noussair Lazrak\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE." }, { "path": "templates/examples/__init__.py", "content": "\"\"\"\nauthors: Richard Osuala, Zuzanna Szafranowska\nBCN-AIM 2021\n\"\"\"\n\nimport logging\nimport os\nfrom pathlib import Path\n\nimport cv2\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.parallel\n\n\nclass BaseGenerator(nn.Module):\n def __init__(\n self,\n nz: int,\n ngf: int,\n nc: int,\n ngpu: int,\n leakiness: float = 0.2,\n bias: bool = False,\n ):\n super(BaseGenerator, self).__init__()\n self.nz = nz\n self.ngf = ngf\n self.nc = nc\n self.ngpu = ngpu\n self.leakiness = leakiness\n self.bias = bias\n self.main = None\n\n def forward(self, input):\n raise NotImplementedError\n\n\nclass Generator(BaseGenerator):\n def __init__(\n self,\n nz: int,\n ngf: int,\n nc: int,\n ngpu: int,\n image_size: int,\n conditional: bool,\n leakiness: float,\n bias: bool = False,\n n_cond: int = 10,\n is_condition_categorical: bool = False,\n num_embedding_dimensions: int = 50,\n ):\n super(Generator, self).__init__(\n nz=nz,\n ngf=ngf,\n nc=nc,\n ngpu=ngpu,\n leakiness=leakiness,\n bias=bias,\n )\n # if is_condition_categorical is False, we model the condition as continous input to the network\n self.is_condition_categorical = is_condition_categorical\n\n # n_cond is only used if is_condition_categorical is True.\n self.num_embedding_input = n_cond\n\n # num_embedding_dimensions is only used if is_condition_categorical is True.\n # num_embedding_dimensions standard would be dim(z), but atm we have a nn.Linear after\n # nn.Embedding that upscales the dimension to self.nz. Using same value of num_embedding_dims in D and G.\n self.num_embedding_dimensions = num_embedding_dimensions\n\n # whether the is a conditional input into the GAN i.e. cGAN\n self.conditional: bool = conditional\n\n # The image size (supported params should be 128 or 64)\n self.image_size = image_size\n\n if self.image_size == 128:\n self.first_layers = nn.Sequential(\n # input is Z, going into a convolution\n nn.ConvTranspose2d(\n self.nz * self.nc, self.ngf * 16, 4, 1, 0, bias=self.bias\n ),\n nn.BatchNorm2d(self.ngf * 16),\n nn.ReLU(True),\n # state size. (ngf*16) x 4 x 4\n nn.ConvTranspose2d(\n self.ngf * 16, self.ngf * 8, 4, 2, 1, bias=self.bias\n ),\n nn.BatchNorm2d(self.ngf * 8),\n nn.ReLU(True),\n )\n elif self.image_size == 64:\n self.first_layers = nn.Sequential(\n # input is Z, going into a convolution\n nn.ConvTranspose2d(\n self.nz * self.nc, self.ngf * 8, 4, 1, 0, bias=self.bias\n ),\n nn.BatchNorm2d(self.ngf * 8),\n nn.ReLU(True),\n )\n else:\n raise ValueError(\n f\"Allowed image sizes are 128 and 64. You provided {self.image_size}. Please adjust.\"\n )\n\n self.main = nn.Sequential(\n *self.first_layers.children(),\n # state size. (ngf*8) x 8 x 8\n nn.ConvTranspose2d(self.ngf * 8, self.ngf * 4, 4, 2, 1, bias=self.bias),\n nn.BatchNorm2d(self.ngf * 4),\n nn.ReLU(True),\n # state size. (ngf*4) x 16 x 16\n nn.ConvTranspose2d(self.ngf * 4, self.ngf * 2, 4, 2, 1, bias=self.bias),\n nn.BatchNorm2d(self.ngf * 2),\n nn.ReLU(True),\n # state size. (ngf*2) x 32 x 32\n nn.ConvTranspose2d(self.ngf * 2, self.ngf, 4, 2, 1, bias=self.bias),\n nn.BatchNorm2d(self.ngf),\n nn.ReLU(True),\n # state size. (ngf) x 64 x 64\n # Note that out_channels=1 instead of out_channels=self.nc.\n # This is due to conditional input channel of our grayscale images\n nn.ConvTranspose2d(\n in_channels=self.ngf,\n out_channels=1,\n kernel_size=4,\n stride=2,\n padding=1,\n bias=self.bias,\n ),\n nn.Tanh(),\n # state size. (nc) x 128 x 128\n )\n\n if self.is_condition_categorical:\n self.embed_nn = nn.Sequential(\n # e.g. condition -> int -> embedding -> fcl -> feature map -> concat with image -> conv layers..\n # embedding layer\n nn.Embedding(\n num_embeddings=self.num_embedding_input,\n embedding_dim=self.num_embedding_dimensions,\n ),\n # target output dim of dense layer is batch_size x self.nz x 1 x 1\n # input is dimension of the embedding layer output\n nn.Linear(\n in_features=self.num_embedding_dimensions, out_features=self.nz\n ),\n # nn.BatchNorm1d(self.nz),\n nn.LeakyReLU(self.leakiness, inplace=True),\n )\n else:\n self.embed_nn = nn.Sequential(\n # target output dim of dense layer is: nz x 1 x 1\n # input is dimension of the numbers of embedding\n nn.Linear(in_features=1, out_features=self.nz),\n # TODO Ablation: How does BatchNorm1d affect the conditional model performance?\n nn.BatchNorm1d(self.nz),\n nn.LeakyReLU(self.leakiness, inplace=True),\n )\n\n def forward(self, x, conditions=None):\n if self.conditional:\n # combining condition labels and input images via a new image channel\n if not self.is_condition_categorical:\n # If labels are continuous (not modelled as categorical), use floats instead of integers for labels.\n # Also adjust dimensions to (batch_size x 1) as needed for input into linear layer\n # labels should already be of type float, no change expected in .float() conversion (it is only a safety check)\n\n # Just for testing:\n conditions *= 0\n conditions += 1\n\n conditions = conditions.view(conditions.size(0), -1).float()\n embedded_conditions = self.embed_nn(conditions)\n embedded_conditions_with_random_noise_dim = embedded_conditions.view(\n -1, self.nz, 1, 1\n )\n x = torch.cat([x, embedded_conditions_with_random_noise_dim], 1)\n return self.main(x)\n\n\ndef interval_mapping(image, from_min, from_max, to_min, to_max):\n # map values from [from_min, from_max] to [to_min, to_max]\n # image: input array\n from_range = from_max - from_min\n to_range = to_max - to_min\n # scale to interval [0,1]\n scaled = np.array((image - from_min) / float(from_range), dtype=float)\n # multiply by range and add minimum to get interval [min,range+min]\n return to_min + (scaled * to_range)\n\n\ndef image_generator(model_path, device, nz, ngf, nc, ngpu, num_samples):\n # instantiate the model\n logging.debug(\"Instantiating model...\")\n netG = Generator(\n nz=nz,\n ngf=ngf,\n nc=nc,\n ngpu=ngpu,\n image_size=128,\n leakiness=0.1,\n conditional=False,\n )\n if device.type == \"cuda\":\n netG.cuda()\n\n # load the model's weights from state_dict *'.pt file\n logging.debug(f\"Loading model weights from {model_path} ...\")\n\n checkpoint = torch.load(model_path, map_location=device)\n try:\n netG.load_state_dict(state_dict=checkpoint[\"generator\"])\n except KeyError:\n raise KeyError(\n f\"checkpoint['generator_state_dict'] was not found.\"\n ) # checkpoint={checkpoint}\")\n logging.debug(f\"Using retrieved model from generator_state_dict checkpoint\")\n netG.eval()\n\n # generate the images\n logging.debug(f\"Generating {num_samples} images using {device}...\")\n z = torch.randn(num_samples, nz, 1, 1, device=device)\n images = netG(z).detach().cpu().numpy()\n image_list = []\n for j, img_ in enumerate(images):\n image_list.append(img_)\n return image_list\n\n\ndef save_generated_images(image_list, path):\n logging.debug(f\"Saving generated images now in {path}\")\n for i, img_ in enumerate(image_list):\n Path(path).mkdir(parents=True, exist_ok=True)\n img_path = f\"{path}/{i}.png\"\n img_ = interval_mapping(img_.transpose(1, 2, 0), -1.0, 0.0, 0, 255)\n img_ = img_.astype(\"uint8\")\n cv2.imwrite(img_path, img_)\n logging.debug(f\"Saved generated images to {path}\")\n\n\ndef return_images(image_list):\n # logging.debug(f\"Returning generated images as {type(image_list)}.\")\n processed_image_list = []\n for i, img_ in enumerate(image_list):\n img_ = interval_mapping(img_.transpose(1, 2, 0), -1.0, 0.0, 0, 255)\n img_ = img_.astype(\"uint8\")\n processed_image_list.append(img_)\n return processed_image_list\n\n\ndef generate(model_file, num_samples, output_path, save_images: bool):\n \"\"\"This function generates synthetic images of mammography regions of interest\"\"\"\n try:\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n ngpu = 0\n if device == \"cuda\":\n ngpu = 1\n image_list = image_generator(model_file, device, 100, 64, 1, ngpu, num_samples)\n if save_images:\n save_generated_images(image_list, output_path)\n else:\n return return_images(image_list)\n except Exception as e:\n logging.error(\n f\"Error while trying to generate {num_samples} images with model {model_file}: {e}\"\n )\n raise e\n" }, { "path": "templates/examples/metadata.json", "content": "{\n \"00005_DCGAN_MMG_MASS_ROI\": {\n \"execution\": {\n \"package_name\": \"MMG_MASS_BCDR_DCGAN\",\n \"package_link\": \"ADD_ZENODO_OR_LOCAL_URL_HERE\",\n \"model_name\": \"500\",\n \"extension\": \".pt\",\n \"image_size\": [\n 128,\n 128\n ],\n \"dependencies\": [\n \"numpy\",\n \"torch\",\n \"opencv-contrib-python-headless\"\n ],\n \"generate_method\": {\n \"name\": \"generate\",\n \"args\": {\n \"base\": [\n \"model_file\",\n \"num_samples\",\n \"output_path\",\n \"save_images\"\n ],\n \"custom\": {}\n }\n }\n },\n \"selection\": {\n \"performance\": {\n \"SSIM\": null,\n \"MSE\": null,\n \"NSME\": null,\n \"PSNR\": null,\n \"IS\": null,\n \"turing_test\": null,\n \"FID_no_images\":1000,\n \"FID\": 67.60,\n \"FID_ratio\": 0.497,\n \"FID_RADIMAGENET\": 1.27,\n \"FID_RADIMAGENET_ratio\": 0.197,\n \"CLF_delta\": null,\n \"SEG_delta\": null,\n \"CLF\": {\n \"trained_on_fake\": {\n \"accuracy\": 0.9528,\n \"f1\": 0.9721,\n \"AUROC\": 0.9596,\n \"AUPRC\": 0.9908\n },\n \"trained_on_real_and_fake\": {},\n \"trained_on_real\": {}\n },\n \"SEG\": {\n \"trained_on_fake\": {},\n \"trained_on_real_and_fake\": {},\n \"trained_on_real\": {}\n }\n },\n \"use_cases\": [\n \"classification\"\n ],\n \"organ\": [\n \"breast\",\n \"breasts\",\n \"chest\"\n ],\n \"modality\": [\n \"MMG\",\n \"Mammography\",\n \"Mammogram\",\n \"full-field digital\",\n \"full-field digital MMG\",\n \"full-field MMG\",\n \"full-field Mammography\",\n \"digital Mammography\",\n \"digital MMG\",\n \"x-ray mammography\"\n ],\n \"vendors\": [],\n \"centres\": [],\n \"function\": [\n \"noise to image\",\n \"image generation\",\n \"unconditional generation\",\n \"data augmentation\"\n ],\n \"condition\": [],\n \"dataset\": [\n \"BCDR\"\n ],\n \"augmentations\": [\n \"horizontal flip\",\n \"vertical flip\"\n ],\n \"generates\": [\n \"mass\",\n \"masses\",\n \"mass roi\",\n \"mass ROI\",\n \"mass images\",\n \"mass region of interest\",\n \"nodule\",\n \"nodule\",\n \"nodule roi\",\n \"nodule ROI\",\n \"nodule images\",\n \"nodule region of interest\"\n ],\n \"height\": 128,\n \"width\": 128,\n \"depth\": null,\n \"type\": \"DCGAN\",\n \"license\": \"MIT\",\n \"dataset_type\": \"public\",\n \"privacy_preservation\": null,\n \"tags\": [\n \"Mammogram\",\n \"Mammography\",\n \"Digital Mammography\",\n \"Full field Mammography\",\n \"Full-field Mammography\",\n \"128x128\",\n \"128 x 128\",\n \"MammoGANs\",\n \"Masses\",\n \"Nodules\"\n ],\n \"year\": \"2021\"\n },\n \"description\": {\n \"title\": \"DCGAN Model for Mammogram MASS Patch Generation (Trained on BCDR)\",\n \"provided_date\": \"15 Dec 2021\",\n \"trained_date\": \"Nov 2021\",\n \"provided_after_epoch\": 1500,\n \"version\": \"0.0.1\",\n \"publication\": null,\n \"doi\": [],\n \"comment\": \"A deep convolutional generative adversarial network (DCGAN) that generates mass patches of mammograms. Pixel dimensions are 128x128. The DCGAN was trained on MMG patches from the BCDR dataset (Lopez et al, 2012). The uploaded ZIP file contains the files 500.pt (model weight), __init__.py (image generation method and utils), a requirements.txt, and the GAN model architecture (in pytorch) below the /src folder.\"\n }\n }," }, { "path": "templates/examples/requirements.txt", "content": "numpy\ntorch\nopencv-contrib-python-headless" }, { "path": "templates/examples/test.sh", "content": "#! /bin/bash\n\necho \"Running a test: Generate method of this medigan model module.\"\n\necho \"If not done already, please download 500.pt file from: https://drive.google.com/file/d/1C9vVPymsKJ5i5gpwQM6cpX0y1G89vcpk/view?usp=sharing\"\n\necho \"1. Creating and activating virtual environment called MMG_env.\"\npython3 -m venv MMG_env\nsource MMG_env/bin/activate\n\necho \"2. Pip install dependencies from requirements.txt\"\npip install -r requirements.txt\n\necho \"3. Run the generate function with parameters\"\npython __init__.py \n\npython -c \"from __init__ import generate; \nmodel_file='500.pt';\nnum_samples=10;\noutput_path='images/';\nsave_images=True;\ngenerate(model_file=model_file, num_samples=num_samples, output_path=output_path, save_images=save_images)\"\n\necho \"4. Done. Any errors? Have synthetic images been successfully created in folder /images?\"" }, { "path": "templates/raw_examples/LICENSE", "content": "copy license here\n" }, { "path": "templates/raw_examples/__init__.py", "content": "" }, { "path": "templates/raw_examples/metadata.json", "content": "{\n \"MODEL_ID\": {\n \"execution\": {\n \"package_name\": null,\n \"package_link\": null,\n \"model_name\": null,\n \"extension\": null,\n \"image_size\": [],\n \"dependencies\": [],\n \"generate_method\": {\n \"name\": null,\n \"args\": {\n \"base\": [\n \"model_file\",\n \"num_samples\",\n \"output_path\",\n \"save_images\"\n ],\n \"custom\": {}\n }\n }\n },\n \"selection\": {\n \"performance\": {\n \"SSIM\": null,\n \"MSE\": null,\n \"NSME\": null,\n \"PSNR\": null,\n \"IS\": null,\n \"FID\": null,\n \"turing_test\": null,\n \"downstream_task\": {\n \"CLF\": {\n \"trained_on_fake\": {\n \"accuracy\": null,\n \"precision\": null,\n \"recall\": null,\n \"f1\": null,\n \"specificity\": null,\n \"AUROC\": null,\n \"AUPRC\": null\n },\n \"trained_on_real_and_fake\": {},\n \"trained_on_real\": {}\n },\n \"SEG\": {\n \"trained_on_fake\": {\n \"dice\": null,\n \"jaccard\": null,\n \"accuracy\": null,\n \"precision\": null,\n \"recall\": null,\n \"f1\": null\n },\n \"trained_on_real_and_fake\": {},\n \"trained_on_real\": {}\n }\n }\n },\n \"use_cases\": [],\n \"organ\": [],\n \"modality\": [],\n \"vendors\": [],\n \"centres\": [],\n \"function\": [],\n \"condition\": [],\n \"dataset\": [],\n \"augmentations\": [],\n \"generates\": [],\n \"height\": null,\n \"width\": null,\n \"depth\": null,\n \"type\": null,\n \"license\": null,\n \"dataset_type\": null,\n \"privacy_preservation\": null,\n \"tags\": [],\n \"year\": null\n },\n \"description\": {\n \"title\": null,\n \"provided_date\": null,\n \"trained_date\": null,\n \"provided_after_epoch\": null,\n \"version\": null,\n \"publication\": null,\n \"doi\": [],\n \"comment\": null\n }\n },\n}\n" }, { "path": "templates/raw_examples/model.pt", "content": "" }, { "path": "templates/template.json", "content": "{\n \"MODEL_ID\": {\n \"execution\": {\n \"package_name\": \"\",\n \"package_link\": \"\",\n \"model_name\": \"\",\n \"extension\": \"\",\n \"image_size\": [],\n \"dependencies\": [],\n \"generate_method\": {\n \"name\": \"\",\n \"args\": {\n \"base\": [\n \"model_file\",\n \"num_samples\",\n \"output_path\",\n \"save_images\"\n ],\n \"custom\": {}\n }\n }\n },\n \"selection\": {\n \"performance\": {\n \"SSIM\": null,\n \"MSE\": null,\n \"NSME\": null,\n \"PSNR\": null,\n \"IS\": null,\n \"FID\": null,\n \"turing_test\": \"\",\n \"downstream_task\": {\n \"CLF\": {\n \"trained_on_fake\": {\n \"accuracy\": null,\n \"precision\": null,\n \"recall\": null,\n \"f1\": null,\n \"specificity\": null,\n \"AUROC\": null,\n \"AUPRC\": null\n },\n \"trained_on_real_and_fake\": {},\n \"trained_on_real\": {}\n },\n \"SEG\": {\n \"trained_on_fake\": {\n \"dice\": null,\n \"jaccard\": null,\n \"accuracy\": null,\n \"precision\": null,\n \"recall\": null,\n \"f1\": null\n },\n \"trained_on_real_and_fake\": {},\n \"trained_on_real\": {}\n }\n }\n },\n \"use_cases\": [],\n \"organ\": [],\n \"modality\": [],\n \"vendors\": [],\n \"centres\": [],\n \"function\": [],\n \"condition\": [],\n \"dataset\": [],\n \"augmentations\": [],\n \"generates\": [],\n \"height\": null,\n \"width\": null,\n \"depth\": null,\n \"type\": \"\",\n \"license\": \"\",\n \"dataset_type\": \"\",\n \"privacy_preservation\": \"\",\n \"tags\": [],\n \"year\": null\n },\n \"description\": {\n \"title\": \"\",\n \"provided_date\": \"\",\n \"trained_date\": \"\",\n \"provided_after_epoch\": null,\n \"version\": \"\",\n \"publication\": \"\",\n \"doi\": [],\n \"inputs\": [],\n \"comment\": \"\"\n }\n }\n}\n" }, { "path": "tests/__init__.py", "content": "" }, { "path": "tests/fid.py", "content": "\"\"\"\nCalculates the Frechet Inception Distance between two distributions, using chosen feature extractor model.\n\nRadImageNet Model source: https://github.com/BMEII-AI/RadImageNet\nRadImageNet InceptionV3 weights (original, broken since 11.07.2023): https://drive.google.com/file/d/1p0q9AhG3rufIaaUE1jc2okpS8sdwN6PU\nRadImageNet InceptionV3 weights (for medigan, updated link 11.07.2023): https://drive.google.com/drive/folders/1lGFiS8_a5y28l4f8zpc7fklwzPJC-gZv\n\nUsage:\n python fid.py dir1 dir2 \n\"\"\"\n\nimport argparse\nimport os\n\nimport cv2\nimport numpy as np\nimport tensorflow as tf\nimport tensorflow_gan as tfgan\nimport wget\nfrom tensorflow.keras.applications import InceptionV3\nfrom tensorflow.keras.applications.inception_v3 import preprocess_input\n\nimg_size = 299\nbatch_size = 64\nnum_batches = 1\nRADIMAGENET_URL = \"https://drive.google.com/uc?id=1uvJHLG1K71Qzl7Km4JMpNOwE7iTjN8g9\"\nRADIMAGENET_WEIGHTS = \"RadImageNet-InceptionV3_notop.h5\"\nIMAGENET_TFHUB_URL = \"https://tfhub.dev/tensorflow/tfgan/eval/inception/1\"\n\n\ndef parse_args() -> argparse.Namespace:\n parser = argparse.ArgumentParser(\n description=\"Calculates the Frechet Inception Distance between two distributions using RadImageNet model.\"\n )\n parser.add_argument(\n \"dataset_path_1\",\n type=str,\n help=\"Path to images from first dataset\",\n )\n parser.add_argument(\n \"dataset_path_2\",\n type=str,\n help=\"Path to images from second dataset\",\n )\n parser.add_argument(\n \"--model\",\n type=str,\n default=\"imagenet\",\n help=\"Use RadImageNet feature extractor for FID calculation\",\n )\n parser.add_argument(\n \"--lower_bound\",\n action=\"store_true\",\n help=\"Calculate lower bound of FID using the 50/50 split of images from dataset_path_1\",\n )\n parser.add_argument(\n \"--normalize_images\",\n action=\"store_true\",\n help=\"Normalize images from both datasources using min and max of each sample\",\n )\n args = parser.parse_args()\n return args\n\n\ndef load_images(directory, normalize=False, split=False, limit=None):\n \"\"\"\n Loads images from the given directory.\n If split is True, then half of the images is loaded to one array and the other half to another.\n \"\"\"\n if split:\n subset_1 = []\n subset_2 = []\n else:\n images = []\n\n for count, filename in enumerate(os.listdir(directory)):\n if filename.lower().endswith((\".png\", \".jpg\", \".jpeg\")):\n img = cv2.imread(os.path.join(directory, filename))\n img = cv2.resize(img, (img_size, img_size), interpolation=cv2.INTER_LINEAR)\n if normalize:\n img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX)\n if len(img.shape) > 2 and img.shape[2] == 4:\n img = img[:, :, :3]\n if len(img.shape) == 2:\n img = np.stack([img] * 3, axis=2)\n\n if split:\n if count % 2 == 0:\n subset_1.append(img)\n else:\n subset_2.append(img)\n else:\n images.append(img)\n if count == limit:\n break\n if split:\n subset_1 = preprocess_input(np.array(subset_1))\n subset_2 = preprocess_input(np.array(subset_2))\n return subset_1, subset_2\n else:\n images = preprocess_input(np.array(images))\n return images\n\n\ndef check_model_weights(model_name):\n \"\"\"\n Checks if the model weights are available and download them if not.\n \"\"\"\n model_weights_path = None\n if model_name == \"radimagenet\":\n model_weights_path = RADIMAGENET_WEIGHTS\n if not os.path.exists(RADIMAGENET_WEIGHTS):\n print(\"Downloading RadImageNet InceptionV3 model:\")\n wget.download(\n RADIMAGENET_URL,\n model_weights_path,\n )\n print(\"\\n\")\n return model_weights_path\n\n\ndef _radimagenet_fn(images):\n \"\"\"\n Get RadImageNet inception v3 model\n \"\"\"\n model = InceptionV3(\n weights=RADIMAGENET_WEIGHTS,\n input_shape=(img_size, img_size, 3),\n include_top=False,\n pooling=\"avg\",\n )\n output = model(images)\n output = tf.nest.map_structure(tf.keras.layers.Flatten(), output)\n return output\n\n\ndef get_classifier_fn(model_name=\"imagenet\"):\n \"\"\"\n Get model as TF function for optimized inference.\n \"\"\"\n check_model_weights(model_name)\n\n if model_name == \"radimagenet\":\n return _radimagenet_fn\n elif model_name == \"imagenet\":\n return tfgan.eval.classifier_fn_from_tfhub(IMAGENET_TFHUB_URL, \"pool_3\", True)\n else:\n raise ValueError(\"Model {} not recognized\".format(model_name))\n\n\ndef calculate_fid(\n directory_1,\n directory_2,\n model_name,\n lower_bound=False,\n normalize_images=False,\n):\n \"\"\"\n Calculates the Frechet Inception Distance between two distributions using chosen feature extractor model.\n \"\"\"\n limit = min(len(os.listdir(directory_1)), len(os.listdir(directory_2)))\n if lower_bound:\n images_1, images_2 = load_images(directory_1, split=True, limit=limit)\n else:\n images_1 = load_images(directory_1, limit=limit, normalize=normalize_images)\n images_2 = load_images(directory_2, limit=limit, normalize=normalize_images)\n\n fid = tfgan.eval.frechet_classifier_distance(\n images_1, images_2, get_classifier_fn(model_name)\n )\n\n return fid\n\n\nif __name__ == \"__main__\":\n args = parse_args()\n\n directory_1 = args.dataset_path_1\n directory_2 = args.dataset_path_2\n lower_bound = args.lower_bound\n normalize_images = args.normalize_images\n model_name = args.model\n\n fid = calculate_fid(\n directory_1=directory_1,\n directory_2=directory_2,\n model_name=model_name,\n lower_bound=lower_bound,\n normalize_images=normalize_images,\n )\n\n if lower_bound:\n print(\"Lower bound FID {}: {}\".format(model_name, fid))\n else:\n print(\"FID {}: {}\".format(model_name, fid))\n" }, { "path": "tests/model_contribution_test_manual.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" script for quick local testing if a new model can be added and works inside medigan.\"\"\"\n# run with python -m tests.model_contribution_test_manual\n\nimport glob\nimport logging\nimport shutil\nimport sys\nimport unittest\n\ntry:\n from src.medigan.generators import Generators\n\n LOGGING_LEVEL = \"INFO\"\n logger = logging.getLogger() # (__name__)\n logger.setLevel(LOGGING_LEVEL)\n stream_handler = logging.StreamHandler(sys.stdout)\n stream_handler.setLevel(LOGGING_LEVEL)\n formatter = logging.Formatter(\n \"%(asctime)s - %(name)s - %(levelname)s - %(message)s\"\n )\n stream_handler.setFormatter(formatter)\n logger.addHandler(stream_handler)\n\n generators = Generators()\n\n # Testing init of contributor with correct params\n init_py_path = \"../models/00012_C-DCGAN_MMG_MASSES/__init__.py\"\n metadata_file_path = \"../models/00012_C-DCGAN_MMG_MASSES/metadata.json\"\n model_id = \"00012_C-DCGAN_MMG_MASSES\"\n\n zenodo_access_token = \"ACCESS_TOKEN\"\n github_access_token = \"ACCESS_TOKEN\"\n\n creator_name = \"John Doe\"\n creator_affiliation = \"University of Barcelona\"\n\n # Testing full model contribution workflow.\n generators.contribute(\n model_id=model_id,\n init_py_path=init_py_path,\n zenodo_access_token=zenodo_access_token,\n github_access_token=github_access_token,\n metadata_file_path=metadata_file_path,\n creator_name=creator_name,\n creator_affiliation=creator_affiliation,\n )\n\n # Testing init of contributor with erroneous params\n # contributor = generators.add_model_contributor(model_id ='Some model id', init_py_path=\"somePath\")\n # contributor = generators.add_model_contributor(model_id ='00008_WGANGP_MMG_MASS_ROI', init_py_path=\"somePath\")\n # contributor = generators.add_model_contributor(model_id ='Some model id', init_py_path=\"init_py_path\")\n\n # Creating the model contributor\n # generators.add_model_contributor(model_id=model_id, init_py_path=init_py_path)\n\n # Adding the metadata of the model from input\n # generators.add_metadata_from_file(\n # model_id=model_id, metadata_file_path=metadata_file_path\n # )\n\n # Alternatively, Adding the metadata of the model from file\n # metadata = contributor.add_metadata_from_input(\n # model_weights_name = \"10000\",\n # model_weights_extension=\".pt\",\n # generate_method_name = \"generate\",\n # dependencies=[\"numpy\", \"torch\", \"opencv-contrib-python-headless\"])\n\n # Add metadata to global.json config\n # generators.test_model(model_id=model_id)\n\n # Alternatively, explicitely providing model metadata to add the metadata to config\n # generators._add_model_to_config(model_id=model_id, metadata=metadata, metadata_file_path=metadata_file_path,\n # overwrite_existing_metadata=True)\n\n # Zenodo upload test\n # generators.push_to_zenodo(\n # model_id=model_id,\n # access_token=zenodo_access_token,\n # creator_name=\"test\",\n # creator_affiliation=\"test affiliation\",\n # )\n\n # Manual Zenodo Test 1\n # import requests\n # r = requests.get('https://zenodo.org/api/deposit/depositions', params = {'access_token': zenodo_access_token})\n # print(r.status_code)\n # print(r.json())\n\n # Manual Zenodo Test 2\n # headers = {\"Content-Type\": \"application/json\"}\n # params = {\"access_token\": zenodo_access_token}\n # r = requests.post(\n # \"https://zenodo.org/api/deposit/depositions\",\n # params=params,\n # json={},\n # headers=headers,\n # )\n # print(r.json())\n # print(r.status_code)\n\n # Github upload test\n # generators.push_to_github(\n # model_id=model_id,\n # github_access_token=github_access_token,\n # package_link=None,\n # creator_name=\"test\",\n # creator_affiliation=\"test affiliation\",\n # model_description=\"test description\",\n # )\n\nexcept Exception as e:\n logging.error(f\"test_init_generators error: {e}\")\n raise e\n" }, { "path": "tests/model_integration_test_manual.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" script for quick local testing if a model works inside medigan.\"\"\"\n# run with python -m tests.model_integration_test_manual\n\nimport logging\n\nMODEL_ID = \"YOUR_MODEL_ID_HERE\"\nMODEL_ID = 23 # \"00023_PIX2PIXHD_BREAST_DCEMRI\" #\"00002_DCGAN_MMG_MASS_ROI\" # \"00007_BEZIERCURVE_TUMOUR_MASK\"\nNUM_SAMPLES = 2\nOUTPUT_PATH = f\"output/{MODEL_ID}/\"\ntry:\n from src.medigan.generators import Generators\n\n generators = Generators()\nexcept Exception as e:\n logging.error(f\"test_init_generators error: {e}\")\n raise e\n\ngenerators.generate(\n model_id=MODEL_ID,\n num_samples=NUM_SAMPLES,\n output_path=OUTPUT_PATH,\n input_path=\"input/\",\n gpu_id=0,\n image_size=448,\n install_dependencies=True,\n)\n\ndata_loader = generators.get_as_torch_dataloader(\n model_id=MODEL_ID,\n num_samples=NUM_SAMPLES,\n output_path=OUTPUT_PATH,\n input_path=\"input/\",\n gpu_id=0,\n image_size=448,\n # prefetch_factor=2, # debugging with torch v2.0.0: This will raise an error for torch DataLoader if num_workers == None at the same time.\n)\n\nprint(f\"len(data_loader): {len(data_loader)}\")\n\nif len(data_loader) != NUM_SAMPLES:\n logging.warning(\n f\"{MODEL_ID}: The number of samples in the dataloader (={len(data_loader)}) is not equal the number of samples requested (={NUM_SAMPLES}).\"\n )\n\n#### Get the object at index 0 from the dataloader\ndata_dict = next(iter(data_loader))\n\nprint(f\"data_dict: {data_dict}\")\n" }, { "path": "tests/test_model_executor.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" main test script to test the primary functions/classes/methods. \"\"\"\n# run with python -m tests.test_generator\n\nimport glob\nimport logging\nimport os\nimport shutil\nimport sys\n\nimport pytest\nimport torch\n\n# import unittest\n\n\n# Set the logging level depending on the level of detail you would like to have in the logs while running the tests.\nLOGGING_LEVEL = logging.INFO # WARNING # logging.INFO\n\nmodels_with_args = [\n (\n \"00001_DCGAN_MMG_CALC_ROI\",\n {},\n 100,\n ), # 100 samples to test automatic batch-wise image generation in model_executor\n (\n \"00002\",\n {},\n 3,\n ), # \"00002\" instead of \"00002_DCGAN_MMG_MASS_ROI\" to test shortcut model_ids\n (\n \"03\",\n {\"translate_all_images\": False},\n 2,\n ), # \"03\" instead of \"00003_CYCLEGAN_MMG_DENSITY_FULL\" to test shortcut model_ids\n (\n 4, # 4 instead of \"00004_PIX2PIX_MMG_MASSES_W_MASKS\" to test shortcut model_ids\n {\n \"shapes\": [\"oval\"],\n \"ssim_threshold\": 0.18,\n \"image_size\": [128, 128],\n \"patch_size\": [30, 30],\n },\n 3,\n ),\n (\"00005_DCGAN_MMG_MASS_ROI\", {}, 3),\n (\"00006_WGANGP_MMG_MASS_ROI\", {}, 3),\n (\n \"00007_INPAINT_BRAIN_MRI\",\n {\n \"image_size\": (256, 256),\n \"num_inpaints_per_sample\": 2,\n \"randomize_input_image_order\": False,\n \"add_variations_to_mask\": False,\n \"x_center\": 120,\n \"y_center\": 140,\n \"radius_1\": 8,\n \"radius_2\": 12,\n \"radius_3\": 24,\n },\n 3,\n ),\n (\n \"00008_C-DCGAN_MMG_MASSES\",\n {\"condition\": 0, \"is_cbisddsm_training_data\": False},\n 3,\n ),\n (\"00009_PGGAN_POLYP_PATCHES_W_MASKS\", {\"save_option\": \"image_only\"}, 3),\n (\"00010_FASTGAN_POLYP_PATCHES_W_MASKS\", {\"save_option\": \"image_only\"}, 3),\n # (\"00011_SINGAN_POLYP_PATCHES_W_MASKS\", {\"checkpoint_ids\": [999]}, 3), # removed after successful testing due to limited CI pipeline capacity\n # (\"00012_C-DCGAN_MMG_MASSES\", {\"condition\": 0}, 3), # removed after successful testing due to limited CI pipeline capacity\n # (\"00013_CYCLEGAN_MMG_DENSITY_OPTIMAM_MLO\", {\"translate_all_images\": False}, 2), # removed after successful testing due to limited CI pipeline capacity\n # (\"00014_CYCLEGAN_MMG_DENSITY_OPTIMAM_CC\", {\"translate_all_images\": False}, 2), # removed after successful testing due to limited CI pipeline capacity\n # (\"00015_CYCLEGAN_MMG_DENSITY_CSAW_MLO\", {\"translate_all_images\": False}, 2), # removed after successful testing due to limited CI pipeline capacity\n # (\"00016_CYCLEGAN_MMG_DENSITY_CSAW_CC\", {\"translate_all_images\": False}, 2), # removed after successful testing due to limited CI pipeline capacity\n (\"00017_DCGAN_XRAY_LUNG_NODULES\", {}, 3),\n (\"00018_WGANGP_XRAY_LUNG_NODULES\", {}, 3),\n (\"00019_PGGAN_CHEST_XRAY\", {}, 3),\n (\"00020_PGGAN_CHEST_XRAY\", {\"resize_pixel_dim\": 512, \"image_size\": 256}, 3),\n (\n \"00021_CYCLEGAN_BRAIN_MRI_T1_T2\",\n {\n \"input_path\": \"models/00021_CYCLEGAN_Brain_MRI_T1_T2/inputs/T2\",\n \"gpu_id\": 0,\n \"T1_to_T2\": False,\n },\n 3,\n ),\n (\"00022_WGAN_CARDIAC_AGING\", {}, 3),\n (\n \"00023_PIX2PIXHD_BREAST_DCEMRI\",\n {\n \"input_path\": \"input\",\n \"gpu_id\": 0,\n \"image_size\": 448,\n },\n 3,\n ),\n]\n\n\n# class TestMediganExecutorMethods(unittest.TestCase):\nclass TestMediganExecutorMethods:\n def setup_class(self):\n ## unittest logger config\n # This logger on root level initialized via logging.getLogger() will also log all log events\n # from the medigan library. Pass a logger name (e.g. __name__) instead if you only want logs from tests.py\n self.logger = logging.getLogger() # (__name__)\n self.logger.setLevel(LOGGING_LEVEL)\n stream_handler = logging.StreamHandler(sys.stdout)\n stream_handler.setLevel(LOGGING_LEVEL)\n formatter = logging.Formatter(\n \"%(asctime)s - %(name)s - %(levelname)s - %(message)s\"\n )\n stream_handler.setFormatter(formatter)\n self.logger.addHandler(stream_handler)\n\n self.test_output_path = \"test_output_path\"\n self.num_samples = 2\n self.test_imports_and_init_generators(self)\n self._remove_dir_and_contents(self) # in case something is left there.\n self.model_ids = self.generators.config_manager.model_ids\n\n def test_imports_and_init_generators(self):\n from src.medigan.constants import (\n CONFIG_FILE_KEY_EXECUTION,\n CONFIG_FILE_KEY_GENERATE,\n CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE,\n )\n from src.medigan.generators import Generators\n\n self.generators = Generators()\n self.CONFIG_FILE_KEY_EXECUTION = CONFIG_FILE_KEY_EXECUTION\n self.CONFIG_FILE_KEY_GENERATE = CONFIG_FILE_KEY_GENERATE\n self.CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE = (\n CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE\n )\n\n @pytest.mark.parametrize(\"models_with_args\", [models_with_args])\n def test_sample_generation_methods(self, models_with_args: list):\n self.logger.debug(f\"models: {models_with_args}\")\n for i, model_id in enumerate(self.model_ids):\n # if (\n # model_id != \"00011_SINGAN_POLYP_PATCHES_W_MASKS\"\n # ):\n ## avoiding full memory on Windows ci test server\n # continue\n self.logger.debug(f\"Now testing model {model_id}\")\n self._remove_dir_and_contents() # Already done in each test independently, but to be sure, here again.\n self.test_generate_method(model_id=model_id)\n\n # Check if args available fo model_id. Note: The models list may not include the latest medigan models\n for model in models_with_args:\n if model_id == model[0]:\n self.test_generate_method_with_additional_args(\n model_id=model[0], args=model[1], expected_num_samples=model[2]\n )\n self.test_get_generate_method(model_id=model_id)\n self.test_get_dataloader_method(model_id=model_id)\n\n # if i == 16: # just for local testing\n # self._remove_model_dir_and_zip(\n # model_ids=[model_id], are_all_models_deleted=False\n # )\n\n @pytest.mark.parametrize(\n \"values_list, should_sample_be_generated\",\n [\n ([\"dcgan\", \"mMg\", \"ClF\", \"modality\", \"inbreast\"], True),\n ([\"dcgan\", \"mMg\", \"ClF\", \"modality\", \"optimam\"], True),\n ([\"dcgan\", \"mMg\", \"ClF\", \"modalities\"], False),\n ],\n )\n def test_find_model_and_generate_method(\n self, values_list, should_sample_be_generated\n ):\n self._remove_dir_and_contents()\n\n self.generators.find_model_and_generate(\n values=values_list,\n target_values_operator=\"AND\",\n are_keys_also_matched=True,\n is_case_sensitive=False,\n num_samples=self.num_samples,\n output_path=self.test_output_path,\n )\n\n self._check_if_samples_were_generated(\n should_sample_be_generated=should_sample_be_generated\n )\n\n @pytest.mark.parametrize(\n \"values_list, metric\",\n [\n ([\"dcgan\", \"MMG\"], \"CLF.trained_on_real_and_fake.f1\"),\n ([\"dcgan\", \"MMG\"], \"turing_test.AUC\"),\n ],\n )\n def test_find_and_rank_models_then_generate_method(self, values_list, metric):\n self._remove_dir_and_contents()\n # TODO This test needs the respective metrics for any of these models to be available in config/global.json.\n # These values would need to find at least two models.\n self.generators.find_models_rank_and_generate(\n values=values_list,\n target_values_operator=\"AND\",\n are_keys_also_matched=True,\n is_case_sensitive=False,\n metric=metric,\n order=\"asc\",\n num_samples=self.num_samples,\n output_path=self.test_output_path,\n )\n self._check_if_samples_were_generated()\n\n # @pytest.mark.parametrize(\"model_id\", [model[0] for model in models_with_args])\n @pytest.mark.skip\n def test_generate_method(self, model_id):\n self._remove_dir_and_contents()\n self.generators.generate(\n model_id=model_id,\n num_samples=self.num_samples,\n output_path=self.test_output_path,\n install_dependencies=True,\n )\n self._check_if_samples_were_generated(model_id=model_id)\n\n # @pytest.mark.parametrize(\"model_id, args, expected_num_samples\", models_with_args)\n @pytest.mark.skip\n def test_generate_method_with_additional_args(\n self, model_id, args, expected_num_samples\n ):\n self._remove_dir_and_contents()\n self.generators.generate(\n model_id=model_id,\n num_samples=expected_num_samples,\n output_path=self.test_output_path,\n **args,\n )\n self._check_if_samples_were_generated(\n model_id=model_id, num_samples=expected_num_samples\n )\n\n # @pytest.mark.parametrize(\"model_id\", [model[0] for model in models_with_args])\n @pytest.mark.skip\n def test_get_generate_method(self, model_id):\n self._remove_dir_and_contents()\n gen_function = self.generators.get_generate_function(\n model_id=model_id,\n num_samples=self.num_samples,\n output_path=self.test_output_path,\n )\n gen_function()\n self._check_if_samples_were_generated(model_id=model_id)\n del gen_function\n\n # @pytest.mark.parametrize(\"model_id\", [model[0] for model in models_with_args])\n @pytest.mark.skip\n def test_get_dataloader_method(self, model_id):\n self._remove_dir_and_contents()\n data_loader = self.generators.get_as_torch_dataloader(\n model_id=model_id, num_samples=self.num_samples\n )\n self.logger.debug(f\"{model_id}: len(data_loader): {len(data_loader)}\")\n\n if len(data_loader) != self.num_samples:\n logging.warning(\n f\"{model_id}: The number of samples in the dataloader (={len(data_loader)}) is not equal the number of samples requested (={self.num_samples}). \"\n f\"Hint: Revise if the model's internal generate() function returned tuples as required in get_as_torch_dataloader().\"\n )\n\n #### Get the object at index 0 from the dataloader\n data_dict = next(iter(data_loader))\n\n # Test if the items at index [0] of the aforementioned object is of type torch tensor (e.g. torch.uint8) and not None, as expected by data structure design decision.\n assert torch.is_tensor(data_dict.get(\"sample\"))\n\n # Test if the items at index [1], [2] of the aforementioned object are None and, if not, whether they are of type torch tensor, as expected\n assert data_dict.get(\"mask\") is None or torch.is_tensor(data_dict.get(\"mask\"))\n assert data_dict.get(\"other_imaging_output\") is None or torch.is_tensor(\n data_dict.get(\"other_imaging_output\")\n )\n\n # Test if the items at index [3] of the aforementioned object is None and, if not, whether it is of type list of strings, as expected.\n assert data_dict.get(\"label\") is None or (\n isinstance(data_dict.get(\"label\"), list)\n and isinstance(data_dict.get(\"label\")[0], str)\n )\n del data_dict\n del data_loader\n\n # @pytest.mark.parametrize(\"model_id\", [model[0] for model in models_with_args])\n @pytest.mark.skip\n def test_visualize_method(self, model_id):\n if (\n self.CONFIG_FILE_KEY_GENERATE_ARGS_INPUT_LATENT_VECTOR_SIZE\n in self.generators.config_manager.config_dict[model_id][\n self.CONFIG_FILE_KEY_EXECUTION\n ][self.CONFIG_FILE_KEY_GENERATE]\n ):\n self.generators.visualize(model_id, auto_close=True)\n\n else:\n with pytest.raises(Exception) as e:\n self.generators.visualize(model_id, auto_close=True)\n\n assert e.type == ValueError\n\n @pytest.mark.skip\n def _check_if_samples_were_generated(\n self, model_id=None, num_samples=None, should_sample_be_generated: bool = True\n ):\n # check if the number of generated samples of model_id_1 is as expected.\n file_list = glob.glob(self.test_output_path + \"/*\")\n self.logger.debug(f\"{model_id}: {len(file_list)} == {self.num_samples} ?\")\n if num_samples is None:\n num_samples = self.num_samples\n\n if should_sample_be_generated:\n assert (\n len(file_list) == num_samples\n or len(file_list)\n == num_samples\n * 2\n * 6 # 00007_INPAINT_BRAIN_MRI: 2 inpaints per sample, 6 outputs per sample\n or len(file_list)\n == num_samples * 2 # Temporary fix for different outputs per model.\n or len(file_list) == num_samples + 1\n ), f\"Model {model_id} generated {len(file_list)} samples instead of the expected {num_samples}, {num_samples*2*6}, or {num_samples + 1}.\"\n # Some models are balanced per label by default: If num_samples is odd, then len(file_list)==num_samples +1\n else:\n assert len(file_list) == 0\n\n # @pytest.mark.skip\n def _remove_dir_and_contents(self):\n \"\"\"After each test, empty the created folders and files to avoid corrupting a new test.\"\"\"\n\n try:\n shutil.rmtree(self.test_output_path)\n except OSError as e:\n # This may give an error if the folders are not created.\n self.logger.debug(\n f\"Exception while trying to delete folder. Likely it simply had not yet been created: {e}\"\n )\n except Exception as e2:\n self.logger.error(f\"Error while trying to delete folder: {e2}\")\n\n @pytest.mark.skip\n def _remove_model_dir_and_zip(\n self, model_ids=[], are_all_models_deleted: bool = False\n ):\n \"\"\"After a specific model folders, model_executor, and model zip file to avoid running out-of-disk space.\"\"\"\n\n try:\n for i, model_executor in enumerate(self.generators.model_executors):\n if are_all_models_deleted or (\n model_ids is not None and model_executor.model_id in model_ids\n ):\n try:\n # Delete the folder containing the model\n model_path = os.path.dirname(\n model_executor.deserialized_model_as_lib.__file__\n )\n shutil.rmtree(model_path)\n self.logger.info(\n f\"Deleted directory of model {model_executor.model_id}. ({model_path})\"\n )\n\n except OSError as e:\n # This may give an error if the FOLDER is not present\n self.logger.warning(\n f\"Exception while trying to delete the model folder of model {model_executor.model_id}: {e}\"\n )\n try:\n # If the downloaded zip package of the model was not deleted inside the model_path, we explicitely delete it now.\n if model_executor.package_path.is_file():\n os.remove(model_executor.package_path)\n self.logger.info(\n f\"Deleted zip file of model {model_executor.model_id}. ({model_executor.package_path})\"\n )\n except Exception as e:\n self.logger.warning(\n f\"Exception while trying to delete the ZIP file ({model_executor.package_path}) of model {model_executor.model_id}: {e}\"\n )\n # Deleting the stateful model_executors instantiated by the generators module, after deleting folders and zips\n if are_all_models_deleted:\n self.generators.model_executors.clear()\n else:\n if model_ids is not None:\n for model_id in model_ids:\n model_executor = self.generators.find_model_executor_by_id(\n model_id\n )\n if model_executor is not None:\n self.generators.model_executors.remove(model_executor)\n del model_executor\n except Exception as e2:\n self.logger.error(\n f\"Error while trying to delete model folders and zips: {e2}\"\n )\n\n # @pytest.fixture(scope=\"session\", autouse=True)\n def teardown_class(self):\n \"\"\"After all tests, empty the large model folders, model_executors, and zip files to avoid running out-of-disk space.\"\"\"\n\n # yield is at test-time, signaling that things after yield are run after the execution of the last test has terminated\n # https://docs.pytest.org/en/7.1.x/reference/reference.html?highlight=fixture#pytest.fixture\n # yield None\n\n # Remove all test outputs in test_output_path\n self._remove_dir_and_contents(self)\n\n # Remove all model folders, zip files and model executors\n # self._remove_model_dir_and_zip(\n # self, model_ids=[\"00006_WGANGP_MMG_MASS_ROI\"], are_all_models_deleted=False\n # ) # just for local testing\n # self._remove_model_dir_and_zip(\n # self, model_ids=None, are_all_models_deleted=True\n # )\n" }, { "path": "tests/test_model_selector.py", "content": "# -*- coding: utf-8 -*-\n# ! /usr/bin/env python\n\"\"\" main test script to test the primary functions/classes/methods. \"\"\"\n# run with python -m tests.test_model_selector\n\nimport logging\nimport sys\n\nimport pytest\n\n# import unittest\n\n\n# Set the logging level depending on the level of detail you would like to have in the logs while running the tests.\nLOGGING_LEVEL = logging.INFO # WARNING # logging.INFO\n\nmodels = [\n (\n \"00001_DCGAN_MMG_CALC_ROI\",\n {},\n 100,\n ),\n (\"00002_DCGAN_MMG_MASS_ROI\", {}, 3),\n (\"00003_CYCLEGAN_MMG_DENSITY_FULL\", {\"translate_all_images\": False}, 2),\n (\"00005_DCGAN_MMG_MASS_ROI\", {}, 3),\n # Further models can be added here if/when needed.\n]\n\n\n# class TestMediganSelectorMethods(unittest.TestCase):\nclass TestMediganSelectorMethods:\n def setup_method(self):\n ## unittest logger config\n # This logger on root level initialized via logging.getLogger() will also log all log events\n # from the medigan library. Pass a logger name (e.g. __name__) instead if you only want logs from tests.py\n self.logger = logging.getLogger() # (__name__)\n self.logger.setLevel(LOGGING_LEVEL)\n stream_handler = logging.StreamHandler(sys.stdout)\n stream_handler.setLevel(LOGGING_LEVEL)\n formatter = logging.Formatter(\n \"%(asctime)s - %(name)s - %(levelname)s - %(message)s\"\n )\n stream_handler.setFormatter(formatter)\n self.logger.addHandler(stream_handler)\n self.test_init_generators()\n\n def test_init_generators(self):\n from src.medigan.generators import Generators\n\n self.generators = Generators()\n\n @pytest.mark.parametrize(\n \"values_list\",\n [\n ([\"dcgan\", \"mMg\", \"ClF\", \"modality\"]),\n ([\"DCGAN\", \"Mammography\"]),\n ],\n )\n def test_search_for_models_method(self, values_list):\n found_models = self.generators.find_matching_models_by_values(\n values=values_list,\n target_values_operator=\"AND\",\n are_keys_also_matched=True,\n is_case_sensitive=False,\n )\n self.logger.debug(\n f\"For value {values_list}, these models were found: {found_models}\"\n )\n assert len(found_models) > 0\n\n @pytest.mark.parametrize(\n \"models, values_list, metric\",\n [\n (\n models,\n [\"dcgan\", \"MMG\"],\n \"CLF.trained_on_real_and_fake.f1\",\n ),\n (models, [\"dcgan\", \"MMG\"], \"turing_test.AUC\"),\n ],\n )\n def test_find_and_rank_models_by_performance(self, models, values_list, metric):\n # These values would need to find at least two models. See metrics and values in the config/global.json file.\n found_ranked_models = self.generators.find_models_and_rank(\n values=values_list,\n target_values_operator=\"AND\",\n are_keys_also_matched=True,\n is_case_sensitive=False,\n metric=metric,\n order=\"desc\",\n )\n assert (\n len(found_ranked_models) > 0 # some models were found as is expected\n and found_ranked_models[0][\"model_id\"] is not None # has a model id\n and (\n len(found_ranked_models) < 2\n or found_ranked_models[0][metric] > found_ranked_models[1][metric]\n ) # descending order (the higher a model's value, the lower its index in the list) is working\n )\n\n @pytest.mark.parametrize(\n \"models, metric, order\",\n [\n (\n models,\n \"FID\",\n \"asc\",\n ), # Note: normally a lower FID is better, therefore asc (model with lowest FID has lowest result list index).\n (\n models,\n \"FID_RADIMAGENET_ratio\",\n \"desc\", # descending, as the higher the FID ratio the better.\n ),\n # Note: normally a lower FID is better, therefore asc (model with lowest FID has lowest result list index).\n (models, \"CLF.trained_on_real_and_fake.f1\", \"desc\"),\n (models, \"turing_test.AUC\", \"desc\"),\n ],\n )\n def test_rank_models_by_performance(self, models, metric, order):\n \"\"\"Ranking according to metrics in the config/global.json file.\"\"\"\n ranked_models = self.generators.rank_models_by_performance(\n model_ids=None,\n metric=metric,\n order=order,\n )\n assert (\n len(ranked_models) > 0 # at least one model was found\n and (\n len(ranked_models) >= 21 or metric != \"FID\"\n ) # we should find at least 21 models with FID in medigan\n and ranked_models[0][\"model_id\"]\n is not None # found model has a model id (i.e. correctly formatted results)\n and (\n len(ranked_models) == 1\n or (\n ranked_models[0][metric] > ranked_models[1][metric]\n or metric == \"FID\"\n )\n ) # descending order (the higher a model's value, the lower its index in the list) is working. In case of FID it is the other way around (ascending order is better).\n )\n\n @pytest.mark.parametrize(\n \"models, metric, order\",\n [\n (models, \"CLF.trained_on_real_and_fake.f1\", \"desc\"),\n (models, \"turing_test.AUC\", \"desc\"),\n ],\n )\n def test_rank_models_by_performance_with_given_ids(self, models, metric, order):\n \"\"\"Ranking a specified set of models according to metrics in the config/global.json file.\"\"\"\n ranked_models = self.generators.rank_models_by_performance(\n model_ids=[models[1][0], models[2][0]],\n metric=metric,\n order=order,\n )\n assert 0 < len(ranked_models) <= 2 and (\n len(ranked_models) < 2\n or (ranked_models[0][metric] > ranked_models[1][metric])\n ) # checking if descending order (the higher a model's value, the lower its index in the list) is working.\n\n @pytest.mark.parametrize(\n \"key1, value1, expected\",\n [\n (\"modality\", \"Full-Field Mammography\", 2),\n (\"license\", \"BSD\", 2),\n (\"performance.CLF.trained_on_real_and_fake.f1\", \"0.96\", 0),\n (\"performance.turing_test.AUC\", \"0.56\", 0),\n ],\n )\n def test_get_models_by_key_value_pair(self, key1, value1, expected):\n found_models = self.generators.get_models_by_key_value_pair(\n key1=key1, value1=value1, is_case_sensitive=False\n )\n assert len(found_models) >= expected\n" } ]