diff --git a/azureml/.gitignore b/azureml/.gitignore
index 3381960..43ffd7d 100644
--- a/azureml/.gitignore
+++ b/azureml/.gitignore
@@ -5,3 +5,4 @@ medimageinsight/exam-parameter-demo/data/pngs/
 medimageparse/examples
 *.csv
 *.json
+medimageparse/finetuning/CDD-CESM/
diff --git a/azureml/medimageparse/finetuning/medimageparse_finetuning.ipynb b/azureml/medimageparse/finetuning/medimageparse_finetuning.ipynb
new file mode 100644
index 0000000..8dd24be
--- /dev/null
+++ b/azureml/medimageparse/finetuning/medimageparse_finetuning.ipynb
@@ -0,0 +1,567 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1ca0f65c",
+   "metadata": {},
+   "source": [
+    "# MedImageParse Fine-tuning Pipeline\n",
+    "\n",
+    "This notebook demonstrates a complete end-to-end workflow for fine-tuning the MedImageParse model using Azure Machine Learning. The pipeline includes:\n",
+    "\n",
+    "1. **Data Management**: Uploading training data and configuration files to Azure ML\n",
+    "2. **Pipeline Execution**: Running the fine-tuning job on Azure ML compute\n",
+    "3. **Model Deployment**: Deploying the fine-tuned model as a managed online endpoint\n",
+    "4. **Validation**: Testing the deployed model with sample medical images\n",
+    "\n",
+    "## Prerequisites:\n",
+    "- Azure ML workspace configured\n",
+    "- Download training data to the same location as the medimageparse_finetuning.ipynb notebook --> https://huggingface.co/datasets/microsoft/BiomedParseData/blob/main/CDD-CESM.zip\n",
+    "- ⚠️ IMPORTANT: You need to have a huggingface account and be logged in for downloading the dataset!\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49ea4d12",
+   "metadata": {},
+   "source": [
+    "## Setup and Authentication\n",
+    "\n",
+    "This section handles the initial setup including:\n",
+    "- Importing required Azure ML SDK components and other dependencies\n",
+    "- Establishing authentication with Azure using DefaultAzureCredential\n",
+    "- Creating the MLClient instance for interacting with Azure ML services\n",
+    "\n",
+    "create a config.json file in the following format:\n",
+    "```\n",
+    "{\n",
+    "       \"subscription_id\": \"my-subscription-id\",\n",
+    "       \"resource_group\": \"my-resourcegroup-name\",\n",
+    "       \"workspace_name\": \"my-workspace-name\"\n",
+    "   }\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "14f94cac",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found the config file in: .\\config.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "from azure.ai.ml import MLClient, load_component\n",
+    "from azure.identity import DefaultAzureCredential\n",
+    "from azure.ai.ml.entities import Data, Environment, BuildContext, AmlCompute, Model\n",
+    "from azure.ai.ml.constants import AssetTypes\n",
+    "from azure.ai.ml.dsl import pipeline\n",
+    "import random\n",
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "from azure.ai.ml.entities import (\n",
+    "    ManagedOnlineEndpoint,\n",
+    "    ManagedOnlineDeployment,\n",
+    ")\n",
+    "import json\n",
+    "import base64\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from azure.core.exceptions import ResourceNotFoundError\n",
+    "\n",
+    "credentials = DefaultAzureCredential()\n",
+    "ml_client = MLClient.from_config(credentials)\n",
+    "ml_registry = MLClient(credential=credentials, registry_name=\"azureml\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7eb101cf",
+   "metadata": {},
+   "source": [
+    "# Upload Data\n",
+    "\n",
+    "This section creates and registers data assets in Azure ML that will be used for fine-tuning:\n",
+    "\n",
+    "- **training_data**: The CDD-CESM dataset containing medical images and corresponding masks for training. Expected folder structure:\n",
+    "\n",
+    "```\n",
+    ".\n",
+    "└── CCD-CESM/\n",
+    "    ├── test/\n",
+    "    │   └── xxx.png\n",
+    "    ├── test_mask/\n",
+    "    │   └── xxx.png\n",
+    "    ├── train/\n",
+    "    │   └── xxx.png\n",
+    "    ├── train_mask/\n",
+    "    │   └── xxx.png\n",
+    "    ├── test.json\n",
+    "    └── train.json\n",
+    "```\n",
+    "- **parameters**: Configuration file that defines training parameters, and other settings\n",
+    "\n",
+    "The finetuning data asset is registered as a URI_FOLDER type, whereas the parameters file is registered as URI_FILE type, making them reusable across different experiments and pipelines. Azure ML automatically versions these assets, allowing for reproducible experiments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4cc00b8e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "name = \"medimageparse\"\n",
+    "\n",
+    "# Create and upload training data folder\n",
+    "training_data = Data(\n",
+    "    path=\"CDD-CESM\",\n",
+    "    type=AssetTypes.URI_FOLDER,\n",
+    "    description=f\"{name} training data\",\n",
+    "    name=f\"{name}-training_data\",\n",
+    ")\n",
+    "training_data = ml_client.data.create_or_update(training_data)\n",
+    "print(\n",
+    "    f\"Data asset training_data created or updated.\",\n",
+    "    training_data.name,\n",
+    "    training_data.version,\n",
+    ")\n",
+    "\n",
+    "# Create and upload parameters file\n",
+    "parameters = Data(\n",
+    "    path=\"parameters.yaml\",\n",
+    "    type=AssetTypes.URI_FILE,\n",
+    "    description=f\"{name} parameters\",\n",
+    "    name=f\"{name}-parameters\",\n",
+    ")\n",
+    "parameters = ml_client.data.create_or_update(parameters)\n",
+    "print(\n",
+    "    f\"Data asset parameters created or updated.\",\n",
+    "    parameters.name,\n",
+    "    parameters.version,\n",
+    ")\n",
+    "\n",
+    "# Store references for later use\n",
+    "data_assets = {\n",
+    "    \"training_data\": training_data,\n",
+    "    \"parameters\": parameters,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eea8cef1",
+   "metadata": {},
+   "source": [
+    "# Create and run Pipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74bca164",
+   "metadata": {},
+   "source": [
+    "## Select / Create Compute\n",
+    "\n",
+    "This section manages the compute resources needed for fine-tuning:\n",
+    "\n",
+    "- **GPU Compute**: Uses Standard_NC40ads_H100_v5 instances with powerful H100 GPUs.\n",
+    "- **Conditional Creation**: Only creates new compute if it doesn't already exist\n",
+    "- **Resource Management**: Automatically scales down when not in use to minimize costs\n",
+    "\n",
+    "The H100 GPUs are specifically chosen for their excellent performance with large language models and computer vision tasks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f90fad6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compute_name = \"gpucluster\"\n",
+    "\n",
+    "try:\n",
+    "    compute = ml_client.compute.get(name=compute_name)\n",
+    "except ResourceNotFoundError:\n",
+    "    compute_cluster = AmlCompute(\n",
+    "        name=compute_name,\n",
+    "        description=\"GPU cluster compute for fine-tuning\",\n",
+    "        min_instances=1,\n",
+    "        max_instances=2,\n",
+    "        size=\"Standard_NC40ads_H100_v5\",\n",
+    "    )\n",
+    "    compute = ml_client.compute.begin_create_or_update(compute_cluster).result()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2aadf524",
+   "metadata": {},
+   "source": [
+    "## Pipeline Setup and Execution\n",
+    "\n",
+    "This section handles the core pipeline creation and execution:\n",
+    "\n",
+    "1. **Registry Access**: Connects to the Azure ML registry to access pre-trained models\n",
+    "2. **Data Asset loading**: Retrieves the latest version of the fine-tuning data assets\n",
+    "3. **Component Loading**: Retrieves the latest version of the fine-tuning component\n",
+    "4. **Pre-trained Model**: Fetches the latest MedImageParse model from the Azure ML registry\n",
+    "5. **Pipeline Definition**: Creates a pipeline that combines all components with proper input/output mapping\n",
+    "6. **Job Submission**: Submits the pipeline job to Azure ML with experiment tracking"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "05c71b16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get the pipeline component\n",
+    "finetune_pipeline_component = ml_registry.components.get(\n",
+    "    name=\"medimageparse_finetune\", label=\"latest\"\n",
+    ")\n",
+    "print(\n",
+    "    \"Component loaded\",\n",
+    "    finetune_pipeline_component.name,\n",
+    "    finetune_pipeline_component.version,\n",
+    ")\n",
+    "\n",
+    "# Get the latest MIP model\n",
+    "model = ml_registry.models.get(name=\"MedImageParse\", label=\"latest\")\n",
+    "\n",
+    "\n",
+    "@pipeline(name=\"medimageparse_finetuning\" + str(random.randint(0, 100000)))\n",
+    "def create_pipeline():\n",
+    "    mip_pipeline = finetune_pipeline_component(\n",
+    "        pretrained_mlflow_model=model.id,\n",
+    "        data=data_assets[\"training_data\"].id,\n",
+    "        config=data_assets[\"parameters\"].id,\n",
+    "    )\n",
+    "    return {\"mlflow_model_folder\": mip_pipeline.outputs.mlflow_model_folder}\n",
+    "\n",
+    "\n",
+    "pipeline_object = create_pipeline()\n",
+    "pipeline_object.compute = compute.name\n",
+    "pipeline_object.settings.continue_on_step_failure = False\n",
+    "pipeline_job = ml_client.jobs.create_or_update(\n",
+    "    pipeline_object, experiment_name=\"medimageparse_finetune_experiment\"\n",
+    ")\n",
+    "pipeline_job_run_id = pipeline_job.name\n",
+    "pipeline_job"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d34c48e3",
+   "metadata": {},
+   "source": [
+    "### Monitor Pipeline Job\n",
+    "\n",
+    "This cell displays the pipeline job details including:\n",
+    "- Job status and progress\n",
+    "- Links to view the job in Azure ML Studio\n",
+    "- Job ID for future reference\n",
+    "- Real-time updates on training progress\n",
+    "\n",
+    "You can click on the Studio link to monitor training metrics, logs, and resource utilization in real-time."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50165894",
+   "metadata": {},
+   "source": [
+    "# Deploy Fine-tuned Model\n",
+    "\n",
+    "This section handles the deployment of the fine-tuned model as a managed online endpoint:\n",
+    "\n",
+    "## Key Steps:\n",
+    "1. **Model Registration**: Register the fine-tuned model from the pipeline output\n",
+    "2. **Endpoint Creation**: Create a managed online endpoint for real-time inference\n",
+    "3. **Deployment Configuration**: Set up the deployment with appropriate compute resources\n",
+    "4. **Resource Allocation**: Use GPU instances for optimal inference performance\n",
+    "\n",
+    "The deployment creates a REST API endpoint that can be called for real-time medical image segmentation and analysis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "5146f1ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found the config file in: .\\config.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run this cell if you reconnected to the notebook.\n",
+    "\n",
+    "from azure.ai.ml import MLClient\n",
+    "from azure.identity import DefaultAzureCredential\n",
+    "\n",
+    "credentials = DefaultAzureCredential()\n",
+    "ml_client = MLClient.from_config(credentials)\n",
+    "\n",
+    "if \"pipeline_job_run_id\" not in locals():\n",
+    "    ##  Retrieved by checking the json of the parent job in AzureML studio (under \"See all properties\") or in output of the cell where you started the job under \"Name\".\n",
+    "    pipeline_job_run_id = \"\"\n",
+    "\n",
+    "if not len(pipeline_job_run_id):\n",
+    "    raise ValueError(\n",
+    "        \"Your kernel may have died! You need to set the pipeline_job_run_id manually from the output above (job name), or from the experiment in AzureML portal.\"\n",
+    "    )\n",
+    "\n",
+    "pipeline_job = ml_client.jobs.get(name=pipeline_job_run_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2988156c",
+   "metadata": {},
+   "source": [
+    "## Model Registration and Endpoint Deployment\n",
+    "\n",
+    "This section performs the actual model registration and endpoint deployment:\n",
+    "\n",
+    "### Model Registration:\n",
+    "- **Output Path**: References the pipeline job output containing the fine-tuned model\n",
+    "- **MLflow Format**: Uses MLflow model format for easy deployment and versioning\n",
+    "- **Unique Naming**: Creates a unique model name combining project name and job ID\n",
+    "\n",
+    "### Endpoint Creation:\n",
+    "- **Managed Endpoint**: Creates a managed online endpoint for easy scaling and management\n",
+    "- **GPU Deployment**: Uses Standard_NC40ads_H100_v5 for optimal inference performance. Standard_NC24ads_A100_v4 would also work.\n",
+    "- **Single Instance**: Starts with 1 instance, can be scaled up based on demand\n",
+    "\n",
+    "⚠️ **Note**: This process can take 10-15 minutes to complete as Azure provisions the compute resources and deploys the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ac22b7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Check: endpoint medimageparse exists\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "....................................................................................................................................."
+     ]
+    }
+   ],
+   "source": [
+    "run_model = Model(\n",
+    "    path=f\"azureml://jobs/{pipeline_job.name}/outputs/mlflow_model_folder\",\n",
+    "    name=f\"MIP-{name}-{pipeline_job.name}\",\n",
+    "    description=\"Model created from run.\",\n",
+    "    type=AssetTypes.MLFLOW_MODEL,\n",
+    ")\n",
+    "\n",
+    "# Register the Model\n",
+    "run_model = ml_client.models.create_or_update(run_model)\n",
+    "\n",
+    "# Create endpoint and deployment with the classification model\n",
+    "endpoint = ManagedOnlineEndpoint(name=name)\n",
+    "endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()\n",
+    "deployment = ManagedOnlineDeployment(\n",
+    "    name=name,\n",
+    "    endpoint_name=endpoint.name,\n",
+    "    model=run_model.id,\n",
+    "    instance_type=\"Standard_NC40ads_H100_v5\",\n",
+    "    instance_count=1,\n",
+    ")\n",
+    "deployment = ml_client.online_deployments.begin_create_or_update(deployment).result()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f861bf5",
+   "metadata": {},
+   "source": [
+    "# Validate Deployment\n",
+    "\n",
+    "This section tests the deployed model to ensure it's working correctly:\n",
+    "\n",
+    "## Test Process:\n",
+    "1. **Sample Data Preparation**: Load a test mammography image from the CDD-CESM dataset\n",
+    "2. **Request Formatting**: Convert the image to base64 encoding and create a properly formatted JSON request\n",
+    "3. **Text Prompt**: Include a text description to guide the model's segmentation task\n",
+    "4. **API Call**: Send the request to the deployed endpoint\n",
+    "5. **Results Visualization**: Display the original image alongside the generated segmentation masks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "dd04f63a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def read_image(image_path):\n",
+    "    with open(image_path, \"rb\") as f:\n",
+    "        return f.read()\n",
+    "\n",
+    "\n",
+    "sample_image = os.path.join(\"./CDD-CESM/test\", \"P3_L_CM_CC_mammography_breast.png\")\n",
+    "data = {\n",
+    "    \"input_data\": {\n",
+    "        \"columns\": [\"image\", \"text\"],\n",
+    "        \"index\": [0],\n",
+    "        \"data\": [\n",
+    "            [\n",
+    "                base64.encodebytes(read_image(sample_image)).decode(\"utf-8\"),\n",
+    "                \"neoplastic cells in breast pathology & inflammatory cells\",\n",
+    "            ]\n",
+    "        ],\n",
+    "    }\n",
+    "}\n",
+    "data_json = json.dumps(data)\n",
+    "\n",
+    "# Create request json\n",
+    "request_file_name = \"sample_request_data.json\"\n",
+    "with open(request_file_name, \"w\") as request_file:\n",
+    "    json.dump(data, request_file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "4e43e0eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def decode_json_to_array(json_encoded):\n",
+    "    \"\"\"Decode an image pixel data array in JSON.\n",
+    "    Return image pixel data as an array.\n",
+    "    \"\"\"\n",
+    "    # Parse the JSON string\n",
+    "    array_metadata = json.loads(json_encoded)\n",
+    "    # Extract Base64 string, shape, and dtype\n",
+    "    base64_encoded = array_metadata[\"data\"]\n",
+    "    shape = tuple(array_metadata[\"shape\"])\n",
+    "    dtype = np.dtype(array_metadata[\"dtype\"])\n",
+    "    # Decode Base64 to byte string\n",
+    "    array_bytes = base64.b64decode(base64_encoded)\n",
+    "    # Convert byte string back to NumPy array and reshape\n",
+    "    array = np.frombuffer(array_bytes, dtype=dtype).reshape(shape)\n",
+    "    return array\n",
+    "\n",
+    "\n",
+    "def plot_segmentation_masks(original_image, segmentation_masks):\n",
+    "    \"\"\"Plot a list of segmentation mask over an image.\"\"\"\n",
+    "    fig, ax = plt.subplots(1, len(segmentation_masks) + 1, figsize=(10, 5))\n",
+    "    ax[0].imshow(original_image)\n",
+    "    ax[0].set_title(\"Original Image\")\n",
+    "\n",
+    "    for i, mask in enumerate(segmentation_masks):\n",
+    "        ax[i + 1].imshow(original_image)\n",
+    "        ax[i + 1].set_title(f\"Mask {i+1}\")\n",
+    "        mask_temp = original_image.copy()\n",
+    "        mask_temp[mask > 128] = [255, 0, 0, 255]\n",
+    "        mask_temp[mask <= 128] = [0, 0, 0, 0]\n",
+    "        ax[i + 1].imshow(mask_temp, alpha=0.9)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "43b0dead",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "response = ml_client.online_endpoints.invoke(\n",
+    "    endpoint_name=\"medimageparse\",\n",
+    "    deployment_name=\"medimageparse\",\n",
+    "    request_file=request_file_name,\n",
+    ")\n",
+    "result_list = json.loads(response)\n",
+    "image_features_str = result_list[0][\"image_features\"]\n",
+    "image_features = decode_json_to_array(image_features_str)\n",
+    "\n",
+    "# Plot feature over image\n",
+    "sample_image_arr = plt.imread(sample_image)\n",
+    "plot_segmentation_masks(sample_image_arr, image_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "9925b08a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "..............................................................."
+     ]
+    }
+   ],
+   "source": [
+    "_ = ml_client.online_endpoints.begin_delete(name=endpoint.name).wait()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "mip_pipeline",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/azureml/medimageparse/finetuning/parameters.yaml b/azureml/medimageparse/finetuning/parameters.yaml
new file mode 100644
index 0000000..19b3d02
--- /dev/null
+++ b/azureml/medimageparse/finetuning/parameters.yaml
@@ -0,0 +1,13 @@
+datamodule:
+  dataloaders:
+    train:
+      batch_size: 4
+    validate:
+      batch_size: 4
+
+optimizer:
+  lr: 0.00002
+  weight_decay: 0.01
+
+trainer:
+  max_epochs: 10
\ No newline at end of file