two version of R2R are here HEAD master

6 files changed, 888 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/__init__.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/__init__.py
new file mode 100644
index 00000000..fdf8caba
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/__init__.py
@@ -0,0 +1,5 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/constants.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/constants.py
new file mode 100644
index 00000000..5084ffbd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/constants.py
@@ -0,0 +1,20 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+
+class AzureMLDistillationProperties:
+    ENABLE_DISTILLATION = "azureml.enable_distillation"
+    DATA_GENERATION_TYPE = "azureml.data_generation_type"
+    DATA_GENERATION_TASK_TYPE = "azureml.data_generation_task_type"
+    TEACHER_MODEL = "azureml.teacher_model"
+    INSTANCE_TYPE = "azureml.instance_type"
+    CONNECTION_INFORMATION = "azureml.connection_information"
+
+
+class EndpointSettings:
+    VALID_SETTINGS = {"request_batch_size", "min_endpoint_success_ratio"}
+
+
+class PromptSettingKeys:
+    VALID_SETTINGS = {"enable_chain_of_thought", "enable_chain_of_density", "max_len_summary"}
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/distillation_job.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/distillation_job.py
new file mode 100644
index 00000000..469fde98
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/distillation_job.py
@@ -0,0 +1,542 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import json
+from typing import Any, Dict, Optional
+
+from azure.ai.ml._restclient.v2024_01_01_preview.models import (
+    CustomModelFineTuning as RestCustomModelFineTuningVertical,
+)
+from azure.ai.ml._restclient.v2024_01_01_preview.models import FineTuningJob as RestFineTuningJob
+from azure.ai.ml._restclient.v2024_01_01_preview.models import JobBase as RestJobBase
+from azure.ai.ml._restclient.v2024_01_01_preview.models import MLFlowModelJobInput, UriFileJobInput
+from azure.ai.ml._utils._experimental import experimental
+from azure.ai.ml.constants import DataGenerationType, JobType
+from azure.ai.ml.constants._common import BASE_PATH_CONTEXT_KEY, TYPE, AssetTypes
+from azure.ai.ml.entities._inputs_outputs import Input
+from azure.ai.ml.entities._job._input_output_helpers import from_rest_data_outputs, to_rest_data_outputs
+from azure.ai.ml.entities._job.distillation.constants import (
+    AzureMLDistillationProperties,
+    EndpointSettings,
+    PromptSettingKeys,
+)
+from azure.ai.ml.entities._job.distillation.endpoint_request_settings import EndpointRequestSettings
+from azure.ai.ml.entities._job.distillation.prompt_settings import PromptSettings
+from azure.ai.ml.entities._job.distillation.teacher_model_settings import TeacherModelSettings
+from azure.ai.ml.entities._job.job import Job
+from azure.ai.ml.entities._job.job_io_mixin import JobIOMixin
+from azure.ai.ml.entities._job.resource_configuration import ResourceConfiguration
+from azure.ai.ml.entities._util import load_from_dict
+from azure.ai.ml.entities._workspace.connections.workspace_connection import WorkspaceConnection
+
+
+# pylint: disable=too-many-instance-attributes
+@experimental
+class DistillationJob(Job, JobIOMixin):
+    def __init__(
+        self,
+        *,
+        data_generation_type: str,
+        data_generation_task_type: str,
+        teacher_model_endpoint_connection: WorkspaceConnection,
+        student_model: Input,
+        training_data: Optional[Input] = None,
+        validation_data: Optional[Input] = None,
+        teacher_model_settings: Optional[TeacherModelSettings] = None,
+        prompt_settings: Optional[PromptSettings] = None,
+        hyperparameters: Optional[Dict] = None,
+        resources: Optional[ResourceConfiguration] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._data_generation_type = data_generation_type
+        self._data_generation_task_type = data_generation_task_type
+        self._teacher_model_endpoint_connection = teacher_model_endpoint_connection
+        self._student_model = student_model
+        self._training_data = training_data
+        self._validation_data = validation_data
+        self._teacher_model_settings = teacher_model_settings
+        self._prompt_settings = prompt_settings
+        self._hyperparameters = hyperparameters
+        self._resources = resources
+
+        if self._training_data is None and self._data_generation_type == DataGenerationType.LABEL_GENERATION:
+            raise ValueError(
+                f"Training data can not be None when data generation type is set to "
+                f"{DataGenerationType.LABEL_GENERATION}."
+            )
+
+        if self._validation_data is None and self._data_generation_type == DataGenerationType.LABEL_GENERATION:
+            raise ValueError(
+                f"Validation data can not be None when data generation type is set to "
+                f"{DataGenerationType.LABEL_GENERATION}."
+            )
+
+        kwargs[TYPE] = JobType.DISTILLATION
+        self._outputs = kwargs.pop("outputs", None)
+        super().__init__(**kwargs)
+
+    @property
+    def data_generation_type(self) -> str:
+        """Get the type of synthetic data generation to perform.
+
+        :return: str representing the type of synthetic data generation to perform.
+        :rtype: str
+        """
+        return self._data_generation_type
+
+    @data_generation_type.setter
+    def data_generation_type(self, task: str) -> None:
+        """Set the data generation task.
+
+        :param task: The data generation task. Possible values include 'Label_Generation' and 'Data_Generation'.
+        :type task: str
+        """
+        self._data_generation_type = task
+
+    @property
+    def data_generation_task_type(self) -> str:
+        """Get the type of synthetic data to generate.
+
+        :return: str representing the type of synthetic data to generate.
+        :rtype: str
+        """
+        return self._data_generation_task_type
+
+    @data_generation_task_type.setter
+    def data_generation_task_type(self, task: str) -> None:
+        """Set the data generation type.
+
+        :param task: The data generation type. Possible values include 'nli', 'nlu_qa', 'conversational',
+                     'math', and 'summarization'.
+        :type task: str
+        """
+        self._data_generation_task_type = task
+
+    @property
+    def teacher_model_endpoint_connection(self) -> WorkspaceConnection:
+        """Get the endpoint connection of the teacher model to use for data generation.
+
+        :return: Endpoint connection
+        :rtype: WorkspaceConnection
+        """
+        return self._teacher_model_endpoint_connection
+
+    @teacher_model_endpoint_connection.setter
+    def teacher_model_endpoint_connection(self, connection: WorkspaceConnection) -> None:
+        """Set the endpoint information of the teacher model.
+
+        :param connection: Workspace connection
+        :type connection: WorkspaceConnection
+        """
+        self._teacher_model_endpoint_connection = connection
+
+    @property
+    def student_model(self) -> Input:
+        """Get the student model to be trained with synthetic data
+
+        :return: The student model to be finetuned
+        :rtype: Input
+        """
+        return self._student_model
+
+    @student_model.setter
+    def student_model(self, model: Input) -> None:
+        """Set the student model to be trained.
+
+        :param model: The model to use for finetuning
+        :type model: Input
+        """
+        self._student_model = model
+
+    @property
+    def training_data(self) -> Optional[Input]:
+        """Get the training data.
+
+        :return: Training data input
+        :rtype: typing.Optional[Input]
+        """
+        return self._training_data
+
+    @training_data.setter
+    def training_data(self, training_data: Optional[Input]) -> None:
+        """Set the training data.
+
+        :param training_data: Training data input
+        :type training_data: typing.Optional[Input]
+        """
+        self._training_data = training_data
+
+    @property
+    def validation_data(self) -> Optional[Input]:
+        """Get the validation data.
+
+        :return: Validation data input
+        :rtype: typing.Optional[Input]
+        """
+        return self._validation_data
+
+    @validation_data.setter
+    def validation_data(self, validation_data: Optional[Input]) -> None:
+        """Set the validation data.
+
+        :param validation_data: Validation data input
+        :type validation_data: typing.Optional[Input]
+        """
+        self._validation_data = validation_data
+
+    @property
+    def teacher_model_settings(self) -> Optional[TeacherModelSettings]:
+        """Get the teacher model settings.
+
+        :return: The settings for the teacher model to use.
+        :rtype: typing.Optional[TeacherModelSettings]
+        """
+        return self._teacher_model_settings
+
+    @property
+    def prompt_settings(self) -> Optional[PromptSettings]:
+        """Get the settings for the prompt.
+
+        :return: The settings for the prompt.
+        :rtype: typing.Optional[PromptSettings]
+        """
+        return self._prompt_settings
+
+    @property
+    def hyperparameters(self) -> Optional[Dict]:
+        """Get the finetuning hyperparameters.
+
+        :return: The finetuning hyperparameters.
+        :rtype: typing.Optional[typing.Dict]
+        """
+        return self._hyperparameters
+
+    @property
+    def resources(self) -> Optional[ResourceConfiguration]:
+        """Get the resources for data generation.
+
+        :return: The resources for data generation.
+        :rtype: typing.Optional[ResourceConfiguration]
+        """
+        return self._resources
+
+    @resources.setter
+    def resources(self, resource: Optional[ResourceConfiguration]) -> None:
+        """Set the resources for data generation.
+
+        :param resource: The resources for data generation.
+        :type resource: typing.Optional[ResourceConfiguration]
+        """
+        self._resources = resource
+
+    def set_teacher_model_settings(
+        self,
+        inference_parameters: Optional[Dict] = None,
+        endpoint_request_settings: Optional[EndpointRequestSettings] = None,
+    ):
+        """Set settings related to the teacher model.
+
+        :param inference_parameters: Settings the teacher model uses during inferencing.
+        :type inference_parameters: typing.Optional[typing.Dict]
+        :param endpoint_request_settings: Settings for inference requests to the endpoint
+        :type endpoint_request_settings: typing.Optional[EndpointRequestSettings]
+        """
+        self._teacher_model_settings = TeacherModelSettings(
+            inference_parameters=inference_parameters, endpoint_request_settings=endpoint_request_settings
+        )
+
+    def set_prompt_settings(self, prompt_settings: Optional[PromptSettings]):
+        """Set settings related to the system prompt used for generating data.
+
+        :param prompt_settings: Settings related to the system prompt used for generating data.
+        :type prompt_settings: typing.Optional[PromptSettings]
+        """
+        self._prompt_settings = prompt_settings if prompt_settings is not None else self._prompt_settings
+
+    def set_finetuning_settings(self, hyperparameters: Optional[Dict]):
+        """Set the hyperparamters for finetuning.
+
+        :param hyperparameters: The hyperparameters for finetuning.
+        :type hyperparameters: typing.Optional[typing.Dict]
+        """
+        self._hyperparameters = hyperparameters if hyperparameters is not None else self._hyperparameters
+
+    def _to_dict(self) -> Dict:
+        """Convert the object to a dictionary.
+
+        :return: dictionary representation of the object.
+        :rtype: typing.Dict
+        """
+        from azure.ai.ml._schema._distillation.distillation_job import DistillationJobSchema
+
+        schema_dict: dict = {}
+        schema_dict = DistillationJobSchema(context={BASE_PATH_CONTEXT_KEY: "./"}).dump(self)
+
+        return schema_dict
+
+    @classmethod
+    def _load_from_dict(
+        cls,
+        data: Dict,
+        context: Dict,
+        additional_message: str,
+        **kwargs: Any,
+    ) -> "DistillationJob":
+        """Load from a dictionary.
+
+        :param data: dictionary representation of the object.
+        :type data: typing.Dict
+        :param context: dictionary containing the context.
+        :type context: typing.Dict
+        :param additional_message: additional message to be added to the error message.
+        :type additional_message: str
+        :return: DistillationJob object.
+        :rtype: DistillationJob
+        """
+        from azure.ai.ml._schema._distillation.distillation_job import DistillationJobSchema
+
+        loaded_data = load_from_dict(DistillationJobSchema, data, context, additional_message, **kwargs)
+
+        training_data = loaded_data.get("training_data", None)
+        if isinstance(training_data, str):
+            loaded_data["training_data"] = Input(type="uri_file", path=training_data)
+
+        validation_data = loaded_data.get("validation_data", None)
+        if isinstance(validation_data, str):
+            loaded_data["validation_data"] = Input(type="uri_file", path=validation_data)
+
+        student_model = loaded_data.get("student_model", None)
+        if isinstance(student_model, str):
+            loaded_data["student_model"] = Input(type=AssetTypes.URI_FILE, path=student_model)
+
+        job_instance = DistillationJob(**loaded_data)
+        return job_instance
+
+    @classmethod
+    def _from_rest_object(cls, obj: RestJobBase) -> "DistillationJob":
+        """Convert a REST object to DistillationJob object.
+
+        :param obj: CustomModelFineTuningJob in Rest format.
+        :type obj: JobBase
+        :return: DistillationJob objects.
+        :rtype: DistillationJob
+        """
+        properties: RestFineTuningJob = obj.properties
+        finetuning_details: RestCustomModelFineTuningVertical = properties.fine_tuning_details
+
+        job_kwargs_dict = DistillationJob._filter_properties(properties=properties.properties)
+
+        job_args_dict = {
+            "id": obj.id,
+            "name": obj.name,
+            "description": properties.description,
+            "tags": properties.tags,
+            "properties": properties.properties,
+            "experiment_name": properties.experiment_name,
+            "services": properties.services,
+            "status": properties.status,
+            "creation_context": obj.system_data,
+            "display_name": properties.display_name,
+            "outputs": from_rest_data_outputs(properties.outputs),
+        }
+
+        distillation_job = cls(
+            student_model=finetuning_details.model,
+            training_data=finetuning_details.training_data,
+            validation_data=finetuning_details.validation_data,
+            hyperparameters=finetuning_details.hyper_parameters,
+            **job_kwargs_dict,
+            **job_args_dict,
+        )
+
+        distillation_job._restore_inputs()
+
+        return distillation_job
+
+    def _to_rest_object(self) -> "RestFineTuningJob":
+        """Convert DistillationJob object to a RestFineTuningJob object.
+
+        :return: REST object representation of this object.
+        :rtype: JobBase
+        """
+        distillation = RestCustomModelFineTuningVertical(
+            task_type="ChatCompletion",
+            model=self.student_model,
+            model_provider="Custom",
+            training_data=self.training_data,
+            validation_data=self.validation_data,
+            hyper_parameters=self._hyperparameters,
+        )
+
+        if isinstance(distillation.training_data, Input):
+            distillation.training_data = UriFileJobInput(uri=distillation.training_data.path)
+        if isinstance(distillation.validation_data, Input):
+            distillation.validation_data = UriFileJobInput(uri=distillation.validation_data.path)
+        if isinstance(distillation.model, Input):
+            distillation.model = MLFlowModelJobInput(uri=distillation.model.path)
+
+        self._add_distillation_properties(self.properties)
+
+        finetuning_job = RestFineTuningJob(
+            display_name=self.display_name,
+            description=self.description,
+            experiment_name=self.experiment_name,
+            services=self.services,
+            tags=self.tags,
+            properties=self.properties,
+            fine_tuning_details=distillation,
+            outputs=to_rest_data_outputs(self.outputs),
+        )
+
+        result = RestJobBase(properties=finetuning_job)
+        result.name = self.name
+
+        return result
+
+    @classmethod
+    def _load_from_rest(cls, obj: RestJobBase) -> "DistillationJob":
+        """Loads the rest object to a dict containing items to init the AutoMLJob objects.
+
+        :param obj: Azure Resource Manager resource envelope.
+        :type obj: JobBase
+        :raises ValidationException: task type validation error
+        :return: A DistillationJob
+        :rtype: DistillationJob
+        """
+        return DistillationJob._from_rest_object(obj)
+
+    # TODO: Remove once Distillation is added to MFE
+    def _add_distillation_properties(self, properties: Dict) -> None:
+        """Adds DistillationJob attributes to properties to pass into the FT Overloaded API property bag
+
+        :param properties: Current distillation properties
+        :type properties: typing.Dict
+        """
+        properties[AzureMLDistillationProperties.ENABLE_DISTILLATION] = True
+        properties[AzureMLDistillationProperties.DATA_GENERATION_TASK_TYPE] = self._data_generation_task_type.upper()
+        properties[f"{AzureMLDistillationProperties.TEACHER_MODEL}.endpoint_name"] = (
+            self._teacher_model_endpoint_connection.name
+        )
+
+        # Not needed for FT Overload API but additional info needed to convert from REST object to Distillation object
+        properties[AzureMLDistillationProperties.DATA_GENERATION_TYPE] = self._data_generation_type
+        properties[AzureMLDistillationProperties.CONNECTION_INFORMATION] = json.dumps(
+            self._teacher_model_endpoint_connection._to_dict()  # pylint: disable=protected-access
+        )
+
+        if self._prompt_settings:
+            for setting, value in self._prompt_settings.items():
+                if value is not None:
+                    properties[f"azureml.{setting.strip('_')}"] = value
+
+        if self._teacher_model_settings:
+            inference_settings = self._teacher_model_settings.inference_parameters
+            endpoint_settings = self._teacher_model_settings.endpoint_request_settings
+
+            if inference_settings:
+                for inference_key, value in inference_settings.items():
+                    if value is not None:
+                        properties[f"{AzureMLDistillationProperties.TEACHER_MODEL}.{inference_key}"] = value
+
+            if endpoint_settings:
+                for setting, value in endpoint_settings.items():
+                    if value is not None:
+                        properties[f"azureml.{setting.strip('_')}"] = value
+
+        if self._resources and self._resources.instance_type:
+            properties[f"{AzureMLDistillationProperties.INSTANCE_TYPE}.data_generation"] = self._resources.instance_type
+
+    # TODO: Remove once Distillation is added to MFE
+    @classmethod
+    def _filter_properties(cls, properties: Dict) -> Dict:
+        """Convert properties from REST object back to their original states.
+
+        :param properties: Properties from a REST object
+        :type properties: typing.Dict
+        :return: A dict that can be used to create a DistillationJob
+        :rtype: typing.Dict
+        """
+        inference_parameters = {}
+        endpoint_settings = {}
+        prompt_settings = {}
+        resources = {}
+        teacher_settings = {}
+        teacher_model_info = ""
+        for key, val in properties.items():
+            param = key.split(".")[-1]
+            if AzureMLDistillationProperties.TEACHER_MODEL in key and param != "endpoint_name":
+                inference_parameters[param] = val
+            elif AzureMLDistillationProperties.INSTANCE_TYPE in key:
+                resources[key.split(".")[1]] = val
+            elif AzureMLDistillationProperties.CONNECTION_INFORMATION in key:
+                teacher_model_info = val
+            else:
+                if param in EndpointSettings.VALID_SETTINGS:
+                    endpoint_settings[param] = val
+                elif param in PromptSettingKeys.VALID_SETTINGS:
+                    prompt_settings[param] = val
+
+        if inference_parameters:
+            teacher_settings["inference_parameters"] = inference_parameters
+        if endpoint_settings:
+            teacher_settings["endpoint_request_settings"] = EndpointRequestSettings(**endpoint_settings)  # type: ignore
+
+        return {
+            "data_generation_task_type": properties.get(AzureMLDistillationProperties.DATA_GENERATION_TASK_TYPE),
+            "data_generation_type": properties.get(AzureMLDistillationProperties.DATA_GENERATION_TYPE),
+            "teacher_model_endpoint_connection": WorkspaceConnection._load(  # pylint: disable=protected-access
+                data=json.loads(teacher_model_info)
+            ),
+            "teacher_model_settings": (
+                TeacherModelSettings(**teacher_settings) if teacher_settings else None  # type: ignore
+            ),
+            "prompt_settings": PromptSettings(**prompt_settings) if prompt_settings else None,
+            "resources": ResourceConfiguration(**resources) if resources else None,
+        }
+
+    def _restore_inputs(self) -> None:
+        """Restore UriFileJobInputs to JobInputs within data_settings."""
+        if isinstance(self.training_data, UriFileJobInput):
+            self.training_data = Input(type=AssetTypes.URI_FILE, path=self.training_data.uri)
+        if isinstance(self.validation_data, UriFileJobInput):
+            self.validation_data = Input(type=AssetTypes.URI_FILE, path=self.validation_data.uri)
+        if isinstance(self.student_model, MLFlowModelJobInput):
+            self.student_model = Input(type=AssetTypes.MLFLOW_MODEL, path=self.student_model.uri)
+
+    def __eq__(self, other: object) -> bool:
+        """Returns True if both instances have the same values.
+
+        This method check instances equality and returns True if both of
+        the instances have the same attributes with the same values.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        if not isinstance(other, DistillationJob):
+            return False
+        return (
+            super().__eq__(other)
+            and self.data_generation_type == other.data_generation_type
+            and self.data_generation_task_type == other.data_generation_task_type
+            and self.teacher_model_endpoint_connection.name == other.teacher_model_endpoint_connection.name
+            and self.student_model == other.student_model
+            and self.training_data == other.training_data
+            and self.validation_data == other.validation_data
+            and self.teacher_model_settings == other.teacher_model_settings
+            and self.prompt_settings == other.prompt_settings
+            and self.hyperparameters == other.hyperparameters
+            and self.resources == other.resources
+        )
+
+    def __ne__(self, other: object) -> bool:
+        """Check inequality between two DistillationJob objects.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        return not self.__eq__(other)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/endpoint_request_settings.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/endpoint_request_settings.py
new file mode 100644
index 00000000..89fb8015
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/endpoint_request_settings.py
@@ -0,0 +1,90 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from typing import Optional
+
+from azure.ai.ml._utils._experimental import experimental
+
+
+@experimental
+class EndpointRequestSettings:
+    def __init__(self, *, request_batch_size: Optional[int] = None, min_endpoint_success_ratio: Optional[float] = None):
+        """Initialize EndpointRequestSettings.
+
+        :param request_batch_size: The number of requests to send to the teacher model endpoint as a batch,
+            defaults to None
+        :type request_batch_size: typing.Optional[int], optional
+        :param min_endpoint_success_ratio: The ratio of (successful requests / total requests) needed for the
+            data generation step to be considered successful. Must be a value between 0 and 1 inclusive,
+            defaults to None
+        :type min_endpoint_success_ratio: typing.Optional[float], optional
+        """
+        self._request_batch_size = request_batch_size
+        self._min_endpoint_success_ratio = min_endpoint_success_ratio
+
+    @property
+    def request_batch_size(self) -> Optional[int]:
+        """Get the number of inference requests to send to the teacher model as a batch.
+
+        :return: The number of inference requests to send to the teacher model as a batch.
+        :rtype: typing.Optional[int]
+        """
+        return self._request_batch_size
+
+    @request_batch_size.setter
+    def request_batch_size(self, value: Optional[int]) -> None:
+        """Set the number of inference requests to send to the teacher model as a batch.
+
+        :param value: The number of inference requests to send to the teacher model as a batch.
+        :type value: typing.Optional[int]
+        """
+        self._request_batch_size = value
+
+    @property
+    def min_endpoint_success_ratio(self) -> Optional[float]:
+        """Get the minimum ratio of successful inferencing requests.
+
+        :return: The minimum ratio of successful inferencing requests.
+        :rtype: typing.Optional[float]
+        """
+        return self._min_endpoint_success_ratio
+
+    @min_endpoint_success_ratio.setter
+    def min_endpoint_success_ratio(self, ratio: Optional[float]) -> None:
+        """Set the minimum ratio of successful inferencing requests.
+
+        :param ratio: The minimum ratio of successful inferencing requests.
+        :type ratio: typing.Optional[float]
+        """
+        self._min_endpoint_success_ratio = ratio
+
+    def items(self):
+        return self.__dict__.items()
+
+    def __eq__(self, other: object) -> bool:
+        """Returns True if both instances have the same values.
+
+        This method check instances equality and returns True if both of
+            the instances have the same attributes with the same values.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        if not isinstance(other, EndpointRequestSettings):
+            return False
+        return (
+            self.request_batch_size == other.request_batch_size
+            and self.min_endpoint_success_ratio == other.min_endpoint_success_ratio
+        )
+
+    def __ne__(self, other: object) -> bool:
+        """Check inequality between two EndpointRequestSettings objects.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        return not self.__eq__(other)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/prompt_settings.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/prompt_settings.py
new file mode 100644
index 00000000..d74af748
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/prompt_settings.py
@@ -0,0 +1,138 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from typing import Optional
+
+from azure.ai.ml._utils._experimental import experimental
+
+
+@experimental
+class PromptSettings:
+    def __init__(
+        self,
+        *,
+        enable_chain_of_thought: bool = False,
+        enable_chain_of_density: bool = False,
+        max_len_summary: Optional[int] = None,
+        # custom_prompt: Optional[str] = None
+    ):
+        """Initialize PromptSettings.
+
+        :param enable_chain_of_thought: Whether or not to enable chain of thought which modifies the system prompt
+            used. Can be used for all `data_generation_task_type` values except `SUMMARIZATION`, defaults to False
+        :type enable_chain_of_thought: bool, optional
+        :param enable_chain_of_density: Whether or not to enable chain of density which modifies the system prompt
+            used. Can only be used for `data_generation_task_type` of `SUMMARIZATION`, defaults to False
+        :type enable_chain_of_density: bool, optional
+        :param max_len_summary: The maximum length of the summary generated for data_generation_task_type` of
+            `SUMMARIZATION`, defaults to None
+        :type max_len_summary: typing.Optional[int]
+        """
+        self._enable_chain_of_thought = enable_chain_of_thought
+        self._enable_chain_of_density = enable_chain_of_density
+        self._max_len_summary = max_len_summary
+        # self._custom_prompt = custom_prompt
+
+    @property
+    def enable_chain_of_thought(self) -> bool:
+        """Get whether or not chain of thought is enabled.
+
+        :return: Whether or not chain of thought is enabled.
+        :rtype: bool
+        """
+        return self._enable_chain_of_thought
+
+    @enable_chain_of_thought.setter
+    def enable_chain_of_thought(self, value: bool) -> None:
+        """Set chain of thought.
+
+        :param value: Whether or not chain of thought is enabled.
+        :type value: bool
+        """
+        self._enable_chain_of_thought = value
+
+    @property
+    def enable_chain_of_density(self) -> bool:
+        """Get whether or not chain of density is enabled.
+
+        :return: Whether or not chain of thought is enabled
+        :rtype: bool
+        """
+        return self._enable_chain_of_density
+
+    @enable_chain_of_density.setter
+    def enable_chain_of_density(self, value: bool) -> None:
+        """Set whether or not chain of thought is enabled.
+
+        :param value: Whether or not chain of thought is enabled
+        :type value: bool
+        """
+        self._enable_chain_of_density = value
+
+    @property
+    def max_len_summary(self) -> Optional[int]:
+        """The number of tokens to use for summarization.
+
+        :return: The number of tokens to use for summarization
+        :rtype: typing.Optional[int]
+        """
+        return self._max_len_summary
+
+    @max_len_summary.setter
+    def max_len_summary(self, length: Optional[int]) -> None:
+        """Set the number of tokens to use for summarization.
+
+        :param length: The number of tokens to use for summarization.
+        :type length: typing.Optional[int]
+        """
+        self._max_len_summary = length
+
+    # @property
+    # def custom_prompt(self) -> Optional[str]:
+    #     """Get the custom system prompt to use for inferencing.
+    #     :return: The custom prompt to use for inferencing.
+    #     :rtype: Optional[str]
+    #     """
+    #     return self._custom_prompt
+
+    # @custom_prompt.setter
+    # def custom_prompt(self, prompt: Optional[str]) -> None:
+    #     """Set the custom prompt to use for inferencing.
+
+    #     :param prompt: The custom prompt to use for inferencing.
+    #     :type prompt: Optional[str]
+    #     """
+    #     self._custom_prompt = prompt
+
+    def items(self):
+        return self.__dict__.items()
+
+    def __eq__(self, other: object) -> bool:
+        """Returns True if both instances have the same values.
+
+        This method check instances equality and returns True if both of
+            the instances have the same attributes with the same values.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        if not isinstance(other, PromptSettings):
+            return False
+        return (
+            self.enable_chain_of_thought == other.enable_chain_of_thought
+            and self.enable_chain_of_density == other.enable_chain_of_density
+            and self.max_len_summary == other.max_len_summary
+            # self.custom_prompt == other.custom_prompt
+        )
+
+    def __ne__(self, other: object) -> bool:
+        """Check inequality between two PromptSettings objects.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        return not self.__eq__(other)
diff --git a/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/teacher_model_settings.py b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/teacher_model_settings.py
new file mode 100644
index 00000000..481800de
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/azure/ai/ml/entities/_job/distillation/teacher_model_settings.py
@@ -0,0 +1,93 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from typing import Dict, Optional
+
+from azure.ai.ml._utils._experimental import experimental
+from azure.ai.ml.entities._job.distillation.endpoint_request_settings import EndpointRequestSettings
+
+
+@experimental
+class TeacherModelSettings:
+    def __init__(
+        self,
+        *,
+        inference_parameters: Optional[Dict] = None,
+        endpoint_request_settings: Optional[EndpointRequestSettings] = None,
+    ):
+        """Initialize TeacherModelSettings
+
+        :param inference_parameters: The inference parameters inferencing requests will use, defaults to None
+        :type inference_parameters: typing.Optional[typing.Dict], optional
+        :param endpoint_request_settings: The settings to use for the endpoint, defaults to None
+        :type endpoint_request_settings: typing.Optional[EndpointRequestSettings], optional
+        """
+        self._inference_parameters = inference_parameters
+        self._endpoint_request_settings = endpoint_request_settings
+
+    @property
+    def inference_parameters(self) -> Optional[Dict]:
+        """Get the inference parameters.
+
+        :return: The inference parameters.
+        :rtype: typing.Optional[typing.Dict]
+        """
+        return self._inference_parameters
+
+    @inference_parameters.setter
+    def inference_parameters(self, params: Optional[Dict]) -> None:
+        """Set the inference parameters.
+
+        :param params: Inference parameters.
+        :type params: typing.Optional[typing.Dict]
+        """
+        self._inference_parameters = params
+
+    @property
+    def endpoint_request_settings(self) -> Optional[EndpointRequestSettings]:
+        """Get the endpoint request settings.
+
+        :return: The endpoint request settings.
+        :rtype: typing.Optional[EndpointRequestSettings]
+        """
+        return self._endpoint_request_settings
+
+    @endpoint_request_settings.setter
+    def endpoint_request_settings(self, endpoint_settings: Optional[EndpointRequestSettings]) -> None:
+        """Set the endpoint request settings.
+
+        :param endpoint_settings: Endpoint request settings
+        :type endpoint_settings: typing.Optional[EndpointRequestSettings]
+        """
+        self._endpoint_request_settings = endpoint_settings
+
+    def items(self):
+        return self.__dict__.items()
+
+    def __eq__(self, other: object) -> bool:
+        """Returns True if both instances have the same values.
+
+        This method check instances equality and returns True if both of
+            the instances have the same attributes with the same values.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        if not isinstance(other, TeacherModelSettings):
+            return False
+        return (
+            self.inference_parameters == other.inference_parameters
+            and self.endpoint_request_settings == other.endpoint_request_settings
+        )
+
+    def __ne__(self, other: object) -> bool:
+        """Check inequality between two TeacherModelSettings objects.
+
+        :param other: Any object
+        :type other: object
+        :return: True or False
+        :rtype: bool
+        """
+        return not self.__eq__(other)