Inherits NetworkObject.

Public Member Functions
str	modelDescriptorFileName (cls)

Self	createModel (cls, str name, int experimentId, float accuracy, Dict[str, Any] meta)

None	saveModelDescriptor (cls, str path, Dict[str, Any] contents)

None	download (self)

bool	upload (self, str path)

Detailed Description

    Represents a machine learning model object on Coretex.ai
    Contains properties that describe the model

    Properties
    ----------
    name : str
        model name
    createdById : str
        id of model
    createdOn : datetime
        date of model creation
    datasetId : int
        dataset id that is used for training the model
    spaceId : int
        space id that is used for training the model
    projectId : int
        project id that is used for training the model
    isTrained : bool
        True if model is trained, False otherwise
    isDeleted : bool
        True if model is deleted, False otherwise
    accuracy : float
        model accuracy
    experimentId : int
        experiment id of trained model
    meta : Dict[str, Any]
        model meta data

Definition at line 33 of file model.py.

Member Function Documentation

◆ createModel()

Self coretex.coretex.model.model.Model.createModel	(		cls,
		str	name,
		int	experimentId,
		float	accuracy,
		Dict[str, Any]	meta
	)

    Creates Model object of the provided experiment with specified properties

    Parameters
    ----------
    name : str
model name
    experimentId : int
experiment id of model
    accuracy : float
model accuracy
    meta : Dict[str, Any]
model meta data

    Returns
    -------
    Self -> Model object

    Example
    -------
    >>> from coretex import Model, ExecutingExperiment
    \b
    >>> experiment = ExecutingExperiment.current()
    >>> model = Model.createModel(
    name = experiment.name,
    experimentId = experiment.id,
    accuracy = 0.87,
    meta = {}
)

Definition at line 95 of file model.py.

     def createModel(cls, name: str, experimentId: int, accuracy: float, meta: Dict[str, Any]) -> Self:
         """
             Creates Model object of the provided experiment with specified properties
  
             Parameters
             ----------
             name : str
                 model name
             experimentId : int
                 experiment id of model
             accuracy : float
                 model accuracy
             meta : Dict[str, Any]
                 model meta data
  
             Returns
             -------
             Self -> Model object
  
             Example
             -------
             >>> from coretex import Model, ExecutingExperiment
             \b
             >>> experiment = ExecutingExperiment.current()
             >>> model = Model.createModel(
                     name = experiment.name,
                     experimentId = experiment.id,
                     accuracy = 0.87,
                     meta = {}
                 )
         """
  
         model = cls.create(parameters = {
             "name": name,
             "model_queue_id": experimentId,
             "accuracy": accuracy,
             "meta": meta
         })
  
         if model is None:
             raise ValueError(">> [Coretex] Failed to create Model entity")
  
         return model
  

◆ download()

None coretex.coretex.model.model.Model.download ( self )

    Downloads and extracts the model zip file from Coretex.ai

Definition at line 179 of file model.py.

     def download(self) -> None:
         """
             Downloads and extracts the model zip file from Coretex.ai
         """
  
         if self.isDeleted or not self.isTrained:
             return
  
         modelZipDestination = os.path.join(FolderManager.instance().modelsFolder, f"{self.id}.zip")
  
         modelFolderDestination = os.path.join(FolderManager.instance().modelsFolder, f"{self.id}")
         if os.path.exists(modelFolderDestination):
             return
  
         os.mkdir(modelFolderDestination)
  
         response = networkManager.genericDownload(
             endpoint=f"model/download?id={self.id}",
             destination=modelZipDestination
         )
  
         if response.hasFailed():
             logging.getLogger("coretexpylib").info(">> [Coretex] Failed to download the model")
  
         zipFile = ZipFile(modelZipDestination)
         zipFile.extractall(modelFolderDestination)
         zipFile.close()
  

◆ modelDescriptorFileName()

str coretex.coretex.model.model.Model.modelDescriptorFileName ( cls )

    Returns
    -------
    str -> name of model descriptor file

Definition at line 78 of file model.py.

     def modelDescriptorFileName(cls) -> str:
         """
             Returns
             -------
             str -> name of model descriptor file
         """
  
         return "model_descriptor.json"
  

◆ saveModelDescriptor()

None coretex.coretex.model.model.Model.saveModelDescriptor	(		cls,
		str	path,
		Dict[str, Any]	contents
	)

Saves a model descriptor - a JSON file that provides a description of a
machine learning model. It includes information such as the model's
architecture, input and output shapes, labels, description and etc.

Example
-------
>>> from coretex import ExecutingExperiment, Model
>>> model = Model.createModel(experiment.name, experiment.id, accuracy, {})
>>> model.saveModelDescriptor(modelPath, {
"project_task": experiment.spaceTask,
"labels": labels,
"modelName": model.name,
"description": experiment.description,

"input_description":
    Input shape is [x, y]

    x is actually number of samples in dataset\n
    y represents number of unique taxons for selected level in dataset,

"input_shape": [x, y],

"output_description":
    Output shape - [x, z]

    x is actually number of samples in dataset\n
    z represents that output 2d array (table) is going to have only 1 column (1 prediction for each sample in dataset),

"output_shape": [x, z]
    })

Definition at line 140 of file model.py.

     def saveModelDescriptor(cls, path: str, contents: Dict[str, Any]) -> None:
         """
         Saves a model descriptor - a JSON file that provides a description of a
         machine learning model. It includes information such as the model's
         architecture, input and output shapes, labels, description and etc.
  
         Example
         -------
         >>> from coretex import ExecutingExperiment, Model
         >>> model = Model.createModel(experiment.name, experiment.id, accuracy, {})
         >>> model.saveModelDescriptor(modelPath, {
                 "project_task": experiment.spaceTask,
                 "labels": labels,
                 "modelName": model.name,
                 "description": experiment.description,
  
                 "input_description":
                     Input shape is [x, y]
  
                     x is actually number of samples in dataset\n
                     y represents number of unique taxons for selected level in dataset,
  
                 "input_shape": [x, y],
  
                 "output_description":
                     Output shape - [x, z]
  
                     x is actually number of samples in dataset\n
                     z represents that output 2d array (table) is going to have only 1 column (1 prediction for each sample in dataset),
  
                 "output_shape": [x, z]
             })
         """
  
         modelDescriptorPath = os.path.join(path, cls.modelDescriptorFileName())
  
         with open(modelDescriptorPath, "w", encoding = "utf-8") as file:
             json.dump(contents, file, ensure_ascii = False, indent = 4)
  

◆ upload()

bool coretex.coretex.model.model.Model.upload	(		self,
		str	path
	)

    Uploads the model zip file to Coretex.ai

    Parameters
    ----------
    path : str
Path to the saved model dir

    Returns
    -------
    bool -> True if model data uploaded successfully, False if model data upload has failed


    Example
    -------
    >>> from coretex import Model, ExecutingExperiment
    \b
    >>> experiment: ExecutingExperiment[NetworkDataset] = ExecutingExperiment.current()
    >>> model = Model.createModel(
name = experiment.name,
experimentId = experiment.id,
accuracy = 0.87,
meta = {}
    )
    >>> if not model.upload("path/to/model-dir"):
    print("Failed to upload model")

Definition at line 207 of file model.py.

     def upload(self, path: str) -> bool:
         """
             Uploads the model zip file to Coretex.ai
  
             Parameters
             ----------
             path : str
                 Path to the saved model dir
  
             Returns
             -------
             bool -> True if model data uploaded successfully, False if model data upload has failed
  
  
             Example
             -------
             >>> from coretex import Model, ExecutingExperiment
             \b
             >>> experiment: ExecutingExperiment[NetworkDataset] = ExecutingExperiment.current()
             >>> model = Model.createModel(
                 name = experiment.name,
                 experimentId = experiment.id,
                 accuracy = 0.87,
                 meta = {}
             )
             >>> if not model.upload("path/to/model-dir"):
                     print("Failed to upload model")
         """
  
         if self.isDeleted:
             return False
  
         logging.getLogger("coretexpylib").info(">> [Coretex] Uploading model file...")
  
         shutil.make_archive(path, "zip", path)
  
         files = {
             ("file", open(f"{path}.zip", "rb"))
         }
  
         parameters = {
             "id": self.id
         }
  
         response = networkManager.genericUpload("model/upload", files, parameters)
         if response.hasFailed():
             logging.getLogger("coretexpylib").info(">> [Coretex] Failed to upload model file")
         else:
             logging.getLogger("coretexpylib").info(">> [Coretex] Uploaded model file")
  
         return not response.hasFailed()

The documentation for this class was generated from the following file:

src/coretex/coretex/model/model.py