oracle-ads 2.11.8__py3-none-any.whl → 2.11.10__py3-none-any.whl

ads/aqua/{model.py → model/model.py}

@@ -3,292 +3,59 @@
 # Copyright (c) 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 import os
-import re
-from dataclasses import InitVar, dataclass, field
 from datetime import datetime, timedelta
-from enum import Enum
 from threading import Lock
-from typing import List, Union
+from typing import List, Optional, Union
 
-import oci
 from cachetools import TTLCache
 from oci.data_science.models import JobRun, Model
 
-from ads.aqua import ODSC_MODEL_COMPARTMENT_OCID, logger, utils
-from ads.aqua.base import AquaApp
-from ads.aqua.constants import (
-    TRAINING_METRICS_FINAL,
-    TRINING_METRICS,
-    UNKNOWN_VALUE,
-    VALIDATION_METRICS,
-    VALIDATION_METRICS_FINAL,
-    FineTuningDefinedMetadata,
+from ads.aqua import ODSC_MODEL_COMPARTMENT_OCID
+from ads.aqua.app import AquaApp
+from ads.aqua.common.enums import Tags
+from ads.aqua.common.errors import AquaRuntimeError
+from ads.aqua.common.utils import (
+    create_word_icon,
+    get_artifact_path,
+    read_file,
+    copy_model_config,
+    load_config,
 )
-from ads.aqua.data import AquaResourceIdentifier, Tags
-from ads.aqua.exception import AquaRuntimeError
-from ads.aqua.training.exceptions import exit_code_dict
-from ads.aqua.utils import (
+from ads.aqua.constants import (
     LICENSE_TXT,
+    MODEL_BY_REFERENCE_OSS_PATH_KEY,
     README,
     READY_TO_DEPLOY_STATUS,
     READY_TO_FINE_TUNE_STATUS,
+    READY_TO_IMPORT_STATUS,
+    TRAINING_METRICS_FINAL,
+    TRINING_METRICS,
     UNKNOWN,
-    create_word_icon,
-    get_artifact_path,
-    read_file,
+    VALIDATION_METRICS,
+    VALIDATION_METRICS_FINAL,
+    AQUA_MODEL_ARTIFACT_CONFIG,
+    AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME,
+    AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE,
+    AQUA_MODEL_TYPE_CUSTOM,
 )
+from ads.aqua.model.constants import *
+from ads.aqua.model.entities import *
 from ads.common.auth import default_signer
-from ads.common.object_storage_details import ObjectStorageDetails
 from ads.common.oci_resource import SEARCH_TYPE, OCIResource
-from ads.common.serializer import DataClassSerializable
-from ads.common.utils import get_console_link, get_log_links
+from ads.common.utils import get_console_link
 from ads.config import (
-    AQUA_SERVICE_MODELS_BUCKET,
+    AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME,
+    AQUA_EVALUATION_CONTAINER_METADATA_NAME,
+    AQUA_FINETUNING_CONTAINER_METADATA_NAME,
     COMPARTMENT_OCID,
-    CONDA_BUCKET_NS,
     PROJECT_OCID,
     TENANCY_OCID,
 )
 from ads.model import DataScienceModel
-from ads.model.model_metadata import MetadataTaxonomyKeys, ModelCustomMetadata
+from ads.model.model_metadata import ModelCustomMetadata, ModelCustomMetadataItem
 from ads.telemetry import telemetry
 
 
-class FineTuningMetricCategories(Enum):
-    VALIDATION = "validation"
-    TRAINING = "training"
-
-
-@dataclass(repr=False)
-class FineTuningShapeInfo(DataClassSerializable):
-    instance_shape: str = field(default_factory=str)
-    replica: int = field(default_factory=int)
-
-
-# TODO: give a better name
-@dataclass(repr=False)
-class AquaFineTuneValidation(DataClassSerializable):
-    type: str = "Automatic split"
-    value: str = ""
-
-
-@dataclass(repr=False)
-class AquaFineTuningMetric(DataClassSerializable):
-    name: str = field(default_factory=str)
-    category: str = field(default_factory=str)
-    scores: list = field(default_factory=list)
-
-
-@dataclass(repr=False)
-class AquaModelLicense(DataClassSerializable):
-    """Represents the response of Get Model License."""
-
-    id: str = field(default_factory=str)
-    license: str = field(default_factory=str)
-
-
-@dataclass(repr=False)
-class AquaModelSummary(DataClassSerializable):
-    """Represents a summary of Aqua model."""
-
-    compartment_id: str = None
-    icon: str = None
-    id: str = None
-    is_fine_tuned_model: bool = None
-    license: str = None
-    name: str = None
-    organization: str = None
-    project_id: str = None
-    tags: dict = None
-    task: str = None
-    time_created: str = None
-    console_link: str = None
-    search_text: str = None
-    ready_to_deploy: bool = True
-    ready_to_finetune: bool = False
-
-
-@dataclass(repr=False)
-class AquaModel(AquaModelSummary, DataClassSerializable):
-    """Represents an Aqua model."""
-
-    model_card: str = None
-
-
-@dataclass(repr=False)
-class AquaEvalFTCommon(DataClassSerializable):
-    """Represents common fields for evaluation and fine-tuning."""
-
-    lifecycle_state: str = None
-    lifecycle_details: str = None
-    job: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)
-    source: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)
-    experiment: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)
-    log_group: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)
-    log: AquaResourceIdentifier = field(default_factory=AquaResourceIdentifier)
-
-    model: InitVar = None
-    region: InitVar = None
-    jobrun: InitVar = None
-
-    def __post_init__(
-        self, model, region: str, jobrun: oci.data_science.models.JobRun = None
-    ):
-        try:
-            log_id = jobrun.log_details.log_id
-        except Exception as e:
-            logger.debug(f"No associated log found. {str(e)}")
-            log_id = ""
-
-        try:
-            loggroup_id = jobrun.log_details.log_group_id
-        except Exception as e:
-            logger.debug(f"No associated loggroup found. {str(e)}")
-            loggroup_id = ""
-
-        loggroup_url = get_log_links(region=region, log_group_id=loggroup_id)
-        log_url = (
-            get_log_links(
-                region=region,
-                log_group_id=loggroup_id,
-                log_id=log_id,
-                compartment_id=jobrun.compartment_id,
-                source_id=jobrun.id,
-            )
-            if jobrun
-            else ""
-        )
-
-        log_name = None
-        loggroup_name = None
-
-        if log_id:
-            try:
-                log = utils.query_resource(log_id, return_all=False)
-                log_name = log.display_name if log else ""
-            except:
-                pass
-
-        if loggroup_id:
-            try:
-                loggroup = utils.query_resource(loggroup_id, return_all=False)
-                loggroup_name = loggroup.display_name if loggroup else ""
-            except:
-                pass
-
-        experiment_id, experiment_name = utils._get_experiment_info(model)
-
-        self.log_group = AquaResourceIdentifier(
-            loggroup_id, loggroup_name, loggroup_url
-        )
-        self.log = AquaResourceIdentifier(log_id, log_name, log_url)
-        self.experiment = utils._build_resource_identifier(
-            id=experiment_id, name=experiment_name, region=region
-        )
-        self.job = utils._build_job_identifier(job_run_details=jobrun, region=region)
-        self.lifecycle_details = (
-            utils.LIFECYCLE_DETAILS_MISSING_JOBRUN
-            if not jobrun
-            else jobrun.lifecycle_details
-        )
-
-
-@dataclass(repr=False)
-class AquaFineTuneModel(AquaModel, AquaEvalFTCommon, DataClassSerializable):
-    """Represents an Aqua Fine Tuned Model."""
-
-    dataset: str = field(default_factory=str)
-    validation: AquaFineTuneValidation = field(default_factory=AquaFineTuneValidation)
-    shape_info: FineTuningShapeInfo = field(default_factory=FineTuningShapeInfo)
-    metrics: List[AquaFineTuningMetric] = field(default_factory=list)
-
-    def __post_init__(
-        self,
-        model: DataScienceModel,
-        region: str,
-        jobrun: oci.data_science.models.JobRun = None,
-    ):
-        super().__post_init__(model=model, region=region, jobrun=jobrun)
-
-        if jobrun is not None:
-            jobrun_env_vars = (
-                jobrun.job_configuration_override_details.environment_variables or {}
-            )
-            self.shape_info = FineTuningShapeInfo(
-                instance_shape=jobrun.job_infrastructure_configuration_details.shape_name,
-                # TODO: use variable for `NODE_COUNT` in ads/jobs/builders/runtimes/base.py
-                replica=jobrun_env_vars.get("NODE_COUNT", UNKNOWN_VALUE),
-            )
-
-        try:
-            model_hyperparameters = model.defined_metadata_list.get(
-                MetadataTaxonomyKeys.HYPERPARAMETERS
-            ).value
-        except Exception as e:
-            logger.debug(
-                f"Failed to extract model hyperparameters from {model.id}: " f"{str(e)}"
-            )
-            model_hyperparameters = {}
-
-        self.dataset = model_hyperparameters.get(
-            FineTuningDefinedMetadata.TRAINING_DATA.value
-        )
-        if not self.dataset:
-            logger.debug(
-                f"Key={FineTuningDefinedMetadata.TRAINING_DATA.value} not found in model hyperparameters."
-            )
-
-        self.validation = AquaFineTuneValidation(
-            value=model_hyperparameters.get(
-                FineTuningDefinedMetadata.VAL_SET_SIZE.value
-            )
-        )
-        if not self.validation:
-            logger.debug(
-                f"Key={FineTuningDefinedMetadata.VAL_SET_SIZE.value} not found in model hyperparameters."
-            )
-
-        if self.lifecycle_details:
-            self.lifecycle_details = self._extract_job_lifecycle_details(
-                self.lifecycle_details
-            )
-
-    def _extract_job_lifecycle_details(self, lifecycle_details):
-        message = lifecycle_details
-        try:
-            # Extract exit code
-            match = re.search(r"exit code (\d+)", lifecycle_details)
-            if match:
-                exit_code = int(match.group(1))
-                if exit_code == 1:
-                    return message
-                # Match exit code to message
-                exception = exit_code_dict().get(
-                    exit_code,
-                    lifecycle_details,
-                )
-                message = f"{exception.reason} (exit code {exit_code})"
-        except:
-            pass
-
-        return message
-
-
-# TODO: merge metadata key used in create FT
-
-
-class FineTuningCustomMetadata(Enum):
-    FT_SOURCE = "fine_tune_source"
-    FT_SOURCE_NAME = "fine_tune_source_name"
-    FT_OUTPUT_PATH = "fine_tune_output_path"
-    FT_JOB_ID = "fine_tune_job_id"
-    FT_JOB_RUN_ID = "fine_tune_jobrun_id"
-    TRAINING_METRICS_FINAL = "train_metrics_final"
-    VALIDATION_METRICS_FINAL = "val_metrics_final"
-    TRAINING_METRICS_EPOCH = "train_metrics_epoch"
-    VALIDATION_METRICS_EPOCH = "val_metrics_epoch"
-
-
 class AquaModelApp(AquaApp):
     """Provides a suite of APIs to interact with Aqua models within the Oracle
     Cloud Infrastructure Data Science service, serving as an interface for
@@ -305,6 +72,7 @@ class AquaModelApp(AquaApp):
         Lists all Aqua models within a specified compartment and/or project.
     clear_model_list_cache()
         Allows clear list model cache items from the service models compartment.
+    register(model: str, os_path: str, local_dir: str = None)
 
     Note:
         This class is designed to work within the Oracle Cloud Infrastructure
@@ -382,13 +150,15 @@ class AquaModelApp(AquaApp):
         return custom_model
 
     @telemetry(entry_point="plugin=model&action=get", name="aqua")
-    def get(self, model_id) -> "AquaModel":
+    def get(self, model_id: str, load_model_card: Optional[bool] = True) -> "AquaModel":
         """Gets the information of an Aqua model.
 
         Parameters
         ----------
         model_id: str
             The model OCID.
+        load_model_card: (bool, optional). Defaults to `True`.
+            Whether to load model card from artifacts or not.
 
         Returns
         -------
@@ -407,38 +177,57 @@ class AquaModelApp(AquaApp):
         is_fine_tuned_model = (
             True
             if ds_model.freeform_tags
-            and ds_model.freeform_tags.get(Tags.AQUA_FINE_TUNED_MODEL_TAG.value)
+            and ds_model.freeform_tags.get(Tags.AQUA_FINE_TUNED_MODEL_TAG)
             else False
         )
 
         # todo: consolidate this logic in utils for model and deployment use
-        try:
-            artifact_path = ds_model.custom_metadata_list.get(
-                utils.MODEL_BY_REFERENCE_OSS_PATH_KEY
-            ).value.rstrip("/")
-            if not ObjectStorageDetails.is_oci_path(artifact_path):
-                artifact_path = ObjectStorageDetails(
-                    AQUA_SERVICE_MODELS_BUCKET, CONDA_BUCKET_NS, artifact_path
-                ).path
-        except ValueError:
-            artifact_path = utils.UNKNOWN
+        is_verified_type = (
+            ds_model.freeform_tags.get(Tags.READY_TO_IMPORT, "false").upper()
+            == READY_TO_IMPORT_STATUS
+        )
 
-        if not artifact_path:
-            logger.debug("Failed to get artifact path from custom metadata.")
+        model_card = ""
+        if load_model_card:
+            artifact_path = get_artifact_path(
+                ds_model.custom_metadata_list._to_oci_metadata()
+            )
+            if artifact_path != UNKNOWN:
+                model_card = str(
+                    read_file(
+                        file_path=(
+                            f"{artifact_path.rstrip('/')}/config/{README}"
+                            if is_verified_type
+                            else f"{artifact_path.rstrip('/')}/{README}"
+                        ),
+                        auth=default_signer(),
+                    )
+                )
 
-        aqua_model_atttributes = dict(
+        inference_container = ds_model.custom_metadata_list.get(
+            ModelCustomMetadataFields.DEPLOYMENT_CONTAINER,
+            ModelCustomMetadataItem(key=ModelCustomMetadataFields.DEPLOYMENT_CONTAINER),
+        ).value
+        evaluation_container = ds_model.custom_metadata_list.get(
+            ModelCustomMetadataFields.EVALUATION_CONTAINER,
+            ModelCustomMetadataItem(key=ModelCustomMetadataFields.EVALUATION_CONTAINER),
+        ).value
+        finetuning_container: str = ds_model.custom_metadata_list.get(
+            ModelCustomMetadataFields.FINETUNE_CONTAINER,
+            ModelCustomMetadataItem(key=ModelCustomMetadataFields.FINETUNE_CONTAINER),
+        ).value
+
+        aqua_model_attributes = dict(
             **self._process_model(ds_model, self.region),
             project_id=ds_model.project_id,
-            model_card=str(
-                read_file(
-                    file_path=f"{artifact_path}/{README}",
-                    auth=self._auth,
-                )
-            ),
+            model_card=model_card,
+            inference_container=inference_container,
+            finetuning_container=finetuning_container,
+            evaluation_container=evaluation_container,
         )
 
         if not is_fine_tuned_model:
-            model_details = AquaModel(**aqua_model_atttributes)
+            model_details = AquaModel(**aqua_model_attributes)
             self._service_model_details_cache.__setitem__(
                 key=model_id, value=model_details
             )
@@ -455,7 +244,7 @@ class AquaModelApp(AquaApp):
 
             try:
                 source_id = ds_model.custom_metadata_list.get(
-                    FineTuningCustomMetadata.FT_SOURCE.value
+                    FineTuningCustomMetadata.FT_SOURCE
                 ).value
             except ValueError as e:
                 logger.debug(str(e))
@@ -463,7 +252,7 @@ class AquaModelApp(AquaApp):
 
             try:
                 source_name = ds_model.custom_metadata_list.get(
-                    FineTuningCustomMetadata.FT_SOURCE_NAME.value
+                    FineTuningCustomMetadata.FT_SOURCE_NAME
                 ).value
             except ValueError as e:
                 logger.debug(str(e))
@@ -494,7 +283,7 @@ class AquaModelApp(AquaApp):
             )
 
             model_details = AquaFineTuneModel(
-                **aqua_model_atttributes,
+                **aqua_model_attributes,
                 source=source_identifier,
                 lifecycle_state=(
                     Model.LIFECYCLE_STATE_ACTIVE
@@ -541,29 +330,29 @@ class AquaModelApp(AquaApp):
 
         validation_metrics = self._fetch_metric_from_metadata(
             custom_metadata_list=custom_metadata_list,
-            target=FineTuningCustomMetadata.VALIDATION_METRICS_EPOCH.value,
-            category=FineTuningMetricCategories.VALIDATION.value,
+            target=FineTuningCustomMetadata.VALIDATION_METRICS_EPOCH,
+            category=FineTuningMetricCategories.VALIDATION,
             metric_name=VALIDATION_METRICS,
         )
 
         training_metrics = self._fetch_metric_from_metadata(
             custom_metadata_list=custom_metadata_list,
-            target=FineTuningCustomMetadata.TRAINING_METRICS_EPOCH.value,
-            category=FineTuningMetricCategories.TRAINING.value,
+            target=FineTuningCustomMetadata.TRAINING_METRICS_EPOCH,
+            category=FineTuningMetricCategories.TRAINING,
             metric_name=TRINING_METRICS,
         )
 
         validation_final = self._fetch_metric_from_metadata(
             custom_metadata_list=custom_metadata_list,
-            target=FineTuningCustomMetadata.VALIDATION_METRICS_FINAL.value,
-            category=FineTuningMetricCategories.VALIDATION.value,
+            target=FineTuningCustomMetadata.VALIDATION_METRICS_FINAL,
+            category=FineTuningMetricCategories.VALIDATION,
             metric_name=VALIDATION_METRICS_FINAL,
         )
 
         training_final = self._fetch_metric_from_metadata(
             custom_metadata_list=custom_metadata_list,
-            target=FineTuningCustomMetadata.TRAINING_METRICS_FINAL.value,
-            category=FineTuningMetricCategories.TRAINING.value,
+            target=FineTuningCustomMetadata.TRAINING_METRICS_FINAL,
+            category=FineTuningMetricCategories.TRAINING,
             metric_name=TRAINING_METRICS_FINAL,
         )
 
@@ -623,23 +412,27 @@ class AquaModelApp(AquaApp):
         )
 
         freeform_tags = model.freeform_tags or {}
-        is_fine_tuned_model = Tags.AQUA_FINE_TUNED_MODEL_TAG.value in freeform_tags
+        is_fine_tuned_model = Tags.AQUA_FINE_TUNED_MODEL_TAG in freeform_tags
         ready_to_deploy = (
-            freeform_tags.get(Tags.AQUA_TAG.value, "").upper() == READY_TO_DEPLOY_STATUS
+            freeform_tags.get(Tags.AQUA_TAG, "").upper() == READY_TO_DEPLOY_STATUS
         )
         ready_to_finetune = (
-            freeform_tags.get(Tags.READY_TO_FINE_TUNE.value, "").upper()
+            freeform_tags.get(Tags.READY_TO_FINE_TUNE, "").upper()
             == READY_TO_FINE_TUNE_STATUS
         )
+        ready_to_import = (
+            freeform_tags.get(Tags.READY_TO_IMPORT, "").upper()
+            == READY_TO_IMPORT_STATUS
+        )
 
         return dict(
             compartment_id=model.compartment_id,
             icon=icon or UNKNOWN,
             id=model_id,
-            license=freeform_tags.get(Tags.LICENSE.value, UNKNOWN),
+            license=freeform_tags.get(Tags.LICENSE, UNKNOWN),
             name=model.display_name,
-            organization=freeform_tags.get(Tags.ORGANIZATION.value, UNKNOWN),
-            task=freeform_tags.get(Tags.TASK.value, UNKNOWN),
+            organization=freeform_tags.get(Tags.ORGANIZATION, UNKNOWN),
+            task=freeform_tags.get(Tags.TASK, UNKNOWN),
             time_created=model.time_created,
             is_fine_tuned_model=is_fine_tuned_model,
             tags=tags,
@@ -647,11 +440,16 @@ class AquaModelApp(AquaApp):
             search_text=search_text,
             ready_to_deploy=ready_to_deploy,
             ready_to_finetune=ready_to_finetune,
+            ready_to_import=ready_to_import,
         )
 
     @telemetry(entry_point="plugin=model&action=list", name="aqua")
     def list(
-        self, compartment_id: str = None, project_id: str = None, **kwargs
+        self,
+        compartment_id: str = None,
+        project_id: str = None,
+        model_type: str = None,
+        **kwargs,
     ) -> List["AquaModelSummary"]:
         """Lists all Aqua models within a specified compartment and/or project.
         If `compartment_id` is not specified, the method defaults to returning
@@ -665,6 +463,8 @@ class AquaModelApp(AquaApp):
             The compartment OCID.
         project_id: (str, optional). Defaults to `None`.
             The project OCID.
+        model_type: (str, optional). Defaults to `None`.
+            Model type represents the type of model in the user compartment, can be either FT or BASE.
         **kwargs:
             Additional keyword arguments that can be used to filter the results.
 
@@ -682,7 +482,8 @@ class AquaModelApp(AquaApp):
             )
 
             logger.info(f"Fetching custom models from compartment_id={compartment_id}.")
-            models = self._rqs(compartment_id)
+            model_type = model_type.upper() if model_type else ModelType.FT
+            models = self._rqs(compartment_id, model_type=model_type)
         else:
             # tracks number of times service model listing was called
             self.telemetry.record_event_async(
@@ -751,16 +552,275 @@ class AquaModelApp(AquaApp):
                 }
         return res
 
+    def _create_model_catalog_entry(
+        self,
+        os_path: str,
+        model_name: str,
+        inference_container: str,
+        finetuning_container: str,
+        verified_model: DataScienceModel,
+        compartment_id: Optional[str],
+        project_id: Optional[str],
+    ) -> DataScienceModel:
+        """Create model by reference from the object storage path
+
+        Args:
+            os_path (str): OCI  where the model is uploaded - oci://bucket@namespace/prefix
+            model_name (str): name of the model
+            inference_container (str): selects service defaults
+            finetuning_container (str): selects service defaults
+            verified_model (DataScienceModel): If set, then copies all the tags and custom metadata information from the service verified model
+            compartment_id (Optional[str]): Compartment Id of the compartment where the model has to be created
+            project_id (Optional[str]): Project id of the project where the model has to be created
+
+        Returns:
+            DataScienceModel: Returns Datascience model instance.
+        """
+        model = DataScienceModel()
+        tags = (
+            {
+                **verified_model.freeform_tags,
+                Tags.AQUA_SERVICE_MODEL_TAG: verified_model.id,
+            }
+            if verified_model
+            else {Tags.AQUA_TAG: "active", Tags.BASE_MODEL_CUSTOM: "true"}
+        )
+        tags.update({Tags.BASE_MODEL_CUSTOM: "true"})
+
+        # Remove `ready_to_import` tag that might get copied from service model.
+        tags.pop(Tags.READY_TO_IMPORT, None)
+        metadata = None
+        if verified_model:
+            # Verified model is a model in the service catalog that either has no artifacts but contains all the necessary metadata for deploying and fine tuning.
+            # If set, then we copy all the model metadata.
+            metadata = verified_model.custom_metadata_list
+            if verified_model.model_file_description:
+                model = model.with_model_file_description(
+                    json_dict=verified_model.model_file_description
+                )
+
+        else:
+            metadata = ModelCustomMetadata()
+            if not inference_container:
+                raise AquaRuntimeError(
+                    f"Require Inference container information. Model: {model_name} does not have associated inference container defaults. Check docs for more information on how to pass inference container."
+                )
+            if finetuning_container:
+                tags[Tags.READY_TO_FINE_TUNE] = "true"
+                metadata.add(
+                    key=AQUA_FINETUNING_CONTAINER_METADATA_NAME,
+                    value=finetuning_container,
+                    description=f"Fine-tuning container mapping for {model_name}",
+                    category="Other",
+                )
+            else:
+                logger.warn(
+                    f"Proceeding with model registration without the fine-tuning container information. "
+                    f"This model will not be available for fine tuning."
+                )
+
+            metadata.add(
+                key=AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME,
+                value=inference_container,
+                description=f"Inference container mapping for {model_name}",
+                category="Other",
+            )
+            metadata.add(
+                key=AQUA_EVALUATION_CONTAINER_METADATA_NAME,
+                value="odsc-llm-evaluate",
+                description="Evaluation container mapping for SMC",
+                category="Other",
+            )
+            # TODO: either get task and organization from user or a config file
+            # tags["task"] = "UNKNOWN"
+            # tags["organization"] = "UNKNOWN"
+
+        try:
+            # If verified model already has a artifact json, use that.
+            artifact_path = metadata.get(MODEL_BY_REFERENCE_OSS_PATH_KEY).value
+            logger.info(
+                f"Found model artifact in the service bucket. "
+                f"Using artifact from service bucket instead of {os_path}"
+            )
+
+            # todo: implement generic copy_folder method
+            # copy model config from artifact path to user bucket
+            copy_model_config(
+                artifact_path=artifact_path, os_path=os_path, auth=default_signer()
+            )
+
+        except:
+            # Add artifact from user bucket
+            metadata.add(
+                key=MODEL_BY_REFERENCE_OSS_PATH_KEY,
+                value=os_path,
+                description="artifact location",
+                category="Other",
+            )
+
+        model = (
+            model.with_custom_metadata_list(metadata)
+            .with_compartment_id(compartment_id or COMPARTMENT_OCID)
+            .with_project_id(project_id or PROJECT_OCID)
+            .with_artifact(os_path)
+            .with_display_name(model_name)
+            .with_freeform_tags(**tags)
+        ).create(model_by_reference=True)
+        logger.debug(model)
+        return model
+
+    def register(
+        self, import_model_details: ImportModelDetails = None, **kwargs
+    ) -> AquaModel:
+        """Loads the model from object storage and registers as Model in Data Science Model catalog
+        The inference container and finetuning container could be of type Service Manged Container(SMC) or custom.
+        If it is custom, full container URI is expected. If it of type SMC, only the container family name is expected.
+
+        Args:
+            import_model_details (ImportModelDetails): Model details for importing the model.
+            kwargs:
+                model (str): name of the model or OCID of the service model that has inference and finetuning information
+                os_path (str): Object storage destination URI to store the downloaded model. Format: oci://bucket-name@namespace/prefix
+                inference_container (str): selects service defaults
+                finetuning_container (str): selects service defaults
+
+        Returns:
+            AquaModel:
+                The registered model as a AquaModel object.
+        """
+        verified_model_details: DataScienceModel = None
+
+        if not import_model_details:
+            import_model_details = ImportModelDetails(**kwargs)
+
+        try:
+            model_config = load_config(
+                file_path=import_model_details.os_path,
+                config_file_name=AQUA_MODEL_ARTIFACT_CONFIG,
+            )
+        except Exception as ex:
+            logger.error(
+                f"Exception occurred while loading config file from {import_model_details.os_path}"
+                f"Exception message: {ex}"
+            )
+            raise AquaRuntimeError(
+                f"The model path {import_model_details.os_path} does not contain the file config.json. "
+                f"Please check if the path is correct or the model artifacts are available at this location."
+            )
+
+        model_service_id = None
+        # If OCID of a model is passed, we need to copy the defaults for Tags and metadata from the service model.
+        if (
+            import_model_details.model.startswith("ocid")
+            and "datasciencemodel" in import_model_details.model
+        ):
+            model_service_id = import_model_details.model
+        else:
+            # If users passes model name, check if there is model with the same name in the service model catalog. If it is there, then use that model
+            model_service_id = self._find_matching_aqua_model(
+                import_model_details.model
+            )
+            logger.info(
+                f"Found service model for {import_model_details.model}: {model_service_id}"
+            )
+        if model_service_id:
+            verified_model_details = DataScienceModel.from_id(model_service_id)
+            try:
+                metadata_model_type = verified_model_details.custom_metadata_list.get(
+                    AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE
+                ).value
+                if metadata_model_type:
+                    if AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE in model_config:
+                        if (
+                            model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE]
+                            != metadata_model_type
+                        ):
+                            raise AquaRuntimeError(
+                                f"The {AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE} attribute in {AQUA_MODEL_ARTIFACT_CONFIG}"
+                                f" at {import_model_details.os_path} is invalid, expected {metadata_model_type} for "
+                                f"the model {import_model_details.model}. Please check if the path is correct or "
+                                f"the correct model artifacts are available at this location."
+                                f""
+                            )
+                    else:
+                        logger.debug(
+                            f"Could not find {AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE} attribute in "
+                            f"{AQUA_MODEL_ARTIFACT_CONFIG}. Proceeding with model registration."
+                        )
+            except:
+                pass
+
+        # Copy the model name from the service model if `model` is ocid
+        model_name = (
+            verified_model_details.display_name
+            if verified_model_details
+            else import_model_details.model
+        )
+
+        # Create Model catalog entry with pass by reference
+        ds_model = self._create_model_catalog_entry(
+            os_path=import_model_details.os_path,
+            model_name=model_name,
+            inference_container=import_model_details.inference_container,
+            finetuning_container=import_model_details.finetuning_container,
+            verified_model=verified_model_details,
+            compartment_id=import_model_details.compartment_id,
+            project_id=import_model_details.project_id,
+        )
+        # registered model will always have inference and evaluation container, but
+        # fine-tuning container may be not set
+        inference_container = ds_model.custom_metadata_list.get(
+            ModelCustomMetadataFields.DEPLOYMENT_CONTAINER
+        ).value
+        evaluation_container = ds_model.custom_metadata_list.get(
+            ModelCustomMetadataFields.EVALUATION_CONTAINER,
+        ).value
+        try:
+            finetuning_container = ds_model.custom_metadata_list.get(
+                ModelCustomMetadataFields.FINETUNE_CONTAINER,
+            ).value
+        except:
+            finetuning_container = None
+
+        aqua_model_attributes = dict(
+            **self._process_model(ds_model, self.region),
+            project_id=ds_model.project_id,
+            model_card=str(
+                read_file(
+                    file_path=f"{import_model_details.os_path.rstrip('/')}/{README}",
+                    auth=default_signer(),
+                )
+            ),
+            inference_container=inference_container,
+            finetuning_container=finetuning_container,
+            evaluation_container=evaluation_container,
+        )
+
+        if verified_model_details:
+            telemetry_model_name = model_name
+        else:
+            if AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME in model_config:
+                telemetry_model_name = f"{AQUA_MODEL_TYPE_CUSTOM}_{model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_NAME]}"
+            elif AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE in model_config:
+                telemetry_model_name = f"{AQUA_MODEL_TYPE_CUSTOM}_{model_config[AQUA_MODEL_ARTIFACT_CONFIG_MODEL_TYPE]}"
+            else:
+                telemetry_model_name = AQUA_MODEL_TYPE_CUSTOM
+
+        self.telemetry.record_event_async(
+            category="aqua/model",
+            action="register",
+            detail=telemetry_model_name,
+        )
+
+        return AquaModel(**aqua_model_attributes)
+
     def _if_show(self, model: DataScienceModel) -> bool:
         """Determine if the given model should be return by `list`."""
         if model.freeform_tags is None:
             return False
 
         TARGET_TAGS = model.freeform_tags.keys()
-        return (
-            Tags.AQUA_TAG.value in TARGET_TAGS
-            or Tags.AQUA_TAG.value.lower() in TARGET_TAGS
-        )
+        return Tags.AQUA_TAG in TARGET_TAGS or Tags.AQUA_TAG.lower() in TARGET_TAGS
 
     def _load_icon(self, model_name: str) -> str:
         """Loads icon."""
@@ -772,10 +832,18 @@ class AquaModelApp(AquaApp):
             logger.debug(f"Failed to load icon for the model={model_name}: {str(e)}.")
             return None
 
-    def _rqs(self, compartment_id: str, **kwargs):
+    def _rqs(self, compartment_id: str, model_type="FT", **kwargs):
         """Use RQS to fetch models in the user tenancy."""
+        if model_type == ModelType.FT:
+            filter_tag = Tags.AQUA_FINE_TUNED_MODEL_TAG
+        elif model_type == ModelType.BASE:
+            filter_tag = Tags.BASE_MODEL_CUSTOM
+        else:
+            raise ValueError(
+                f"Model of type {model_type} is unknown. The values should be in {ModelType.values()}"
+            )
 
-        condition_tags = f"&& (freeformTags.key = '{Tags.AQUA_TAG.value}' && freeformTags.key = '{Tags.AQUA_FINE_TUNED_MODEL_TAG.value}')"
+        condition_tags = f"&& (freeformTags.key = '{Tags.AQUA_TAG}' && freeformTags.key = '{filter_tag}')"
         condition_lifecycle = "&& lifecycleState = 'ACTIVE'"
         query = f"query datasciencemodel resources where (compartmentId = '{compartment_id}' {condition_lifecycle} {condition_tags})"
         logger.info(query)
@@ -820,3 +888,27 @@ class AquaModelApp(AquaApp):
         )
 
         return AquaModelLicense(id=model_id, license=content)
+
+    def _find_matching_aqua_model(self, model_id: str) -> Optional[str]:
+        """
+        Finds a matching model in AQUA based on the model ID from list of verified models.
+
+        Parameters
+        ----------
+        model_id (str): Verified model ID to match.
+
+        Returns
+        -------
+        Optional[str]
+            Returns model ocid that matches the model in the service catalog else returns None.
+        """
+        # Convert the model ID to lowercase once
+        model_id_lower = model_id.lower()
+
+        aqua_model_list = self.list()
+
+        for aqua_model_summary in aqua_model_list:
+            if aqua_model_summary.name.lower() == model_id_lower:
+                return aqua_model_summary.id
+
+        return None