diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/LICENSE b/data-platform/data-science/oracle-data-science/anomaly-detection/LICENSE
new file mode 100644
index 000000000..4c17d2626
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/LICENSE
@@ -0,0 +1,35 @@
+Copyright (c) 2026 Oracle and/or its affiliates.
+
+The Universal Permissive License (UPL), Version 1.0
+
+Subject to the condition set forth below, permission is hereby granted to any
+person obtaining a copy of this software, associated documentation and/or data
+(collectively the "Software"), free of charge and under any and all copyright
+rights in the Software, and any and all patent rights owned or freely
+licensable by each licensor hereunder covering either (i) the unmodified
+Software as contributed to or provided by such licensor, or (ii) the Larger
+Works (as defined below), to deal in both
+
+(a) the Software, and
+(b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+one is included with the Software (each a "Larger Work" to which the Software
+is contributed by such licensors),
+
+without restriction, including without limitation the rights to copy, create
+derivative works of, display, perform, and distribute the Software and make,
+use, sell, offer for sale, import, export, have made, and have sold the
+Software and the Larger Work(s), and to sublicense the foregoing rights on
+either these or other terms.
+
+This license is subject to the following condition:
+The above copyright notice and either this complete permission notice or at
+a minimum a reference to the UPL must be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/README.md b/data-platform/data-science/oracle-data-science/anomaly-detection/README.md
new file mode 100644
index 000000000..6902dd364
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/README.md
@@ -0,0 +1,58 @@
+# Overview
+
+This repository contains end-to-end anomaly detection projects demonstrating both supervised and unsupervised approaches using OCI Data Science and the ADS SDK.
+
+The projects cover key stages of the ML lifecycle, including data preparation, modeling, validation, model registration and deployment, deployment invocation, and monitoring workflows.
+
+The repository currently includes:
+
+* **Fraud Classification** – supervised fraud detection using classification models.
+* **Sales Unlabeled Anomaly Detection** – time-series anomaly detection using SARIMAX forecasting and prediction intervals.
+
+---
+
+# Projects
+
+## Fraud Classification
+
+This project demonstrates a supervised fraud detection workflow, including preprocessing, modeling, validation, model deployment, and deployment invocation.
+
+The project also demonstrates production-oriented concepts such as:
+1. Scikit-learn pipelines
+2. Custom deployment artifacts
+3. Feature engineering within the deployment pipeline, and handling high-cardinality categorical features.
+
+The deployed model can support both real-time and batch fraud monitoring workflows. The batch implementation is also covered in this project, the real time use case requires streaming tool, and not covered here.
+
+---
+
+## Sales Unlabeled Anomaly Detection
+
+This project demonstrates anomaly detection for a continuous unlabeled target variable using time-series regression and SARIMAX forecasting.
+
+The workflow includes exploratory analysis, time-series modeling and validation, anomaly detection using prediction intervals, custom model deployment, and production monitoring workflows integrated with OCI Monitoring.
+
+
+---
+
+# Environment
+
+Conda environment: `generalml_p311_cpu_x86_64_v1`
+
+Created: 2026
+
+---
+
+# Prerequisites
+
+* Access to OCI Data Science
+* Required IAM permissions
+* Familiarity with Python and machine learning workflows
+
+---
+
+# License
+
+Copyright (c) 2026 Oracle and/or its affiliates.
+
+Licensed under the Universal Permissive License (UPL), Version 1.0.
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/__init__.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/analysis.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/analysis.py
new file mode 100644
index 000000000..ecc25b30c
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/analysis.py
@@ -0,0 +1,178 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import shap
+from sklearn.metrics import roc_curve, roc_auc_score
+
+def compute_roc_metrics(y_true, y_probs):
+    """
+    Compute ROC curve metrics.
+    """
+    fpr, tpr, thresholds = roc_curve(y_true, y_probs)
+    auc = roc_auc_score(y_true, y_probs)
+
+    return fpr, tpr, thresholds, auc
+
+
+def plot_roc_curve(fpr, tpr, auc):
+    plt.figure(figsize=(7,5))
+
+    plt.plot(fpr, tpr, label=f"AUC = {auc:.3f}")
+    plt.plot([0,1], [0,1], linestyle="--")
+
+    plt.xlabel("False Positive Rate")
+    plt.ylabel("True Positive Rate")
+    plt.title("ROC Curve")
+    plt.legend()
+
+    plt.show()
+
+
+def get_feature_names(preprocessor, low_cardinality, high_cardinality, numeric_cols):
+
+    feature_names = []
+
+    if "onehot" in preprocessor.named_transformers_:
+        onehot_cols = preprocessor.named_transformers_["onehot"].get_feature_names_out(low_cardinality)
+        feature_names.extend(onehot_cols)
+
+    if "target" in preprocessor.named_transformers_:
+        feature_names.extend(high_cardinality)
+
+    feature_names.extend(numeric_cols)
+
+    return feature_names
+
+
+def plot_feature_importance(pipeline, feature_names, top_n=20):
+
+    model = pipeline.named_steps["model"]
+
+    importance = model.feature_importances_
+
+    indices = np.argsort(importance)[::-1]
+
+    sorted_features = [feature_names[i] for i in indices]
+    sorted_importance = importance[indices]
+
+    plt.figure(figsize=(10,6))
+
+    plt.barh(range(min(top_n, len(sorted_importance))), sorted_importance[:top_n])
+    plt.yticks(range(min(top_n, len(sorted_importance))), sorted_features[:top_n])
+
+    plt.gca().invert_yaxis()
+
+    plt.xlabel("Feature Importance")
+    plt.title(f"Top {top_n} Feature Importances")
+
+    plt.show()
+
+
+
+def compute_shap_values(pipeline, X_train):
+
+    model = pipeline.named_steps["model"]
+    preprocessor = pipeline.named_steps["preprocess"]
+
+    X_transformed = preprocessor.transform(X_train)
+
+    explainer = shap.TreeExplainer(model)
+
+    shap_values = explainer.shap_values(X_transformed)
+
+    return shap_values, X_transformed
+
+
+def plot_shap_summary(shap_values, X_transformed, feature_names):
+
+    shap.summary_plot(
+        shap_values,
+        X_transformed,
+        feature_names=feature_names
+    )
+
+
+def plot_prop(df,var_x):
+    plt.figure(figsize=(8, 6))
+    fraud_counts = df[var_x].value_counts()
+    plt.pie(fraud_counts.values, labels=fraud_counts.index, autopct='%1.1f%%', startangle=90)
+    plt.title('Proportion of Fraud Categories')
+    plt.axis('equal')
+    plt.show()
+
+    print(f"Class distribution:")
+    print(fraud_counts)
+
+
+def plot_fraud_rate_by_category(df, top_n=5):
+    fraud_rate_by_cat = (df.groupby('category')['is_fraud']
+                           .mean()
+                           .sort_values(ascending=False))
+    top_n_cats = fraud_rate_by_cat.head(top_n) * 100
+    avg_fraud_rate = fraud_rate_by_cat.iloc[top_n:].mean() * 100
+
+    plot_data = top_n_cats.copy()
+    plot_data['Other avg'] = avg_fraud_rate
+
+    colors = ['steelblue'] * len(top_n_cats) + ['tomato']
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    plot_data.plot(kind='bar', ax=ax, color=colors, alpha=0.8, edgecolor='none')
+    ax.set_title(f'Fraud Rate (%) — Top {top_n} Categories vs Other Categories Average')
+    ax.set_xlabel('')
+    ax.set_ylabel('Fraud Rate (%)')
+    ax.tick_params(axis='x', rotation=30)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_fraud_by_hour(df):
+    fraud_by_hour = (df[df['is_fraud'] == 1]
+                     .groupby('hour')
+                     .size()
+                     .reindex(range(24), fill_value=0))
+
+    hours = fraud_by_hour.index.values
+    counts = fraud_by_hour.values
+    angles = np.deg2rad((hours / 24) * 360 - 90)
+    max_count = counts.max()
+    bar_heights = counts / max_count * 0.4
+
+    fig, ax = plt.subplots(figsize=(6, 6))
+    ax.set_aspect('equal')
+    ax.axis('off')
+    ax.add_patch(plt.Circle((0, 0), 0.5, color='lightgray', alpha=0.15))
+    ax.set_xlim(-1, 1)
+    ax.set_ylim(-1, 1)
+
+    for angle, height, count in zip(angles, bar_heights, counts):
+        x_start = 0.1 * np.cos(angle)
+        y_start = 0.1 * np.sin(angle)
+        x_end = (0.1 + height) * np.cos(angle)
+        y_end = (0.1 + height) * np.sin(angle)
+        color = plt.cm.Reds(0.4 + 0.6 * (count / max_count))
+        ax.plot([x_start, x_end], [y_start, y_end],
+                color=color, linewidth=6, solid_capstyle='round')
+
+    for h, label in zip([0, 6, 12, 18], ['12am', '6am', '12pm', '6pm']):
+        angle = np.deg2rad((h / 24) * 360 - 90)
+        ax.text(0.7 * np.cos(angle), 0.7 * np.sin(angle),
+                label, ha='center', va='center', fontsize=9, color='gray')
+
+    plt.title('Fraud by Hour of Day')
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_boxplot_by_fraud(df, column):
+    data = [df[df['is_fraud'] == 0][column].dropna(),
+            df[df['is_fraud'] == 1][column].dropna()]
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    ax.boxplot(data, labels=['Not Fraud', 'Fraud'], patch_artist=True,
+               boxprops=dict(facecolor='steelblue', alpha=0.6),
+               medianprops=dict(color='red', linewidth=2))
+    ax.set_title(f'{column} Distribution by Fraud Label')
+    ax.set_ylabel(column)
+    ax.set_xlabel('is_fraud')
+    plt.tight_layout()
+    plt.show()
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/automation/automation.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/automation/automation.ipynb
new file mode 100644
index 000000000..96d46d75d
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/automation/automation.ipynb
@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fb8ecc4a-849d-49a6-84eb-d7a1b4d724d3",
+   "metadata": {},
+   "source": [
+    "# Creating and running jobs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "13c91316-0f2a-44c3-86b0-22291a3acc51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ads.jobs import Job, DataScienceJob, PythonRuntime\n",
+    "from ads import set_auth\n",
+    "set_auth(\"resource_principal\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d48a5ddf-2e11-42e2-81c3-2ea5c801ba12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job = (\n",
+    "    Job(name=\"anomaly_detection_scoring v.3\")\n",
+    "    .with_infrastructure(\n",
+    "        DataScienceJob()\n",
+    "        .with_log_group_id(\"<group_id_ocid>\")\n",
+    "        .with_log_id(\"<log_id_ocid>\")\n",
+    "        .with_shape_name(\"VM.Standard.E4.Flex\")\n",
+    "        .with_shape_config_details(memory_in_gbs=4, ocpus=1)\n",
+    "        .with_block_storage_size(50) # minimus is 50\n",
+    "    )\n",
+    "    .with_runtime(\n",
+    "        PythonRuntime()\n",
+    "        .with_service_conda(\"generalml_p311_cpu_x86_64_v1\")\n",
+    "        .with_source(\"/home/datascience/code/anomaly_detection/fraud_detection/src/batch_inference.py\")\n",
+    "        .with_environment_variable(FILE_NAME=\"batch-inference/day1_df.csv\") \n",
+    "    )\n",
+    ")\n",
+    "job.create()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "30833c1d-d272-40a6-bd45-2eb199fedfbe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Job OCID: ocid1.datasciencejob.oc1.eu-frankfurt-1.amaaaaaaeicj2tia33ogfxj2cd3llscxalvrakalf6fykwqpexsojwxzo64a\n",
+      "Job Run OCID: ocid1.datasciencejobrun.oc1.eu-frankfurt-1.amaaaaaaeicj2tiagdvnf4a5dqvjwr2hhyifoowlpvmi3z2ubpb7n2un6vva\n",
+      "2026-03-25 11:57:45 - Job Run ACCEPTED\n",
+      "2026-03-25 11:57:55 - Job Run ACCEPTED, Infrastructure provisioning.\n",
+      "2026-03-25 11:59:39 - Job Run ACCEPTED, Job run bootstrap starting.\n",
+      "2026-03-25 12:01:39 - Job Run ACCEPTED, Job run bootstrap complete. Artifact execution starting.\n",
+      "2026-03-25 12:01:42 - Job Run IN_PROGRESS, Job run artifact execution in progress.\n",
+      "2026-03-25 11:59:57 - /bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\n",
+      "2026-03-25 11:59:57 - /bin/sh: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\n",
+      "2026-03-25 11:59:57 - /bin/sh: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\n",
+      "2026-03-25 11:59:57 - /bin/sh: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)\n",
+      "2026-03-25 12:01:46 - Output file: results/day1_prediction.csv\n",
+      "2026-03-25 12:01:46 - Input file:  batch-inference/day1.csv\n",
+      "2026-03-25 12:01:46 - Loaded 1000 rows\n",
+      "2026-03-25 12:02:14 - Scored 500/1000 rows\n",
+      "2026-03-25 12:02:43 - Scored 1000/1000 rows\n",
+      "2026-03-25 12:02:43 - Uploaded results/day1_prediction.csv to fraud-detection-bucket\n",
+      "2026-03-25 12:03:11 - Job Run SUCCEEDED, Job run artifact execution succeeded. Infrastructure de-provisioning.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "kind: jobRun\n",
+       "spec:\n",
+       "  id: ocid1.datasciencejobrun.oc1.eu-frankfurt-1.amaaaaaaeicj2tiagdvnf4a5dqvjwr2hhyifoowlpvmi3z2ubpb7n2un6vva\n",
+       "  infrastructure:\n",
+       "    kind: infrastructure\n",
+       "    spec:\n",
+       "      blockStorageSize: 50\n",
+       "      compartmentId: ocid1.compartment.oc1..aaaaaaaaenvaxcmsbmrio4gieevntz7ryuji6quq65rnbwjqtweahitw4dza\n",
+       "      displayName: day1\n",
+       "      jobInfrastructureType: ME_STANDALONE\n",
+       "      jobType: DEFAULT\n",
+       "      logGroupId: ocid1.loggroup.oc1.eu-frankfurt-1.amaaaaaaeicj2tia4cocgvb633rdxs332osruo2jscng5ohsdypaqtco7mwq\n",
+       "      logId: ocid1.log.oc1.eu-frankfurt-1.amaaaaaaeicj2tiakrkxk3iwvgopon364knrw44zrtw3coeaix2fp4ik7a2q\n",
+       "      projectId: ocid1.datascienceproject.oc1.eu-frankfurt-1.amaaaaaaeicj2tia3noqgbegva53whrsznt2oy7txmxjcm4lggskw7n7i2sq\n",
+       "      shapeConfigDetails:\n",
+       "        memoryInGBs: 4.0\n",
+       "        ocpus: 1.0\n",
+       "      shapeName: VM.Standard.E4.Flex\n",
+       "    type: dataScienceJob\n",
+       "  name: day1\n",
+       "  runtime:\n",
+       "    kind: runtime\n",
+       "    spec:\n",
+       "      conda:\n",
+       "        slug: generalml_p311_cpu_x86_64_v1\n",
+       "        type: service\n",
+       "      definedTags:\n",
+       "        Default_Tags:\n",
+       "          AutoStop: 'Yes'\n",
+       "          CostTrackingCompartment: Specialists\n",
+       "          CreatedBy: ocid1.datasciencenotebooksession.oc1.eu-frankfurt-1.amaaaaaaeicj2tia5kesm5xrcumc5fpc7kflmawra64gborapmu2w2dnxfgq\n",
+       "      entrypoint: batch_inference.py\n",
+       "      env:\n",
+       "      - name: FILE_NAME\n",
+       "        value: batch-inference/day1.csv\n",
+       "      maximumRuntimeInMinutes: 43200\n",
+       "      scriptPathURI: batch_inference\n",
+       "    type: python"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "job_run = job.run(\n",
+    "    name=\"day1\",\n",
+    "    env_var={'FILE_NAME': 'batch-inference/day1.csv'} # in every run we can change these values.\n",
+    ")\n",
+    "job_run.watch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8318b4fd-cf08-49bb-bad1-49785563947d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:generalml_p311_cpu_x86_64_v1]",
+   "language": "python",
+   "name": "conda-env-generalml_p311_cpu_x86_64_v1-py"
+  },
+  "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/automation/batch_inference.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/automation/batch_inference.py
new file mode 100644
index 000000000..fb0c079e8
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/automation/batch_inference.py
@@ -0,0 +1,80 @@
+import math
+import requests
+import pandas as pd
+import io
+import oci
+import os
+import ads
+from oci.auth.signers import get_resource_principals_signer
+
+ads.set_auth(auth='resource_principal')
+
+FILE_NAME = os.environ.get("FILE_NAME")
+
+base_name = os.path.basename(FILE_NAME)                       
+name_without_ext = os.path.splitext(base_name)[0]             
+output_filename = f"results/{name_without_ext}_prediction.csv"
+
+bucket = "your_bucket_name"
+endpoint = "your_endpoint"
+
+
+print(f"Input file:  {FILE_NAME}")
+print(f"Output file: {output_filename}")
+
+
+def load_data_from_oci(bucket, file):
+    signer = oci.auth.signers.get_resource_principals_signer()
+    client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)
+    
+    namespace = client.get_namespace().data
+    response = client.get_object(namespace, bucket, file)
+    df = pd.read_csv(io.BytesIO(response.data.content))
+    return df
+
+df = load_data_from_oci(bucket, FILE_NAME)
+print(f"Loaded {df.shape[0]} rows")
+
+def clean_payload(payload):
+    return {
+        k: (None if isinstance(v, float) and (math.isnan(v) or math.isinf(v)) else v)
+        for k, v in payload.items()
+    }
+
+def score_dataframe(df, endpoint):
+    signer = get_resource_principals_signer()
+    predictions = []
+    for _, row in df.iterrows():
+        payload = clean_payload(row.drop('is_fraud').to_dict())
+        response = requests.post(endpoint, json=payload, auth=signer)
+        fraud_prob = response.json()['prediction'][0]
+        predictions.append(round(fraud_prob))
+        if len(predictions) % 500 == 0:
+            print(f"Scored {len(predictions)}/{len(df)} rows")
+    return predictions
+
+preds = score_dataframe(df, endpoint)
+
+# ── Build results DataFrame ────────────────────────────────────────────────
+results_df = pd.DataFrame({
+    'Unnamed: 0': df['Unnamed: 0'].values,
+    'prediction': preds
+})
+
+# ── Upload results ─────────────────────────────────────────────────────────
+def upload_results(results_df, bucket, filename):
+    signer = oci.auth.signers.get_resource_principals_signer()
+    client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)
+    namespace = client.get_namespace().data
+    csv_buffer = io.BytesIO()
+    results_df.to_csv(csv_buffer, index=False)
+    csv_buffer.seek(0)
+    client.put_object(
+        namespace_name=namespace,
+        bucket_name=bucket,
+        object_name=filename,
+        put_object_body=csv_buffer.getvalue()
+    )
+    print(f"Uploaded {filename} to {bucket}")
+
+upload_results(results_df, bucket, output_filename)
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/config.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/config.py
new file mode 100644
index 000000000..a0bcac90f
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/config.py
@@ -0,0 +1,15 @@
+FEATURE_SET = [
+    'category','amt','gender','street','city','state',
+    'city_pop','job','age','hour','geo_dist' #,'iso_score'
+]
+
+LOW_CARD_THRESHOLD = 15
+
+PARAM_DIST = {
+    "model__n_estimators": [100,200,400],
+    "model__max_depth": [4,6,8],
+    "model__learning_rate": [0.01,0.05,0.1],
+    "model__subsample": [0.6,0.75,0.9],
+    "model__colsample_bytree": [0.6,0.75,0.9],
+    "model__min_child_weight": [2,3,5]
+}
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/data extraction/data_extraction.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/data extraction/data_extraction.ipynb
new file mode 100644
index 000000000..e562872a9
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/data extraction/data_extraction.ipynb	
@@ -0,0 +1,206 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91784411",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import oci \n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import oci\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "from oci.object_storage import UploadManager"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "99340d9c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1296675, 24)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_path='local_data_path'\n",
+    "df=pd.read_csv(data_path)\n",
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3e41dc21",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training set shape: (648337, 24)\n",
+      "Production set shape: (648338, 24)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Split the data into training and production sets\n",
+    "# Using 5% for training and 95% for production\n",
+    "train_df, prod_df = train_test_split(df, test_size=0.50, random_state=42)\n",
+    "\n",
+    "print(f\"Training set shape: {train_df.shape}\")\n",
+    "print(f\"Production set shape: {prod_df.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "91650612",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Class distribution:\n",
+      "is_fraud\n",
+      "0    644591\n",
+      "1      3746\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1. Proportion of fraud categories (class distribution)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "fraud_counts = train_df['is_fraud'].value_counts()\n",
+    "plt.pie(fraud_counts.values, labels=fraud_counts.index, autopct='%1.1f%%', startangle=90)\n",
+    "plt.title('Proportion of Fraud Categories')\n",
+    "plt.axis('equal')\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"Class distribution:\")\n",
+    "print(fraud_counts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a2df765e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = oci.config.from_file()\n",
+    "object_storage_client = oci.object_storage.ObjectStorageClient(config)\n",
+    "\n",
+    "namespace = object_storage_client.get_namespace().data\n",
+    "\n",
+    "compartment_id='compartment_ocid'\n",
+    "bucket_name = 'your_bucket_name' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c330dfc2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<oci.response.Response at 0x20649dde910>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "local_path_train='your_training_local_path'\n",
+    "file_name_train='training_data_fraud_detection_kaggle_600.csv'\n",
+    "\n",
+    "upload_manager = UploadManager(object_storage_client, allow_parallel_uploads=True)\n",
+    "upload_manager.upload_file(\n",
+    "    namespace_name=namespace,\n",
+    "    bucket_name=bucket_name,\n",
+    "    object_name=file_name_train,\n",
+    "    file_path=local_path_train\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d908efeb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<oci.response.Response at 0x20630442410>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "local_path_prod='your_production_local_path'\n",
+    "\n",
+    "file_name_prod='production_data_fraud_detection_kaggle_600.csv'\n",
+    "\n",
+    "upload_manager = UploadManager(object_storage_client, allow_parallel_uploads=True)\n",
+    "upload_manager.upload_file(\n",
+    "    namespace_name=namespace,\n",
+    "    bucket_name=bucket_name,\n",
+    "    object_name=file_name_prod,\n",
+    "    file_path=local_path_prod\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/data.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/data.py
new file mode 100644
index 000000000..4097f2a97
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/data.py
@@ -0,0 +1,38 @@
+import oci, io
+import pandas as pd
+from config import LOW_CARD_THRESHOLD
+
+def load_data_from_oci(bucket, file):
+    try:
+        config = oci.config.from_file()
+        client = oci.object_storage.ObjectStorageClient(config)
+    except oci.exceptions.ConfigFileNotFound:
+        signer = oci.auth.signers.get_resource_principals_signer()
+        client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)
+    
+    namespace = client.get_namespace().data
+    response = client.get_object(namespace, bucket, file)
+    df = pd.read_csv(io.BytesIO(response.data.content))
+    return df
+    
+# def load_data_from_oci(bucket, file):
+
+#     config = oci.config.from_file()
+#     client = oci.object_storage.ObjectStorageClient(config)
+
+#     namespace = client.get_namespace().data
+#     response = client.get_object(namespace, bucket, file)
+
+#     df = pd.read_csv(io.BytesIO(response.data.content))
+
+#     return df
+
+def split_column_types(df):
+
+    numeric_cols = df.select_dtypes(include=["int64","float64"]).columns.tolist()
+    categorical_cols = df.select_dtypes(include=["object","category"]).columns.tolist()
+
+    low_card = [c for c in categorical_cols if df[c].nunique() <= LOW_CARD_THRESHOLD]
+    high_card = [c for c in categorical_cols if df[c].nunique() > LOW_CARD_THRESHOLD]
+
+    return numeric_cols, low_card, high_card
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/example for customized artifacts files/runtime.yaml b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/example for customized artifacts files/runtime.yaml
new file mode 100644
index 000000000..5c6feeebf
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/example for customized artifacts files/runtime.yaml	
@@ -0,0 +1,23 @@
+
+MODEL_ARTIFACT_VERSION: '3.0'
+MODEL_DEPLOYMENT:
+  INFERENCE_CONDA_ENV:
+    INFERENCE_ENV_PATH: 'oci://pub-conda-env@fro8fl9kuqli/conda_environments/cpu/General Machine Learning for CPUs on Python 3.11/1.0/generalml_p311_cpu_x86_64_v1'
+    INFERENCE_ENV_SLUG: ''
+    INFERENCE_ENV_TYPE: ''
+    INFERENCE_PYTHON_VERSION: '3.11'
+MODEL_PROVENANCE:
+  PROJECT_OCID: ''
+  TENANCY_OCID: ''
+  TRAINING_CODE:
+    ARTIFACT_DIRECTORY: /home/datascience/code/anomaly_detection/fraud_detection/sklearn_artifact_dir4
+  TRAINING_COMPARTMENT_OCID: ''
+  TRAINING_CONDA_ENV:
+    TRAINING_ENV_PATH: ''
+    TRAINING_ENV_SLUG: ''
+    TRAINING_ENV_TYPE: ''
+    TRAINING_PYTHON_VERSION: ''
+  TRAINING_REGION: ''
+  TRAINING_RESOURCE_OCID: ''
+  USER_OCID: ''
+  VM_IMAGE_INTERNAL_ID: ''
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/example for customized artifacts files/score.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/example for customized artifacts files/score.py
new file mode 100644
index 000000000..79e0c80ad
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/example for customized artifacts files/score.py	
@@ -0,0 +1,174 @@
+# score.py 1.0 generated by ADS 2.14.3 on 20260506_174024
+import json
+import os
+import cloudpickle
+import pandas as pd
+import numpy as np
+from functools import lru_cache
+
+
+model_name = 'model.pkl'
+
+
+"""
+   Inference script. This script is used for prediction by scoring server when schema is known.
+"""
+
+def feature_engineering(df):
+
+    df = df.copy()
+
+    df['dob'] = pd.to_datetime(df['dob'])
+    df['trans_date_trans_time'] = pd.to_datetime(df['trans_date_trans_time'])
+
+    df['age'] = (df['trans_date_trans_time'] - df['dob']) / pd.Timedelta(days=365.2425)
+
+    df['hour'] = df['trans_date_trans_time'].dt.hour
+
+    df['geo_dist'] = np.sqrt(
+        (df['lat'] - df['merch_lat'])**2 +
+        (df['long'] - df['merch_long'])**2
+    )
+
+    return df
+
+@lru_cache(maxsize=10)
+def load_model(model_file_name=model_name):
+    """
+    Loads model from the serialized format
+
+    Returns
+    -------
+    model:  a model instance on which predict API can be invoked
+    """
+    model_dir = os.path.dirname(os.path.realpath(__file__))
+    contents = os.listdir(model_dir)
+    if model_file_name in contents:
+        print(f'Start loading {model_file_name} from model directory {model_dir} ...')
+        with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), model_file_name), "rb") as file:
+            loaded_model = cloudpickle.load(file)
+
+        print("Model is successfully loaded.")
+        return loaded_model
+    else:
+        raise Exception(f'{model_file_name} is not found in model directory {model_dir}')
+
+@lru_cache(maxsize=1)
+def fetch_data_type_from_schema(input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
+    """
+    Returns data type information fetch from input_schema.json.
+
+    Parameters
+    ----------
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data_type: data type fetch from input_schema.json.
+
+    """
+    data_type = {}
+    if os.path.exists(input_schema_path):
+        schema = json.load(open(input_schema_path))
+        for col in schema['schema']:
+            data_type[col['name']] = col['dtype']
+    else:
+        print("input_schema has to be passed in in order to recover the same data type. pass `X_sample` in `ads.model.framework.sklearn_model.SklearnModel.prepare` function to generate the input_schema. Otherwise, the data type might be changed after serialization/deserialization.")
+    return data_type
+
+def deserialize(data, input_schema_path):
+    """
+    Deserialize json serialization data to data in original type when sent to predict.
+
+    Parameters
+    ----------
+    data: serialized input data.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data: deserialized input data.
+
+    """
+
+    import base64
+    from io import BytesIO, StringIO  # added StringIO
+    if isinstance(data, bytes):
+        return data
+
+    data_type = data.get('data_type', '') if isinstance(data, dict) else ''
+    json_data = data.get('data', data) if isinstance(data, dict) else data
+
+    if "numpy.ndarray" in data_type:
+        load_bytes = BytesIO(base64.b64decode(json_data.encode('utf-8')))
+        return np.load(load_bytes, allow_pickle=True)
+    if "pandas.core.series.Series" in data_type:
+        return pd.Series(json_data)
+    if "pandas.core.frame.DataFrame" in data_type or isinstance(json_data, str):
+#        return pd.read_json(json_data, dtype=fetch_data_type_from_schema(input_schema_path))
+        return pd.read_json(StringIO(json_data), dtype=fetch_data_type_from_schema(input_schema_path)) # add StringIO for better practice
+    if isinstance(json_data, dict):
+#        return pd.DataFrame.from_dict(json_data)
+        return pd.DataFrame([json_data])
+
+    return json_data
+
+
+
+def pre_inference(data, input_schema_path):
+    """
+    Preprocess data
+
+    Parameters
+    ----------
+    data: Data format as expected by the predict API of the core estimator.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data: Data format after any processing.
+
+    """
+    return deserialize(data, input_schema_path)
+
+def post_inference(yhat):
+    """
+    Post-process the model results
+
+    Parameters
+    ----------
+    yhat: Data format after calling model.predict.
+
+    Returns
+    -------
+    yhat: Data format after any processing.
+
+    """
+    if isinstance(yhat, pd.core.frame.DataFrame):
+        yhat = yhat.values
+    if isinstance(yhat, np.ndarray):
+        yhat = yhat.tolist()
+    return yhat
+
+def predict(data, model=load_model(), input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
+    """
+    Returns prediction given the model and data to predict
+
+    Parameters
+    ----------
+    model: Model instance returned by load_model API.
+    data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Pandas DataFrame.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    predictions: Output from scoring server
+        Format: {'prediction': output from model.predict method}
+
+    """
+    features = pre_inference(data, input_schema_path)
+    features = feature_engineering(features) # added to apply the customization
+    yhat = post_inference(
+        model.predict(features)
+    )
+    return {'prediction': yhat}
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/feature.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/feature.py
new file mode 100644
index 000000000..7317f3f77
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/feature.py
@@ -0,0 +1,45 @@
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import IsolationForest
+
+def feature_engineering(df):
+
+    df = df.copy()
+
+    df['dob'] = pd.to_datetime(df['dob'])
+    df['trans_date_trans_time'] = pd.to_datetime(df['trans_date_trans_time'])
+
+    df['age'] = (df['trans_date_trans_time'] - df['dob']) / pd.Timedelta(days=365.2425)
+
+    df['hour'] = df['trans_date_trans_time'].dt.hour
+
+    df['geo_dist'] = np.sqrt(
+        (df['lat'] - df['merch_lat'])**2 +
+        (df['long'] - df['merch_long'])**2
+    )
+
+    return df
+
+
+def fit_iso_forest(X_train):
+
+    numeric_cols = X_train.select_dtypes(include=["int64","float64"]).columns
+
+    iso = IsolationForest(
+        n_estimators=100,
+        contamination=0.01,
+        random_state=42
+    )
+
+    iso.fit(X_train[numeric_cols])
+
+    return iso, numeric_cols
+
+
+def add_iso_score(df, iso, numeric_cols):
+
+    df = df.copy()
+
+    df['iso_score'] = iso.decision_function(df[numeric_cols])
+
+    return df
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/model.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/model.py
new file mode 100644
index 000000000..3c4d01f19
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/model.py
@@ -0,0 +1,67 @@
+from sklearn.model_selection import RandomizedSearchCV
+from sklearn.pipeline import Pipeline
+import xgboost as xgb
+from config import PARAM_DIST
+
+
+def build_model(scale_pos_weight_value):
+
+    model = xgb.XGBClassifier(
+
+        objective="binary:logistic",
+        tree_method="hist",
+        scale_pos_weight=scale_pos_weight_value,
+        random_state=42
+    )
+
+    return model
+
+
+def build_pipeline(preprocessor, model):
+
+    pipeline = Pipeline([
+        ("preprocess", preprocessor),
+        ("model", model)
+    ])
+
+    return pipeline
+
+
+def find_hyper_params(pipeline, X_train, y_train):
+
+    search = RandomizedSearchCV(
+
+        pipeline,
+        PARAM_DIST,
+        n_iter=50,
+        scoring="roc_auc",
+        cv=3,
+        n_jobs=-1,
+        verbose=2,
+        random_state=42
+    )
+
+    search.fit(X_train, y_train)
+
+    best_params = {
+        k.replace("model__", ""): v
+        for k, v in search.best_params_.items()
+    }
+
+    return best_params
+
+def train_final_model(X_train, y_train, best_params, preprocessor,scale_pos_weight_value):
+    model = xgb.XGBClassifier(
+
+        objective="binary:logistic",
+        tree_method="hist",
+        scale_pos_weight=scale_pos_weight_value,
+        random_state=42,
+        **best_params
+    )
+
+    pipeline = build_pipeline(preprocessor, model)
+
+    pipeline.fit(X_train, y_train)
+
+    return pipeline
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/prepro.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/prepro.py
new file mode 100644
index 000000000..418d90bea
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/prepro.py
@@ -0,0 +1,25 @@
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from category_encoders import TargetEncoder
+
+def build_preprocessor(numeric_cols, low_card, high_card):
+
+    preprocessor = ColumnTransformer(
+
+        transformers=[
+
+            ("onehot",
+             OneHotEncoder(handle_unknown="ignore"),
+             low_card),
+
+            ("target",
+             TargetEncoder(handle_unknown="value"),
+             high_card),
+
+            ("num",
+             "passthrough",
+             numeric_cols)
+        ]
+    )
+
+    return preprocessor
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/train.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/train.ipynb
new file mode 100644
index 000000000..0b9fa0913
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/fraud_classification/train.ipynb
@@ -0,0 +1,3243 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4643bad1-164d-4d4f-aa06-39285eb36985",
+   "metadata": {},
+   "source": [
+    "# Fraud Detection"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "82c74a40-97e4-422c-9418-33e9ca6119be",
+   "metadata": {},
+   "source": [
+    "This notebook covers:\n",
+    "* Most stages of the ML lifecycle:\n",
+    "    * Data import, preprocessing, and exploration\n",
+    "    * Modeling and validation\n",
+    "    * Model registration and deployment\n",
+    "    * Deployment invocation\n",
+    "* Production-oriented model design:\n",
+    "    * Use of a scikit-learn pipeline\n",
+    "    * Custom deployment, where feature engineering is handled within the deployment (rather than ad hoc on the client side)\n",
+    "    * High cardinality of the categorical features\n",
+    "\n",
+    "This is the main notebook, and it relies on helper functions from additional scripts.\n",
+    "\n",
+    "Also, please note that the deployed model can be used for both real-time fraud monitoring and alerting, as well as batch monitoring. For batch monitoring, please refer to the automation folder.\n",
+    "\n",
+    "Runtime:\n",
+    "generalml_p311_cpu_x86_64_v1\\\n",
+    "Additional libraries were installed, including category_encoders and seaborn\n",
+    "\n",
+    "Authour: Assaf Rabinowicz\\\n",
+    "Date: May 2026"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6a6327a-04bf-4b9c-b2b8-a32d83f790c5",
+   "metadata": {},
+   "source": [
+    "# Import packages and data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3f97e860-fcb9-47a2-a6ab-6c7599aad185",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import classification_report\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import os\n",
+    "\n",
+    "from config import FEATURE_SET\n",
+    "from feature import feature_engineering, add_iso_score, fit_iso_forest\n",
+    "from data import load_data_from_oci, split_column_types\n",
+    "from prepro import build_preprocessor\n",
+    "from model import build_model, build_pipeline, find_hyper_params, train_final_model\n",
+    "from analysis import compute_roc_metrics, get_feature_names, plot_feature_importance\n",
+    "from analysis import plot_roc_curve, plot_prop, plot_fraud_rate_by_category, plot_fraud_by_hour, plot_boxplot_by_fraud\n",
+    "from analysis import plot_shap_summary, compute_shap_values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4c70b9ba-d591-4040-9dce-24561a07f00f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import oci\n",
+    "import requests\n",
+    "from ads.model.generic_model import GenericModel\n",
+    "import ads\n",
+    "ads.set_auth(auth=\"resource_principal\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "48871664-9c1d-405e-84fd-bb75222f2284",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# data: https://www.kaggle.com/datasets/priyamchoksi/credit-card-transactions-dataset/data\n",
+    "# The data was split into two subsets which were stored in Object Storage, one of them is used here.\n",
+    "df = load_data_from_oci(\n",
+    "    \"fraud-detection-bucket\",\n",
+    "    \"training_data_fraud_detection_kaggle_600.csv\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e0c8538e-3bb3-4c6d-90dd-a3f18b7041d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "shape:  (648337, 24)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Unnamed: 0</th>\n",
+       "      <th>trans_date_trans_time</th>\n",
+       "      <th>cc_num</th>\n",
+       "      <th>merchant</th>\n",
+       "      <th>category</th>\n",
+       "      <th>amt</th>\n",
+       "      <th>first</th>\n",
+       "      <th>last</th>\n",
+       "      <th>gender</th>\n",
+       "      <th>street</th>\n",
+       "      <th>...</th>\n",
+       "      <th>long</th>\n",
+       "      <th>city_pop</th>\n",
+       "      <th>job</th>\n",
+       "      <th>dob</th>\n",
+       "      <th>trans_num</th>\n",
+       "      <th>unix_time</th>\n",
+       "      <th>merch_lat</th>\n",
+       "      <th>merch_long</th>\n",
+       "      <th>is_fraud</th>\n",
+       "      <th>merch_zipcode</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>684365</td>\n",
+       "      <td>2019-10-19 11:14:57</td>\n",
+       "      <td>581508178315</td>\n",
+       "      <td>fraud_Lynch Ltd</td>\n",
+       "      <td>shopping_pos</td>\n",
+       "      <td>131.60</td>\n",
+       "      <td>Michael</td>\n",
+       "      <td>Vargas</td>\n",
+       "      <td>M</td>\n",
+       "      <td>933 Martin Rapids</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-98.5673</td>\n",
+       "      <td>407</td>\n",
+       "      <td>Clothing/textile technologist</td>\n",
+       "      <td>1978-08-08</td>\n",
+       "      <td>d4eabf36041cd28680705e9464315fc0</td>\n",
+       "      <td>1350645297</td>\n",
+       "      <td>31.742311</td>\n",
+       "      <td>-97.657385</td>\n",
+       "      <td>0</td>\n",
+       "      <td>76634.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1149936</td>\n",
+       "      <td>2020-04-24 17:05:33</td>\n",
+       "      <td>343464013864032</td>\n",
+       "      <td>fraud_Swift PLC</td>\n",
+       "      <td>kids_pets</td>\n",
+       "      <td>57.89</td>\n",
+       "      <td>Jodi</td>\n",
+       "      <td>Foster</td>\n",
+       "      <td>F</td>\n",
+       "      <td>551 Zachary Freeway</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-78.0892</td>\n",
+       "      <td>6629</td>\n",
+       "      <td>Call centre manager</td>\n",
+       "      <td>1962-08-13</td>\n",
+       "      <td>984a53297467db6fe61d0f24385cf13b</td>\n",
+       "      <td>1366823133</td>\n",
+       "      <td>34.848964</td>\n",
+       "      <td>-78.966559</td>\n",
+       "      <td>0</td>\n",
+       "      <td>28384.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>716689</td>\n",
+       "      <td>2019-11-02 15:21:13</td>\n",
+       "      <td>30407675418785</td>\n",
+       "      <td>fraud_Beer-Jast</td>\n",
+       "      <td>kids_pets</td>\n",
+       "      <td>43.41</td>\n",
+       "      <td>Danielle</td>\n",
+       "      <td>Evans</td>\n",
+       "      <td>F</td>\n",
+       "      <td>76752 David Lodge Apt. 064</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-76.7361</td>\n",
+       "      <td>520</td>\n",
+       "      <td>Psychotherapist</td>\n",
+       "      <td>1991-10-13</td>\n",
+       "      <td>abf4b10688ee9113d59962edf57fea4b</td>\n",
+       "      <td>1351869673</td>\n",
+       "      <td>41.372683</td>\n",
+       "      <td>-77.053554</td>\n",
+       "      <td>0</td>\n",
+       "      <td>17771.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>452599</td>\n",
+       "      <td>2019-07-20 08:34:13</td>\n",
+       "      <td>3523843138706408</td>\n",
+       "      <td>fraud_Goodwin-Nitzsche</td>\n",
+       "      <td>grocery_pos</td>\n",
+       "      <td>105.59</td>\n",
+       "      <td>Grace</td>\n",
+       "      <td>Williams</td>\n",
+       "      <td>F</td>\n",
+       "      <td>28812 Charles Mill Apt. 628</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-86.9475</td>\n",
+       "      <td>1412</td>\n",
+       "      <td>Drilling engineer</td>\n",
+       "      <td>1970-11-20</td>\n",
+       "      <td>f4e672cbab8f2699dfb2ba1661335c67</td>\n",
+       "      <td>1342773253</td>\n",
+       "      <td>32.272346</td>\n",
+       "      <td>-87.328527</td>\n",
+       "      <td>0</td>\n",
+       "      <td>36773.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>805433</td>\n",
+       "      <td>2019-12-05 19:42:10</td>\n",
+       "      <td>30501624614310</td>\n",
+       "      <td>fraud_Lemke-Gutmann</td>\n",
+       "      <td>shopping_net</td>\n",
+       "      <td>8.81</td>\n",
+       "      <td>Amanda</td>\n",
+       "      <td>Smith</td>\n",
+       "      <td>F</td>\n",
+       "      <td>180 Graves Shore</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-81.2455</td>\n",
+       "      <td>302</td>\n",
+       "      <td>Magazine features editor</td>\n",
+       "      <td>1973-05-04</td>\n",
+       "      <td>2d7a8b9142a090601dfde837030006ce</td>\n",
+       "      <td>1354736530</td>\n",
+       "      <td>32.562262</td>\n",
+       "      <td>-82.115629</td>\n",
+       "      <td>0</td>\n",
+       "      <td>30471.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 24 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Unnamed: 0 trans_date_trans_time            cc_num                merchant  \\\n",
+       "0      684365   2019-10-19 11:14:57      581508178315         fraud_Lynch Ltd   \n",
+       "1     1149936   2020-04-24 17:05:33   343464013864032         fraud_Swift PLC   \n",
+       "2      716689   2019-11-02 15:21:13    30407675418785         fraud_Beer-Jast   \n",
+       "3      452599   2019-07-20 08:34:13  3523843138706408  fraud_Goodwin-Nitzsche   \n",
+       "4      805433   2019-12-05 19:42:10    30501624614310     fraud_Lemke-Gutmann   \n",
+       "\n",
+       "       category     amt     first      last gender  \\\n",
+       "0  shopping_pos  131.60   Michael    Vargas      M   \n",
+       "1     kids_pets   57.89      Jodi    Foster      F   \n",
+       "2     kids_pets   43.41  Danielle     Evans      F   \n",
+       "3   grocery_pos  105.59     Grace  Williams      F   \n",
+       "4  shopping_net    8.81    Amanda     Smith      F   \n",
+       "\n",
+       "                        street  ...     long city_pop  \\\n",
+       "0            933 Martin Rapids  ... -98.5673      407   \n",
+       "1          551 Zachary Freeway  ... -78.0892     6629   \n",
+       "2   76752 David Lodge Apt. 064  ... -76.7361      520   \n",
+       "3  28812 Charles Mill Apt. 628  ... -86.9475     1412   \n",
+       "4             180 Graves Shore  ... -81.2455      302   \n",
+       "\n",
+       "                             job         dob  \\\n",
+       "0  Clothing/textile technologist  1978-08-08   \n",
+       "1            Call centre manager  1962-08-13   \n",
+       "2                Psychotherapist  1991-10-13   \n",
+       "3              Drilling engineer  1970-11-20   \n",
+       "4       Magazine features editor  1973-05-04   \n",
+       "\n",
+       "                          trans_num   unix_time  merch_lat merch_long  \\\n",
+       "0  d4eabf36041cd28680705e9464315fc0  1350645297  31.742311 -97.657385   \n",
+       "1  984a53297467db6fe61d0f24385cf13b  1366823133  34.848964 -78.966559   \n",
+       "2  abf4b10688ee9113d59962edf57fea4b  1351869673  41.372683 -77.053554   \n",
+       "3  f4e672cbab8f2699dfb2ba1661335c67  1342773253  32.272346 -87.328527   \n",
+       "4  2d7a8b9142a090601dfde837030006ce  1354736530  32.562262 -82.115629   \n",
+       "\n",
+       "  is_fraud  merch_zipcode  \n",
+       "0        0        76634.0  \n",
+       "1        0        28384.0  \n",
+       "2        0        17771.0  \n",
+       "3        0        36773.0  \n",
+       "4        0        30471.0  \n",
+       "\n",
+       "[5 rows x 24 columns]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print('shape: ',df.shape)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "df7d7910-8ed8-4dc2-88cf-2513ea9ebd97",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Class distribution:\n",
+      "is_fraud\n",
+      "0    644591\n",
+      "1      3746\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "plot_prop(df,'is_fraud')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45f31ace-cbb8-4ab2-be0c-5f6e477393bb",
+   "metadata": {},
+   "source": [
+    "* A low rate of anomalies is inherent to this type of problem, making modeling particularly challenging.\n",
+    "* Several approaches can help address this issue, for example, we later assign higher weights to anomalous cases.\n",
+    "* However, the most effective way to improve model performance is to increase the size of the dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4b24e2f-2d20-41fb-b49c-68bee1290602",
+   "metadata": {},
+   "source": [
+    "# Data preprocessing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c959646b-6b03-44be-a4e6-56dad8ab30a7",
+   "metadata": {},
+   "source": [
+    "Feature engineering is particularly important in anomaly detection use cases, as it helps compensate for the scarcity of anomalous events.\n",
+    "\n",
+    "Features can be engineered either through domain-driven logic or by leveraging algorithmic transformations. In this case, we created three additional features:\n",
+    "* Cardholder age – derived from the date of birth and the transaction timestamp\n",
+    "* Transaction hour – extracted from the transaction timestamp (trans_date_trans_time)\n",
+    "* Distance between the cardholder and the merchant – computed using their geographic coordinates\n",
+    "\n",
+    "A commonly used algorithmic approach in anomaly detection is Isolation Forest"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "df236d36-b799-46b0-80f6-d9c01e6a1368",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = feature_engineering(df) # add the three new engineered features to the df\n",
+    "# Later, You can also add a feature based on Isolation Forest using the fit_iso_forest and add_iso_score functions in model.py, after defining X_train and numeric_cols."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f6885418-f225-4f2c-a37d-ecd816bc8035",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df.drop(columns=['is_fraud'])\n",
+    "y = df['is_fraud']\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y,\n",
+    "    test_size=0.2,\n",
+    "    stratify=y,\n",
+    "    random_state=42\n",
+    ")\n",
+    "scale_pos_weight_value = (len(y_train)-sum(y_train))/(sum(y_train)*10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "893572a6-a1d7-4c6d-97fa-afa0cbe85c42",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['street', 'city', 'state', 'job']\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_train = X_train[FEATURE_SET]\n",
+    "X_test = X_test[FEATURE_SET]\n",
+    "\n",
+    "numeric_cols, low_card, high_card = split_column_types(X_train)\n",
+    "print(high_card)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e5b53809-4ded-450e-bf1d-a01e82754f7e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Unnamed: 0', 'trans_date_trans_time', 'cc_num', 'merchant', 'category',\n",
+       "       'amt', 'first', 'last', 'gender', 'street', 'city', 'state', 'zip',\n",
+       "       'lat', 'long', 'city_pop', 'job', 'dob', 'trans_num', 'unix_time',\n",
+       "       'merch_lat', 'merch_long', 'is_fraud', 'merch_zipcode', 'age', 'hour',\n",
+       "       'geo_dist'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.columns"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c50d2ccc-664c-47ef-aa93-171dca5b6556",
+   "metadata": {},
+   "source": [
+    "# Data Exploration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4bc924bf-ff64-4c4e-84e5-a9dee0d3aaf2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_fraud_rate_by_category(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d553c8a6-2e9f-4773-8e6c-7c369b5524cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_fraud_by_hour(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "da3345e9-4ccd-4453-9bd6-8974f39918eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_boxplot_by_fraud(df, column='amt')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8979e640-b522-4c8d-bc34-ae6e49357261",
+   "metadata": {},
+   "source": [
+    "# Modeling"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c5de276-e8a8-486a-8015-631081c24c9e",
+   "metadata": {},
+   "source": [
+    "## Model pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5369382a-4eb8-43ca-8511-3d7986a80bdc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "preprocessor = build_preprocessor(numeric_cols, low_card, high_card) # data transformer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b269985e-4f74-48c7-8170-bcd0bd85f3f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = build_model(scale_pos_weight_value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a25a6815-5510-40a4-894c-d5329aabc417",
+   "metadata": {},
+   "source": [
+    "## Hyperparameters Selection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f28f2edc-b109-43f9-af49-4b585edd8eb4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fitting 3 folds for each of 50 candidates, totalling 150 fits\n"
+     ]
+    }
+   ],
+   "source": [
+    "pipeline = build_pipeline(preprocessor, model)\n",
+    "best_params = find_hyper_params(pipeline, X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "bc9f5b7b-897c-473f-b814-843c75661fd5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'subsample': 0.6, 'n_estimators': 400, 'min_child_weight': 3, 'max_depth': 8, 'learning_rate': 0.1, 'colsample_bytree': 0.6}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(best_params)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c838f56-4676-405d-88bc-efbd4d0d7c10",
+   "metadata": {},
+   "source": [
+    "## Final model pipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "bd580f8d-a1fd-4356-99f4-8a9e1a5d2367",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_pipeline = train_final_model(X_train, y_train, best_params, preprocessor,scale_pos_weight_value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "01a84943-7fa1-43f9-85fa-22efa70a758f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {\n",
+       "  /* Definition of color scheme common for light and dark mode */\n",
+       "  --sklearn-color-text: #000;\n",
+       "  --sklearn-color-text-muted: #666;\n",
+       "  --sklearn-color-line: gray;\n",
+       "  /* Definition of color scheme for unfitted estimators */\n",
+       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
+       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
+       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
+       "  --sklearn-color-unfitted-level-3: chocolate;\n",
+       "  /* Definition of color scheme for fitted estimators */\n",
+       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
+       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
+       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
+       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1.light {\n",
+       "  /* Specific color for light theme */\n",
+       "  --sklearn-color-text-on-default-background: black;\n",
+       "  --sklearn-color-background: white;\n",
+       "  --sklearn-color-border-box: black;\n",
+       "  --sklearn-color-icon: #696969;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1.dark {\n",
+       "  --sklearn-color-text-on-default-background: white;\n",
+       "  --sklearn-color-background: #111;\n",
+       "  --sklearn-color-border-box: white;\n",
+       "  --sklearn-color-icon: #878787;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 pre {\n",
+       "  padding: 0;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-hidden--visually {\n",
+       "  border: 0;\n",
+       "  clip: rect(1px 1px 1px 1px);\n",
+       "  clip: rect(1px, 1px, 1px, 1px);\n",
+       "  height: 1px;\n",
+       "  margin: -1px;\n",
+       "  overflow: hidden;\n",
+       "  padding: 0;\n",
+       "  position: absolute;\n",
+       "  width: 1px;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
+       "  border: 1px dashed var(--sklearn-color-line);\n",
+       "  margin: 0 0.4em 0.5em 0.4em;\n",
+       "  box-sizing: border-box;\n",
+       "  padding-bottom: 0.4em;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-container {\n",
+       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
+       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
+       "     so we also need the `!important` here to be able to override the\n",
+       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
+       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
+       "  display: inline-block !important;\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-parallel-item,\n",
+       "div.sk-serial,\n",
+       "div.sk-item {\n",
+       "  /* draw centered vertical line to link estimators */\n",
+       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
+       "  background-size: 2px 100%;\n",
+       "  background-repeat: no-repeat;\n",
+       "  background-position: center center;\n",
+       "}\n",
+       "\n",
+       "/* Parallel-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item::after {\n",
+       "  content: \"\";\n",
+       "  width: 100%;\n",
+       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
+       "  flex-grow: 1;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel {\n",
+       "  display: flex;\n",
+       "  align-items: stretch;\n",
+       "  justify-content: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
+       "  align-self: flex-end;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
+       "  align-self: flex-start;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
+       "  width: 0;\n",
+       "}\n",
+       "\n",
+       "/* Serial-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-serial {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "  align-items: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  padding-right: 1em;\n",
+       "  padding-left: 1em;\n",
+       "}\n",
+       "\n",
+       "\n",
+       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
+       "clickable and can be expanded/collapsed.\n",
+       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
+       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
+       "*/\n",
+       "\n",
+       "/* Pipeline and ColumnTransformer style (default) */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable {\n",
+       "  /* Default theme specific background. It is overwritten whether we have a\n",
+       "  specific estimator or a Pipeline/ColumnTransformer */\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable label */\n",
+       "#sk-container-id-1 label.sk-toggleable__label {\n",
+       "  cursor: pointer;\n",
+       "  display: flex;\n",
+       "  width: 100%;\n",
+       "  margin-bottom: 0;\n",
+       "  padding: 0.5em;\n",
+       "  box-sizing: border-box;\n",
+       "  text-align: center;\n",
+       "  align-items: center;\n",
+       "  justify-content: center;\n",
+       "  gap: 0.5em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label .caption {\n",
+       "  font-size: 0.6rem;\n",
+       "  font-weight: lighter;\n",
+       "  color: var(--sklearn-color-text-muted);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
+       "  /* Arrow on the left of the label */\n",
+       "  content: \"▸\";\n",
+       "  float: left;\n",
+       "  margin-right: 0.25em;\n",
+       "  color: var(--sklearn-color-icon);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable content - dropdown */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content {\n",
+       "  display: none;\n",
+       "  text-align: left;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
+       "  margin: 0.2em;\n",
+       "  border-radius: 0.25em;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
+       "  /* Expand drop-down */\n",
+       "  display: block;\n",
+       "  width: 100%;\n",
+       "  overflow: visible;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
+       "  content: \"▾\";\n",
+       "}\n",
+       "\n",
+       "/* Pipeline/ColumnTransformer-specific style */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific style */\n",
+       "\n",
+       "/* Colorize estimator box */\n",
+       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  /* The background is the default theme color */\n",
+       "  color: var(--sklearn-color-text-on-default-background);\n",
+       "}\n",
+       "\n",
+       "/* On hover, darken the color of the background */\n",
+       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Label box, darken color on hover, fitted */\n",
+       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator label */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  font-family: monospace;\n",
+       "  font-weight: bold;\n",
+       "  line-height: 1.2em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label-container {\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific */\n",
+       "#sk-container-id-1 div.sk-estimator {\n",
+       "  font-family: monospace;\n",
+       "  border: 1px dotted var(--sklearn-color-border-box);\n",
+       "  border-radius: 0.25em;\n",
+       "  box-sizing: border-box;\n",
+       "  margin-bottom: 0.5em;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "/* on hover */\n",
+       "#sk-container-id-1 div.sk-estimator:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
+       "\n",
+       "/* Common style for \"i\" and \"?\" */\n",
+       "\n",
+       ".sk-estimator-doc-link,\n",
+       "a:link.sk-estimator-doc-link,\n",
+       "a:visited.sk-estimator-doc-link {\n",
+       "  float: right;\n",
+       "  font-size: smaller;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "  border-radius: 1em;\n",
+       "  height: 1em;\n",
+       "  width: 1em;\n",
+       "  text-decoration: none !important;\n",
+       "  margin-left: 0.5em;\n",
+       "  text-align: center;\n",
+       "  /* unfitted */\n",
+       "  border: var(--sklearn-color-unfitted-level-3) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted,\n",
+       "a:link.sk-estimator-doc-link.fitted,\n",
+       "a:visited.sk-estimator-doc-link.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-0);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-0);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "/* Span, style for the box shown on hovering the info icon */\n",
+       ".sk-estimator-doc-link span {\n",
+       "  display: none;\n",
+       "  z-index: 9999;\n",
+       "  position: relative;\n",
+       "  font-weight: normal;\n",
+       "  right: .2ex;\n",
+       "  padding: .5ex;\n",
+       "  margin: .5ex;\n",
+       "  width: min-content;\n",
+       "  min-width: 20ex;\n",
+       "  max-width: 50ex;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  box-shadow: 2pt 2pt 4pt #999;\n",
+       "  /* unfitted */\n",
+       "  background: var(--sklearn-color-unfitted-level-0);\n",
+       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted span {\n",
+       "  /* fitted */\n",
+       "  background: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link:hover span {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link {\n",
+       "  float: right;\n",
+       "  font-size: 1rem;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "  border-radius: 1rem;\n",
+       "  height: 1rem;\n",
+       "  width: 1rem;\n",
+       "  text-decoration: none;\n",
+       "  /* unfitted */\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".estimator-table {\n",
+       "    font-family: monospace;\n",
+       "}\n",
+       "\n",
+       ".estimator-table summary {\n",
+       "    padding: .5rem;\n",
+       "    cursor: pointer;\n",
+       "}\n",
+       "\n",
+       ".estimator-table summary::marker {\n",
+       "    font-size: 0.7rem;\n",
+       "}\n",
+       "\n",
+       ".estimator-table details[open] {\n",
+       "    padding-left: 0.1rem;\n",
+       "    padding-right: 0.1rem;\n",
+       "    padding-bottom: 0.3rem;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table {\n",
+       "    margin-left: auto !important;\n",
+       "    margin-right: auto !important;\n",
+       "    margin-top: 0;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:nth-child(odd) {\n",
+       "    background-color: #fff;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:nth-child(even) {\n",
+       "    background-color: #f6f6f6;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:hover {\n",
+       "    background-color: #e0e0e0;\n",
+       "}\n",
+       "\n",
+       ".estimator-table table td {\n",
+       "    border: 1px solid rgba(106, 105, 104, 0.232);\n",
+       "}\n",
+       "\n",
+       "/*\n",
+       "    `table td`is set in notebook with right text-align.\n",
+       "    We need to overwrite it.\n",
+       "*/\n",
+       ".estimator-table table td.param {\n",
+       "    text-align: left;\n",
+       "    position: relative;\n",
+       "    padding: 0;\n",
+       "}\n",
+       "\n",
+       ".user-set td {\n",
+       "    color:rgb(255, 94, 0);\n",
+       "    text-align: left !important;\n",
+       "}\n",
+       "\n",
+       ".user-set td.value {\n",
+       "    color:rgb(255, 94, 0);\n",
+       "    background-color: transparent;\n",
+       "}\n",
+       "\n",
+       ".default td {\n",
+       "    color: black;\n",
+       "    text-align: left !important;\n",
+       "}\n",
+       "\n",
+       ".user-set td i,\n",
+       ".default td i {\n",
+       "    color: black;\n",
+       "}\n",
+       "\n",
+       "/*\n",
+       "    Styles for parameter documentation links\n",
+       "    We need styling for visited so jupyter doesn't overwrite it\n",
+       "*/\n",
+       "a.param-doc-link,\n",
+       "a.param-doc-link:link,\n",
+       "a.param-doc-link:visited {\n",
+       "    text-decoration: underline dashed;\n",
+       "    text-underline-offset: .3em;\n",
+       "    color: inherit;\n",
+       "    display: block;\n",
+       "    padding: .5em;\n",
+       "}\n",
+       "\n",
+       "/* \"hack\" to make the entire area of the cell containing the link clickable */\n",
+       "a.param-doc-link::before {\n",
+       "    position: absolute;\n",
+       "    content: \"\";\n",
+       "    inset: 0;\n",
+       "}\n",
+       "\n",
+       ".param-doc-description {\n",
+       "    display: none;\n",
+       "    position: absolute;\n",
+       "    z-index: 9999;\n",
+       "    left: 0;\n",
+       "    padding: .5ex;\n",
+       "    margin-left: 1.5em;\n",
+       "    color: var(--sklearn-color-text);\n",
+       "    box-shadow: .3em .3em .4em #999;\n",
+       "    width: max-content;\n",
+       "    text-align: left;\n",
+       "    max-height: 10em;\n",
+       "    overflow-y: auto;\n",
+       "\n",
+       "    /* unfitted */\n",
+       "    background: var(--sklearn-color-unfitted-level-0);\n",
+       "    border: thin solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       "/* Fitted state for parameter tooltips */\n",
+       ".fitted .param-doc-description {\n",
+       "    /* fitted */\n",
+       "    background: var(--sklearn-color-fitted-level-0);\n",
+       "    border: thin solid var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".param-doc-link:hover .param-doc-description {\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".copy-paste-icon {\n",
+       "    background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);\n",
+       "    background-repeat: no-repeat;\n",
+       "    background-size: 14px 14px;\n",
+       "    background-position: 0;\n",
+       "    display: inline-block;\n",
+       "    width: 14px;\n",
+       "    height: 14px;\n",
+       "    cursor: pointer;\n",
+       "}\n",
+       "</style><body><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>Pipeline(steps=[(&#x27;preprocess&#x27;,\n",
+       "                 ColumnTransformer(transformers=[(&#x27;onehot&#x27;,\n",
+       "                                                  OneHotEncoder(handle_unknown=&#x27;ignore&#x27;),\n",
+       "                                                  [&#x27;category&#x27;, &#x27;gender&#x27;]),\n",
+       "                                                 (&#x27;target&#x27;, TargetEncoder(),\n",
+       "                                                  [&#x27;street&#x27;, &#x27;city&#x27;, &#x27;state&#x27;,\n",
+       "                                                   &#x27;job&#x27;]),\n",
+       "                                                 (&#x27;num&#x27;, &#x27;passthrough&#x27;,\n",
+       "                                                  [&#x27;amt&#x27;, &#x27;city_pop&#x27;, &#x27;age&#x27;,\n",
+       "                                                   &#x27;geo_dist&#x27;])])),\n",
+       "                (&#x27;model&#x27;,\n",
+       "                 XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "                               colsample_bylevel=None, colsam...\n",
+       "                               feature_types=None, feature_weights=None,\n",
+       "                               gamma=None, grow_policy=None,\n",
+       "                               importance_type=None,\n",
+       "                               interaction_constraints=None, learning_rate=0.1,\n",
+       "                               max_bin=None, max_cat_threshold=None,\n",
+       "                               max_cat_to_onehot=None, max_delta_step=None,\n",
+       "                               max_depth=8, max_leaves=None, min_child_weight=3,\n",
+       "                               missing=nan, monotone_constraints=None,\n",
+       "                               multi_strategy=None, n_estimators=400,\n",
+       "                               n_jobs=None, num_parallel_tree=None, ...))])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>Pipeline</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html\">?<span>Documentation for Pipeline</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('steps',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=steps,-list%20of%20tuples\">\n",
+       "            steps\n",
+       "            <span class=\"param-doc-description\">steps: list of tuples<br><br>List of (name of step, estimator) tuples that are to be chained in<br>sequential order. To be compatible with the scikit-learn API, all steps<br>must define `fit`. All non-last steps must also define `transform`. See<br>:ref:`Combining Estimators <combining_estimators>` for more details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">[(&#x27;preprocess&#x27;, ...), (&#x27;model&#x27;, ...)]</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('transform_input',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=transform_input,-list%20of%20str%2C%20default%3DNone\">\n",
+       "            transform_input\n",
+       "            <span class=\"param-doc-description\">transform_input: list of str, default=None<br><br>The names of the :term:`metadata` parameters that should be transformed by the<br>pipeline before passing it to the step consuming it.<br><br>This enables transforming some input arguments to ``fit`` (other than ``X``)<br>to be transformed by the steps of the pipeline up to the step which requires<br>them. Requirement is defined via :ref:`metadata routing <metadata_routing>`.<br>For instance, this can be used to pass a validation set through the pipeline.<br><br>You can only set this if metadata routing is enabled, which you<br>can enable using ``sklearn.set_config(enable_metadata_routing=True)``.<br><br>.. versionadded:: 1.6</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('memory',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=memory,-str%20or%20object%20with%20the%20joblib.Memory%20interface%2C%20default%3DNone\">\n",
+       "            memory\n",
+       "            <span class=\"param-doc-description\">memory: str or object with the joblib.Memory interface, default=None<br><br>Used to cache the fitted transformers of the pipeline. The last step<br>will never be cached, even if it is a transformer. By default, no<br>caching is performed. If a string is given, it is the path to the<br>caching directory. Enabling caching triggers a clone of the transformers<br>before fitting. Therefore, the transformer instance given to the<br>pipeline cannot be inspected directly. Use the attribute ``named_steps``<br>or ``steps`` to inspect estimators within the pipeline. Caching the<br>transformers is advantageous when fitting is time consuming. See<br>:ref:`sphx_glr_auto_examples_neighbors_plot_caching_nearest_neighbors.py`<br>for an example on how to enable caching.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.pipeline.Pipeline.html#:~:text=verbose,-bool%2C%20default%3DFalse\">\n",
+       "            verbose\n",
+       "            <span class=\"param-doc-description\">verbose: bool, default=False<br><br>If True, the time elapsed while fitting each step will be printed as it<br>is completed.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div><div class=\"sk-serial\"><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>preprocess: ColumnTransformer</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html\">?<span>Documentation for preprocess: ColumnTransformer</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('transformers',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=transformers,-list%20of%20tuples\">\n",
+       "            transformers\n",
+       "            <span class=\"param-doc-description\">transformers: list of tuples<br><br>List of (name, transformer, columns) tuples specifying the<br>transformer objects to be applied to subsets of the data.<br><br>name : str<br>    Like in Pipeline and FeatureUnion, this allows the transformer and<br>    its parameters to be set using ``set_params`` and searched in grid<br>    search.<br>transformer : {'drop', 'passthrough'} or estimator<br>    Estimator must support :term:`fit` and :term:`transform`.<br>    Special-cased strings 'drop' and 'passthrough' are accepted as<br>    well, to indicate to drop the columns or to pass them through<br>    untransformed, respectively.<br>columns :  str, array-like of str, int, array-like of int,                 array-like of bool, slice or callable<br>    Indexes the data on its second axis. Integers are interpreted as<br>    positional columns, while strings can reference DataFrame columns<br>    by name.  A scalar string or int should be used where<br>    ``transformer`` expects X to be a 1d array-like (vector),<br>    otherwise a 2d array will be passed to the transformer.<br>    A callable is passed the input data `X` and can return any of the<br>    above. To select multiple columns by name or dtype, you can use<br>    :obj:`make_column_selector`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">[(&#x27;onehot&#x27;, ...), (&#x27;target&#x27;, ...), ...]</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('remainder',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=remainder,-%7B%27drop%27%2C%20%27passthrough%27%7D%20or%20estimator%2C%20default%3D%27drop%27\">\n",
+       "            remainder\n",
+       "            <span class=\"param-doc-description\">remainder: {'drop', 'passthrough'} or estimator, default='drop'<br><br>By default, only the specified columns in `transformers` are<br>transformed and combined in the output, and the non-specified<br>columns are dropped. (default of ``'drop'``).<br>By specifying ``remainder='passthrough'``, all remaining columns that<br>were not specified in `transformers`, but present in the data passed<br>to `fit` will be automatically passed through. This subset of columns<br>is concatenated with the output of the transformers. For dataframes,<br>extra columns not seen during `fit` will be excluded from the output<br>of `transform`.<br>By setting ``remainder`` to be an estimator, the remaining<br>non-specified columns will use the ``remainder`` estimator. The<br>estimator must support :term:`fit` and :term:`transform`.<br>Note that using this feature requires that the DataFrame columns<br>input at :term:`fit` and :term:`transform` have identical order.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;drop&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('sparse_threshold',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=sparse_threshold,-float%2C%20default%3D0.3\">\n",
+       "            sparse_threshold\n",
+       "            <span class=\"param-doc-description\">sparse_threshold: float, default=0.3<br><br>If the output of the different transformers contains sparse matrices,<br>these will be stacked as a sparse matrix if the overall density is<br>lower than this value. Use ``sparse_threshold=0`` to always return<br>dense.  When the transformed output consists of all dense data, the<br>stacked result will be dense, and this keyword will be ignored.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">0.3</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('n_jobs',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=n_jobs,-int%2C%20default%3DNone\">\n",
+       "            n_jobs\n",
+       "            <span class=\"param-doc-description\">n_jobs: int, default=None<br><br>Number of jobs to run in parallel.<br>``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.<br>``-1`` means using all processors. See :term:`Glossary <n_jobs>`<br>for more details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('transformer_weights',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=transformer_weights,-dict%2C%20default%3DNone\">\n",
+       "            transformer_weights\n",
+       "            <span class=\"param-doc-description\">transformer_weights: dict, default=None<br><br>Multiplicative weights for features per transformer. The output of the<br>transformer is multiplied by these weights. Keys are transformer names,<br>values the weights.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=verbose,-bool%2C%20default%3DFalse\">\n",
+       "            verbose\n",
+       "            <span class=\"param-doc-description\">verbose: bool, default=False<br><br>If True, the time elapsed while fitting each transformer will be<br>printed as it is completed.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose_feature_names_out',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=verbose_feature_names_out,-bool%2C%20str%20or%20Callable%5B%5Bstr%2C%20str%5D%2C%20str%5D%2C%20default%3DTrue\">\n",
+       "            verbose_feature_names_out\n",
+       "            <span class=\"param-doc-description\">verbose_feature_names_out: bool, str or Callable[[str, str], str], default=True<br><br>- If True, :meth:`ColumnTransformer.get_feature_names_out` will prefix<br>  all feature names with the name of the transformer that generated that<br>  feature. It is equivalent to setting<br>  `verbose_feature_names_out=\"{transformer_name}__{feature_name}\"`.<br>- If False, :meth:`ColumnTransformer.get_feature_names_out` will not<br>  prefix any feature names and will error if feature names are not<br>  unique.<br>- If ``Callable[[str, str], str]``,<br>  :meth:`ColumnTransformer.get_feature_names_out` will rename all the features<br>  using the name of the transformer. The first argument of the callable is the<br>  transformer name and the second argument is the feature name. The returned<br>  string will be the new feature name.<br>- If ``str``, it must be a string ready for formatting. The given string will<br>  be formatted using two field names: ``transformer_name`` and ``feature_name``.<br>  e.g. ``\"{feature_name}__{transformer_name}\"``. See :meth:`str.format` method<br>  from the standard library for more info.<br><br>.. versionadded:: 1.0<br><br>.. versionchanged:: 1.6<br>    `verbose_feature_names_out` can be a callable or a string to be formatted.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('force_int_remainder_cols',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=force_int_remainder_cols,-bool%2C%20default%3DFalse\">\n",
+       "            force_int_remainder_cols\n",
+       "            <span class=\"param-doc-description\">force_int_remainder_cols: bool, default=False<br><br>This parameter has no effect.<br><br>.. note::<br>    If you do not access the list of columns for the remainder columns<br>    in the `transformers_` fitted attribute, you do not need to set<br>    this parameter.<br><br>.. versionadded:: 1.5<br><br>.. versionchanged:: 1.7<br>   The default value for `force_int_remainder_cols` will change from<br>   `True` to `False` in version 1.7.<br><br>.. deprecated:: 1.7<br>   `force_int_remainder_cols` is deprecated and will be removed in 1.9.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;deprecated&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>onehot</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__onehot__\"><pre>[&#x27;category&#x27;, &#x27;gender&#x27;]</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>OneHotEncoder</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html\">?<span>Documentation for OneHotEncoder</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__onehot__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('categories',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=categories,-%27auto%27%20or%20a%20list%20of%20array-like%2C%20default%3D%27auto%27\">\n",
+       "            categories\n",
+       "            <span class=\"param-doc-description\">categories: 'auto' or a list of array-like, default='auto'<br><br>Categories (unique values) per feature:<br><br>- 'auto' : Determine categories automatically from the training data.<br>- list : ``categories[i]`` holds the categories expected in the ith<br>  column. The passed categories should not mix strings and numeric<br>  values within a single feature, and should be sorted in case of<br>  numeric values.<br><br>The used categories can be found in the ``categories_`` attribute.<br><br>.. versionadded:: 0.20</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;auto&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('drop',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=drop,-%7B%27first%27%2C%20%27if_binary%27%7D%20or%20an%20array-like%20of%20shape%20%28n_features%2C%29%2C%20%20%20%20%20%20%20%20%20%20%20%20%20default%3DNone\">\n",
+       "            drop\n",
+       "            <span class=\"param-doc-description\">drop: {'first', 'if_binary'} or an array-like of shape (n_features,),             default=None<br><br>Specifies a methodology to use to drop one of the categories per<br>feature. This is useful in situations where perfectly collinear<br>features cause problems, such as when feeding the resulting data<br>into an unregularized linear regression model.<br><br>However, dropping one category breaks the symmetry of the original<br>representation and can therefore induce a bias in downstream models,<br>for instance for penalized linear classification or regression models.<br><br>- None : retain all features (the default).<br>- 'first' : drop the first category in each feature. If only one<br>  category is present, the feature will be dropped entirely.<br>- 'if_binary' : drop the first category in each feature with two<br>  categories. Features with 1 or more than 2 categories are<br>  left intact.<br>- array : ``drop[i]`` is the category in feature ``X[:, i]`` that<br>  should be dropped.<br><br>When `max_categories` or `min_frequency` is configured to group<br>infrequent categories, the dropping behavior is handled after the<br>grouping.<br><br>.. versionadded:: 0.21<br>   The parameter `drop` was added in 0.21.<br><br>.. versionchanged:: 0.23<br>   The option `drop='if_binary'` was added in 0.23.<br><br>.. versionchanged:: 1.1<br>    Support for dropping infrequent categories.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('sparse_output',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=sparse_output,-bool%2C%20default%3DTrue\">\n",
+       "            sparse_output\n",
+       "            <span class=\"param-doc-description\">sparse_output: bool, default=True<br><br>When ``True``, it returns a :class:`scipy.sparse.csr_matrix`,<br>i.e. a sparse matrix in \"Compressed Sparse Row\" (CSR) format.<br><br>.. versionadded:: 1.2<br>   `sparse` was renamed to `sparse_output`</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('dtype',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=dtype,-number%20type%2C%20default%3Dnp.float64\">\n",
+       "            dtype\n",
+       "            <span class=\"param-doc-description\">dtype: number type, default=np.float64<br><br>Desired dtype of output.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&lt;class &#x27;numpy.float64&#x27;&gt;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('handle_unknown',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=handle_unknown,-%7B%27error%27%2C%20%27ignore%27%2C%20%27infrequent_if_exist%27%2C%20%27warn%27%7D%2C%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20default%3D%27error%27\">\n",
+       "            handle_unknown\n",
+       "            <span class=\"param-doc-description\">handle_unknown: {'error', 'ignore', 'infrequent_if_exist', 'warn'},                      default='error'<br><br>Specifies the way unknown categories are handled during :meth:`transform`.<br><br>- 'error' : Raise an error if an unknown category is present during transform.<br>- 'ignore' : When an unknown category is encountered during<br>  transform, the resulting one-hot encoded columns for this feature<br>  will be all zeros. In the inverse transform, an unknown category<br>  will be denoted as None.<br>- 'infrequent_if_exist' : When an unknown category is encountered<br>  during transform, the resulting one-hot encoded columns for this<br>  feature will map to the infrequent category if it exists. The<br>  infrequent category will be mapped to the last position in the<br>  encoding. During inverse transform, an unknown category will be<br>  mapped to the category denoted `'infrequent'` if it exists. If the<br>  `'infrequent'` category does not exist, then :meth:`transform` and<br>  :meth:`inverse_transform` will handle an unknown category as with<br>  `handle_unknown='ignore'`. Infrequent categories exist based on<br>  `min_frequency` and `max_categories`. Read more in the<br>  :ref:`User Guide <encoder_infrequent_categories>`.<br>- 'warn' : When an unknown category is encountered during transform<br>  a warning is issued, and the encoding then proceeds as described for<br>  `handle_unknown=\"infrequent_if_exist\"`.<br><br>.. versionchanged:: 1.1<br>    `'infrequent_if_exist'` was added to automatically handle unknown<br>    categories and infrequent categories.<br><br>.. versionadded:: 1.6<br>   The option `\"warn\"` was added in 1.6.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;ignore&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('min_frequency',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=min_frequency,-int%20or%20float%2C%20default%3DNone\">\n",
+       "            min_frequency\n",
+       "            <span class=\"param-doc-description\">min_frequency: int or float, default=None<br><br>Specifies the minimum frequency below which a category will be<br>considered infrequent.<br><br>- If `int`, categories with a smaller cardinality will be considered<br>  infrequent.<br><br>- If `float`, categories with a smaller cardinality than<br>  `min_frequency * n_samples`  will be considered infrequent.<br><br>.. versionadded:: 1.1<br>    Read more in the :ref:`User Guide <encoder_infrequent_categories>`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_categories',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=max_categories,-int%2C%20default%3DNone\">\n",
+       "            max_categories\n",
+       "            <span class=\"param-doc-description\">max_categories: int, default=None<br><br>Specifies an upper limit to the number of output features for each input<br>feature when considering infrequent categories. If there are infrequent<br>categories, `max_categories` includes the category representing the<br>infrequent categories along with the frequent categories. If `None`,<br>there is no limit to the number of output features.<br><br>.. versionadded:: 1.1<br>    Read more in the :ref:`User Guide <encoder_infrequent_categories>`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('feature_name_combiner',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=feature_name_combiner,-%22concat%22%20or%20callable%2C%20default%3D%22concat%22\">\n",
+       "            feature_name_combiner\n",
+       "            <span class=\"param-doc-description\">feature_name_combiner: \"concat\" or callable, default=\"concat\"<br><br>Callable with signature `def callable(input_feature, category)` that returns a<br>string. This is used to create feature names to be returned by<br>:meth:`get_feature_names_out`.<br><br>`\"concat\"` concatenates encoded feature name and category with<br>`feature + \"_\" + str(category)`.E.g. feature X with values 1, 6, 7 create<br>feature names `X_1, X_6, X_7`.<br><br>.. versionadded:: 1.3</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;concat&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>target</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__target__\"><pre>[&#x27;street&#x27;, &#x27;city&#x27;, &#x27;state&#x27;, &#x27;job&#x27;]</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>TargetEncoder</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__target__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">verbose</td>\n",
+       "            <td class=\"value\">0</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('cols',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">cols</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('drop_invariant',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">drop_invariant</td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('return_df',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">return_df</td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('handle_missing',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">handle_missing</td>\n",
+       "            <td class=\"value\">&#x27;value&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('handle_unknown',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">handle_unknown</td>\n",
+       "            <td class=\"value\">&#x27;value&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('min_samples_leaf',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">min_samples_leaf</td>\n",
+       "            <td class=\"value\">20</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('smoothing',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">smoothing</td>\n",
+       "            <td class=\"value\">10</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('hierarchy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">hierarchy</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" ><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>num</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__num__\"><pre>[&#x27;amt&#x27;, &#x27;city_pop&#x27;, &#x27;age&#x27;, &#x27;geo_dist&#x27;]</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-8\" type=\"checkbox\" ><label for=\"sk-estimator-id-8\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>passthrough</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"preprocess__num__\"><pre>passthrough</pre></div></div></div></div></div></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-9\" type=\"checkbox\" ><label for=\"sk-estimator-id-9\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>XGBClassifier</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier\">?<span>Documentation for XGBClassifier</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"model__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('objective',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=objective,-typing.Union%5Bstr%2C%20xgboost.sklearn._SklObjWProto%2C%20typing.Callable%5B%5Btyping.Any%2C%20typing.Any%5D%2C%20typing.Tuple%5Bnumpy.ndarray%2C%20numpy.ndarray%5D%5D%2C%20NoneType%5D\">\n",
+       "            objective\n",
+       "            <span class=\"param-doc-description\">objective: typing.Union[str, xgboost.sklearn._SklObjWProto, typing.Callable[[typing.Any, typing.Any], typing.Tuple[numpy.ndarray, numpy.ndarray]], NoneType]<br><br>Specify the learning task and the corresponding learning objective or a custom<br>objective function to be used.<br><br>For custom objective, see :doc:`/tutorials/custom_metric_obj` and<br>:ref:`custom-obj-metric` for more information, along with the end note for<br>function signatures.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;binary:logistic&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('base_score',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=base_score,-typing.Optional%5Bfloat%5D\">\n",
+       "            base_score\n",
+       "            <span class=\"param-doc-description\">base_score: typing.Optional[float]<br><br>The initial prediction score of all instances, global bias.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('booster',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">booster</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('callbacks',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=callbacks,-typing.Optional%5Btyping.List%5Bxgboost.callback.TrainingCallback%5D%5D\">\n",
+       "            callbacks\n",
+       "            <span class=\"param-doc-description\">callbacks: typing.Optional[typing.List[xgboost.callback.TrainingCallback]]<br><br>List of callback functions that are applied at end of each iteration.<br>It is possible to use predefined callbacks by using<br>:ref:`Callback API <callback_api>`.<br><br>.. note::<br><br>   States in callback are not preserved during training, which means callback<br>   objects can not be reused for multiple training sessions without<br>   reinitialization or deepcopy.<br><br>.. code-block:: python<br><br>    for params in parameters_grid:<br>        # be sure to (re)initialize the callbacks before each run<br>        callbacks = [xgb.callback.LearningRateScheduler(custom_rates)]<br>        reg = xgboost.XGBRegressor(**params, callbacks=callbacks)<br>        reg.fit(X, y)</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('colsample_bylevel',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=colsample_bylevel,-typing.Optional%5Bfloat%5D\">\n",
+       "            colsample_bylevel\n",
+       "            <span class=\"param-doc-description\">colsample_bylevel: typing.Optional[float]<br><br>Subsample ratio of columns for each level.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('colsample_bynode',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=colsample_bynode,-typing.Optional%5Bfloat%5D\">\n",
+       "            colsample_bynode\n",
+       "            <span class=\"param-doc-description\">colsample_bynode: typing.Optional[float]<br><br>Subsample ratio of columns for each split.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('colsample_bytree',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=colsample_bytree,-typing.Optional%5Bfloat%5D\">\n",
+       "            colsample_bytree\n",
+       "            <span class=\"param-doc-description\">colsample_bytree: typing.Optional[float]<br><br>Subsample ratio of columns when constructing each tree.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">0.6</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('device',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=device,-typing.Optional%5Bstr%5D\">\n",
+       "            device\n",
+       "            <span class=\"param-doc-description\">device: typing.Optional[str]<br><br>.. versionadded:: 2.0.0<br><br>Device ordinal, available options are `cpu`, `cuda`, and `gpu`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('early_stopping_rounds',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=early_stopping_rounds,-typing.Optional%5Bint%5D\">\n",
+       "            early_stopping_rounds\n",
+       "            <span class=\"param-doc-description\">early_stopping_rounds: typing.Optional[int]<br><br>.. versionadded:: 1.6.0<br><br>- Activates early stopping. Validation metric needs to improve at least once in<br>  every **early_stopping_rounds** round(s) to continue training.  Requires at<br>  least one item in **eval_set** in :py:meth:`fit`.<br><br>- If early stopping occurs, the model will have two additional attributes:<br>  :py:attr:`best_score` and :py:attr:`best_iteration`. These are used by the<br>  :py:meth:`predict` and :py:meth:`apply` methods to determine the optimal<br>  number of trees during inference. If users want to access the full model<br>  (including trees built after early stopping), they can specify the<br>  `iteration_range` in these inference methods. In addition, other utilities<br>  like model plotting can also use the entire model.<br><br>- If you prefer to discard the trees after `best_iteration`, consider using the<br>  callback function :py:class:`xgboost.callback.EarlyStopping`.<br><br>- If there's more than one item in **eval_set**, the last entry will be used for<br>  early stopping.  If there's more than one metric in **eval_metric**, the last<br>  metric will be used for early stopping.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('enable_categorical',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=enable_categorical,-bool\">\n",
+       "            enable_categorical\n",
+       "            <span class=\"param-doc-description\">enable_categorical: bool<br><br>See the same parameter of :py:class:`DMatrix` for details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('eval_metric',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=eval_metric,-typing.Union%5Bstr%2C%20typing.List%5Bstr%5D%2C%20typing.Callable%2C%20NoneType%5D\">\n",
+       "            eval_metric\n",
+       "            <span class=\"param-doc-description\">eval_metric: typing.Union[str, typing.List[str], typing.Callable, NoneType]<br><br>.. versionadded:: 1.6.0<br><br>Metric used for monitoring the training result and early stopping.  It can be a<br>string or list of strings as names of predefined metric in XGBoost (See<br>:doc:`/parameter`), one of the metrics in :py:mod:`sklearn.metrics`, or any<br>other user defined metric that looks like `sklearn.metrics`.<br><br>If custom objective is also provided, then custom metric should implement the<br>corresponding reverse link function.<br><br>Unlike the `scoring` parameter commonly used in scikit-learn, when a callable<br>object is provided, it's assumed to be a cost function and by default XGBoost<br>will minimize the result during early stopping.<br><br>For advanced usage on Early stopping like directly choosing to maximize instead<br>of minimize, see :py:obj:`xgboost.callback.EarlyStopping`.<br><br>See :doc:`/tutorials/custom_metric_obj` and :ref:`custom-obj-metric` for more<br>information.<br><br>.. code-block:: python<br><br>    from sklearn.datasets import load_diabetes<br>    from sklearn.metrics import mean_absolute_error<br>    X, y = load_diabetes(return_X_y=True)<br>    reg = xgb.XGBRegressor(<br>        tree_method=\"hist\",<br>        eval_metric=mean_absolute_error,<br>    )<br>    reg.fit(X, y, eval_set=[(X, y)])</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('feature_types',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=feature_types,-typing.Optional%5Btyping.Sequence%5Bstr%5D%5D\">\n",
+       "            feature_types\n",
+       "            <span class=\"param-doc-description\">feature_types: typing.Optional[typing.Sequence[str]]<br><br>.. versionadded:: 1.7.0<br><br>Used for specifying feature types without constructing a dataframe. See<br>:py:class:`DMatrix` for details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('feature_weights',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=feature_weights,-Optional%5BArrayLike%5D\">\n",
+       "            feature_weights\n",
+       "            <span class=\"param-doc-description\">feature_weights: Optional[ArrayLike]<br><br>Weight for each feature, defines the probability of each feature being selected<br>when colsample is being used.  All values must be greater than 0, otherwise a<br>`ValueError` is thrown.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('gamma',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=gamma,-typing.Optional%5Bfloat%5D\">\n",
+       "            gamma\n",
+       "            <span class=\"param-doc-description\">gamma: typing.Optional[float]<br><br>(min_split_loss) Minimum loss reduction required to make a further partition on<br>a leaf node of the tree.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('grow_policy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=grow_policy,-typing.Optional%5Bstr%5D\">\n",
+       "            grow_policy\n",
+       "            <span class=\"param-doc-description\">grow_policy: typing.Optional[str]<br><br>Tree growing policy.<br><br>- depthwise: Favors splitting at nodes closest to the node,<br>- lossguide: Favors splitting at nodes with highest loss change.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('importance_type',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">importance_type</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('interaction_constraints',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=interaction_constraints,-typing.Union%5Bstr%2C%20typing.List%5Btyping.Tuple%5Bstr%5D%5D%2C%20NoneType%5D\">\n",
+       "            interaction_constraints\n",
+       "            <span class=\"param-doc-description\">interaction_constraints: typing.Union[str, typing.List[typing.Tuple[str]], NoneType]<br><br>Constraints for interaction representing permitted interactions.  The<br>constraints must be specified in the form of a nested list, e.g. ``[[0, 1], [2,<br>3, 4]]``, where each inner list is a group of indices of features that are<br>allowed to interact with each other.  See :doc:`tutorial<br></tutorials/feature_interaction_constraint>` for more information</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('learning_rate',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=learning_rate,-typing.Optional%5Bfloat%5D\">\n",
+       "            learning_rate\n",
+       "            <span class=\"param-doc-description\">learning_rate: typing.Optional[float]<br><br>Boosting learning rate (xgb's \"eta\")</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">0.1</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_bin',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=max_bin,-typing.Optional%5Bint%5D\">\n",
+       "            max_bin\n",
+       "            <span class=\"param-doc-description\">max_bin: typing.Optional[int]<br><br>If using histogram-based algorithm, maximum number of bins per feature</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_cat_threshold',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=max_cat_threshold,-typing.Optional%5Bint%5D\">\n",
+       "            max_cat_threshold\n",
+       "            <span class=\"param-doc-description\">max_cat_threshold: typing.Optional[int]<br><br>.. versionadded:: 1.7.0<br><br>.. note:: This parameter is experimental<br><br>Maximum number of categories considered for each split. Used only by<br>partition-based splits for preventing over-fitting. Also, `enable_categorical`<br>needs to be set to have categorical feature support. See :doc:`Categorical Data<br></tutorials/categorical>` and :ref:`cat-param` for details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_cat_to_onehot',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=max_cat_to_onehot,-Optional%5Bint%5D\">\n",
+       "            max_cat_to_onehot\n",
+       "            <span class=\"param-doc-description\">max_cat_to_onehot: Optional[int]<br><br>.. versionadded:: 1.6.0<br><br>.. note:: This parameter is experimental<br><br>A threshold for deciding whether XGBoost should use one-hot encoding based split<br>for categorical data.  When number of categories is lesser than the threshold<br>then one-hot encoding is chosen, otherwise the categories will be partitioned<br>into children nodes. Also, `enable_categorical` needs to be set to have<br>categorical feature support. See :doc:`Categorical Data<br></tutorials/categorical>` and :ref:`cat-param` for details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_delta_step',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=max_delta_step,-typing.Optional%5Bfloat%5D\">\n",
+       "            max_delta_step\n",
+       "            <span class=\"param-doc-description\">max_delta_step: typing.Optional[float]<br><br>Maximum delta step we allow each tree's weight estimation to be.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_depth',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=max_depth,-%20typing.Optional%5Bint%5D\">\n",
+       "            max_depth\n",
+       "            <span class=\"param-doc-description\">max_depth:  typing.Optional[int]<br><br>Maximum tree depth for base learners.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">8</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_leaves',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=max_leaves,-typing.Optional%5Bint%5D\">\n",
+       "            max_leaves\n",
+       "            <span class=\"param-doc-description\">max_leaves: typing.Optional[int]<br><br>Maximum number of leaves; 0 indicates no limit.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('min_child_weight',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=min_child_weight,-typing.Optional%5Bfloat%5D\">\n",
+       "            min_child_weight\n",
+       "            <span class=\"param-doc-description\">min_child_weight: typing.Optional[float]<br><br>Minimum sum of instance weight(hessian) needed in a child.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">3</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('missing',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=missing,-float\">\n",
+       "            missing\n",
+       "            <span class=\"param-doc-description\">missing: float<br><br>Value in the data which needs to be present as a missing value. Default to<br>:py:data:`numpy.nan`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">nan</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('monotone_constraints',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=monotone_constraints,-typing.Union%5Btyping.Dict%5Bstr%2C%20int%5D%2C%20str%2C%20NoneType%5D\">\n",
+       "            monotone_constraints\n",
+       "            <span class=\"param-doc-description\">monotone_constraints: typing.Union[typing.Dict[str, int], str, NoneType]<br><br>Constraint of variable monotonicity.  See :doc:`tutorial </tutorials/monotonic>`<br>for more information.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('multi_strategy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=multi_strategy,-typing.Optional%5Bstr%5D\">\n",
+       "            multi_strategy\n",
+       "            <span class=\"param-doc-description\">multi_strategy: typing.Optional[str]<br><br>.. versionadded:: 2.0.0<br><br>.. note:: This parameter is working-in-progress.<br><br>The strategy used for training multi-target models, including multi-target<br>regression and multi-class classification. See :doc:`/tutorials/multioutput` for<br>more information.<br><br>- ``one_output_per_tree``: One model for each target.<br>- ``multi_output_tree``:  Use multi-target trees.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('n_estimators',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=n_estimators,-Optional%5Bint%5D\">\n",
+       "            n_estimators\n",
+       "            <span class=\"param-doc-description\">n_estimators: Optional[int]<br><br>Number of boosting rounds.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">400</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('n_jobs',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=n_jobs,-typing.Optional%5Bint%5D\">\n",
+       "            n_jobs\n",
+       "            <span class=\"param-doc-description\">n_jobs: typing.Optional[int]<br><br>Number of parallel threads used to run xgboost.  When used with other<br>Scikit-Learn algorithms like grid search, you may choose which algorithm to<br>parallelize and balance the threads.  Creating thread contention will<br>significantly slow down both algorithms.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('num_parallel_tree',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">num_parallel_tree</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('random_state',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=random_state,-typing.Union%5Bnumpy.random.mtrand.RandomState%2C%20numpy.random._generator.Generator%2C%20int%2C%20NoneType%5D\">\n",
+       "            random_state\n",
+       "            <span class=\"param-doc-description\">random_state: typing.Union[numpy.random.mtrand.RandomState, numpy.random._generator.Generator, int, NoneType]<br><br>Random number seed.<br><br>.. note::<br><br>   Using gblinear booster with shotgun updater is nondeterministic as<br>   it uses Hogwild algorithm.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">42</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('reg_alpha',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=reg_alpha,-typing.Optional%5Bfloat%5D\">\n",
+       "            reg_alpha\n",
+       "            <span class=\"param-doc-description\">reg_alpha: typing.Optional[float]<br><br>L1 regularization term on weights (xgb's alpha).</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('reg_lambda',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=reg_lambda,-typing.Optional%5Bfloat%5D\">\n",
+       "            reg_lambda\n",
+       "            <span class=\"param-doc-description\">reg_lambda: typing.Optional[float]<br><br>L2 regularization term on weights (xgb's lambda).</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('sampling_method',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=sampling_method,-typing.Optional%5Bstr%5D\">\n",
+       "            sampling_method\n",
+       "            <span class=\"param-doc-description\">sampling_method: typing.Optional[str]<br><br>Sampling method. Used only by the GPU version of ``hist`` tree method.<br><br>- ``uniform``: Select random training instances uniformly.<br>- ``gradient_based``: Select random training instances with higher probability<br>    when the gradient and hessian are larger. (cf. CatBoost)</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('scale_pos_weight',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=scale_pos_weight,-typing.Optional%5Bfloat%5D\">\n",
+       "            scale_pos_weight\n",
+       "            <span class=\"param-doc-description\">scale_pos_weight: typing.Optional[float]<br><br>Balancing of positive and negative weights.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">17.206272939606272</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('subsample',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=subsample,-typing.Optional%5Bfloat%5D\">\n",
+       "            subsample\n",
+       "            <span class=\"param-doc-description\">subsample: typing.Optional[float]<br><br>Subsample ratio of the training instance.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">0.6</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('tree_method',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=tree_method,-typing.Optional%5Bstr%5D\">\n",
+       "            tree_method\n",
+       "            <span class=\"param-doc-description\">tree_method: typing.Optional[str]<br><br>Specify which tree method to use.  Default to auto.  If this parameter is set to<br>default, XGBoost will choose the most conservative option available.  It's<br>recommended to study this option from the parameters document :doc:`tree method<br></treemethod>`</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;hist&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('validate_parameters',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=validate_parameters,-typing.Optional%5Bbool%5D\">\n",
+       "            validate_parameters\n",
+       "            <span class=\"param-doc-description\">validate_parameters: typing.Optional[bool]<br><br>Give warnings for unknown parameter.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbosity',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://xgboost.readthedocs.io/en/release_3.0.0/python/python_api.html#xgboost.XGBClassifier#:~:text=verbosity,-typing.Optional%5Bint%5D\">\n",
+       "            verbosity\n",
+       "            <span class=\"param-doc-description\">verbosity: typing.Optional[int]<br><br>The degree of verbosity. Valid values are 0 (silent) - 3 (debug).</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div></div><script>function copyToClipboard(text, element) {\n",
+       "    // Get the parameter prefix from the closest toggleable content\n",
+       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
+       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
+       "    const fullParamName = paramPrefix ? `${paramPrefix}${text}` : text;\n",
+       "\n",
+       "    const originalStyle = element.style;\n",
+       "    const computedStyle = window.getComputedStyle(element);\n",
+       "    const originalWidth = computedStyle.width;\n",
+       "    const originalHTML = element.innerHTML.replace('Copied!', '');\n",
+       "\n",
+       "    navigator.clipboard.writeText(fullParamName)\n",
+       "        .then(() => {\n",
+       "            element.style.width = originalWidth;\n",
+       "            element.style.color = 'green';\n",
+       "            element.innerHTML = \"Copied!\";\n",
+       "\n",
+       "            setTimeout(() => {\n",
+       "                element.innerHTML = originalHTML;\n",
+       "                element.style = originalStyle;\n",
+       "            }, 2000);\n",
+       "        })\n",
+       "        .catch(err => {\n",
+       "            console.error('Failed to copy:', err);\n",
+       "            element.style.color = 'red';\n",
+       "            element.innerHTML = \"Failed!\";\n",
+       "            setTimeout(() => {\n",
+       "                element.innerHTML = originalHTML;\n",
+       "                element.style = originalStyle;\n",
+       "            }, 2000);\n",
+       "        });\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "document.querySelectorAll('.copy-paste-icon').forEach(function(element) {\n",
+       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
+       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
+       "    const paramName = element.parentElement.nextElementSibling\n",
+       "        .textContent.trim().split(' ')[0];\n",
+       "    const fullParamName = paramPrefix ? `${paramPrefix}${paramName}` : paramName;\n",
+       "\n",
+       "    element.setAttribute('title', fullParamName);\n",
+       "});\n",
+       "\n",
+       "\n",
+       "/**\n",
+       " * Adapted from Skrub\n",
+       " * https://github.com/skrub-data/skrub/blob/403466d1d5d4dc76a7ef569b3f8228db59a31dc3/skrub/_reporting/_data/templates/report.js#L789\n",
+       " * @returns \"light\" or \"dark\"\n",
+       " */\n",
+       "function detectTheme(element) {\n",
+       "    const body = document.querySelector('body');\n",
+       "\n",
+       "    // Check VSCode theme\n",
+       "    const themeKindAttr = body.getAttribute('data-vscode-theme-kind');\n",
+       "    const themeNameAttr = body.getAttribute('data-vscode-theme-name');\n",
+       "\n",
+       "    if (themeKindAttr && themeNameAttr) {\n",
+       "        const themeKind = themeKindAttr.toLowerCase();\n",
+       "        const themeName = themeNameAttr.toLowerCase();\n",
+       "\n",
+       "        if (themeKind.includes(\"dark\") || themeName.includes(\"dark\")) {\n",
+       "            return \"dark\";\n",
+       "        }\n",
+       "        if (themeKind.includes(\"light\") || themeName.includes(\"light\")) {\n",
+       "            return \"light\";\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    // Check Jupyter theme\n",
+       "    if (body.getAttribute('data-jp-theme-light') === 'false') {\n",
+       "        return 'dark';\n",
+       "    } else if (body.getAttribute('data-jp-theme-light') === 'true') {\n",
+       "        return 'light';\n",
+       "    }\n",
+       "\n",
+       "    // Guess based on a parent element's color\n",
+       "    const color = window.getComputedStyle(element.parentNode, null).getPropertyValue('color');\n",
+       "    const match = color.match(/^rgb\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)\\s*$/i);\n",
+       "    if (match) {\n",
+       "        const [r, g, b] = [\n",
+       "            parseFloat(match[1]),\n",
+       "            parseFloat(match[2]),\n",
+       "            parseFloat(match[3])\n",
+       "        ];\n",
+       "\n",
+       "        // https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness\n",
+       "        const luma = 0.299 * r + 0.587 * g + 0.114 * b;\n",
+       "\n",
+       "        if (luma > 180) {\n",
+       "            // If the text is very bright we have a dark theme\n",
+       "            return 'dark';\n",
+       "        }\n",
+       "        if (luma < 75) {\n",
+       "            // If the text is very dark we have a light theme\n",
+       "            return 'light';\n",
+       "        }\n",
+       "        // Otherwise fall back to the next heuristic.\n",
+       "    }\n",
+       "\n",
+       "    // Fallback to system preference\n",
+       "    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';\n",
+       "}\n",
+       "\n",
+       "\n",
+       "function forceTheme(elementId) {\n",
+       "    const estimatorElement = document.querySelector(`#${elementId}`);\n",
+       "    if (estimatorElement === null) {\n",
+       "        console.error(`Element with id ${elementId} not found.`);\n",
+       "    } else {\n",
+       "        const theme = detectTheme(estimatorElement);\n",
+       "        estimatorElement.classList.add(theme);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "forceTheme('sk-container-id-1');</script></body>"
+      ],
+      "text/plain": [
+       "Pipeline(steps=[('preprocess',\n",
+       "                 ColumnTransformer(transformers=[('onehot',\n",
+       "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
+       "                                                  ['category', 'gender']),\n",
+       "                                                 ('target', TargetEncoder(),\n",
+       "                                                  ['street', 'city', 'state',\n",
+       "                                                   'job']),\n",
+       "                                                 ('num', 'passthrough',\n",
+       "                                                  ['amt', 'city_pop', 'age',\n",
+       "                                                   'geo_dist'])])),\n",
+       "                ('model',\n",
+       "                 XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "                               colsample_bylevel=None, colsam...\n",
+       "                               feature_types=None, feature_weights=None,\n",
+       "                               gamma=None, grow_policy=None,\n",
+       "                               importance_type=None,\n",
+       "                               interaction_constraints=None, learning_rate=0.1,\n",
+       "                               max_bin=None, max_cat_threshold=None,\n",
+       "                               max_cat_to_onehot=None, max_delta_step=None,\n",
+       "                               max_depth=8, max_leaves=None, min_child_weight=3,\n",
+       "                               missing=nan, monotone_constraints=None,\n",
+       "                               multi_strategy=None, n_estimators=400,\n",
+       "                               n_jobs=None, num_parallel_tree=None, ...))])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_pipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fc93c27-0981-4546-b741-b1776682b082",
+   "metadata": {},
+   "source": [
+    "# Validation and Explainability"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "b8295f06-9169-472f-950f-a770f5a64801",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00    128919\n",
+      "           1       0.70      0.78      0.74       749\n",
+      "\n",
+      "    accuracy                           1.00    129668\n",
+      "   macro avg       0.85      0.89      0.87    129668\n",
+      "weighted avg       1.00      1.00      1.00    129668\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "y_pred = model_pipeline.predict(X_test)\n",
+    "print(classification_report(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c7fd56a-bbe5-4e4b-aff1-f385d2f7c137",
+   "metadata": {},
+   "source": [
+    "The model correctly detects 77.3% of fraudulent transactions and correctly classifies 99.8% of non-fraudulent transactions as non-fraud. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "679da4e8-b8ac-42e5-b188-3539b15760d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAHWCAYAAAA2Of5hAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABp2klEQVR4nO3dd3hT1R8G8De7O90LCmUP2VQQEEGolCmIShGUwg+3KDJkyBIRKlNQUVRGBUSWisgoMkTZS4ogUFaR1ZbudCdNzu+PSrTSQlOS3rR9P8/Th+bk3uQbbpu8Pefcc2VCCAEiIiIikpRc6gKIiIiIiKGMiIiIyC4wlBERERHZAYYyIiIiIjvAUEZERERkBxjKiIiIiOwAQxkRERGRHWAoIyIiIrIDDGVEREREdoChjIiIiMgOMJQRkWSioqIgk8nMX0qlEtWqVcPQoUNx8+bNYvcRQmDVqlV47LHH4O7uDicnJzRt2hTvv/8+srOzS3yuH374AT169IC3tzfUajUCAwMxYMAA7Nmzp1S15uXl4aOPPkLbtm2h1Wrh4OCA+vXrY8SIEbhw4UKZXj8R0b/JeO1LIpJKVFQUhg0bhvfffx+1atVCXl4eDh8+jKioKAQHB+PMmTNwcHAwb280GjFo0CCsX78eHTt2RP/+/eHk5IR9+/ZhzZo1aNy4MXbt2gU/Pz/zPkII/O9//0NUVBRatmyJZ555Bv7+/oiPj8cPP/yAEydO4MCBA2jfvn2JdSYnJ6N79+44ceIEevfujdDQULi4uCA2NhZr165FQkIC9Hq9Tf+viKgKEEREElmxYoUAII4dO1akffz48QKAWLduXZH2WbNmCQBi7Nixdz3W5s2bhVwuF927dy/SPnfuXAFAvP3228JkMt2138qVK8WRI0fuWWevXr2EXC4XGzduvOu+vLw8MWbMmHvuX1oGg0Hk5+db5bGIqOLh8CUR2Z2OHTsCAC5fvmxuy83Nxdy5c1G/fn1ERkbetU+fPn0QERGB6OhoHD582LxPZGQkGjZsiHnz5kEmk9213wsvvIA2bdqUWMuRI0ewdetWDB8+HE8//fRd92s0GsybN898u3PnzujcufNd2w0dOhTBwcHm21evXoVMJsO8efOwcOFC1KlTBxqNBidPnoRSqcT06dPveozY2FjIZDJ8+umn5rb09HS8/fbbCAoKgkajQd26dTF79myYTKYSXxMR2SeGMiKyO1evXgUAeHh4mNv279+PtLQ0DBo0CEqlstj9hgwZAgDYsmWLeZ/U1FQMGjQICoWiTLVs3rwZQGF4s4UVK1bgk08+wcsvv4z58+cjICAAnTp1wvr16+/adt26dVAoFHj22WcBADk5OejUqRNWr16NIUOG4OOPP0aHDh0wceJEjB492ib1EpHtFP/ORkRUjjIyMpCcnIy8vDwcOXIE06dPh0ajQe/evc3bnD17FgDQvHnzEh/nzn3nzp0r8m/Tpk3LXJs1HuNebty4gUuXLsHHx8fcFh4ejldeeQVnzpxBkyZNzO3r1q1Dp06dzHPmFixYgMuXL+PkyZOoV68eAOCVV15BYGAg5s6dizFjxiAoKMgmdROR9bGnjIgkFxoaCh8fHwQFBeGZZ56Bs7MzNm/ejOrVq5u3yczMBAC4urqW+Dh37tPpdEX+vdc+92ONx7iXp59+ukggA4D+/ftDqVRi3bp15rYzZ87g7NmzCA8PN7dt2LABHTt2hIeHB5KTk81foaGhMBqN+O2332xSMxHZBnvKiEhyixcvRv369ZGRkYHly5fjt99+g0ajKbLNnVB0J5wV57/Bzc3N7b773M+/H8Pd3b3Mj1OSWrVq3dXm7e2Nrl27Yv369ZgxYwaAwl4ypVKJ/v37m7e7ePEi/vjjj7tC3R23b9+2er1EZDsMZUQkuTZt2iAkJAQA0K9fPzz66KMYNGgQYmNj4eLiAgBo1KgRAOCPP/5Av379in2cP/74AwDQuHFjAEDDhg0BAKdPny5xn/v592PcOQHhXmQyGUQxKw0ZjcZit3d0dCy2feDAgRg2bBhiYmLQokULrF+/Hl27doW3t7d5G5PJhCeeeALjxo0r9jHq169/33qJyH5w+JKI7IpCoUBkZCRu3bpV5CzDRx99FO7u7lizZk2JAWflypUAYJ6L9uijj8LDwwPffvttifvcT58+fQAAq1evLtX2Hh4eSE9Pv6v9r7/+suh5+/XrB7VajXXr1iEmJgYXLlzAwIEDi2xTp04dZGVlITQ0tNivGjVqWPScRCQthjIisjudO3dGmzZtsHDhQuTl5QEAnJycMHbsWMTGxmLSpEl37bN161ZERUUhLCwMjzzyiHmf8ePH49y5cxg/fnyxPVirV6/G0aNHS6ylXbt26N69O5YuXYpNmzbddb9er8fYsWPNt+vUqYPz588jKSnJ3Hbq1CkcOHCg1K8fANzd3REWFob169dj7dq1UKvVd/X2DRgwAIcOHcKOHTvu2j89PR0FBQUWPScRSYsr+hORZO6s6H/s2DHz8OUdGzduxLPPPovPP/8cr776KoDCIcDw8HB89913eOyxx/D000/D0dER+/fvx+rVq9GoUSPs3r27yIr+JpMJQ4cOxapVq9CqVSvziv4JCQnYtGkTjh49ioMHD6Jdu3Yl1pmUlIRu3brh1KlT6NOnD7p27QpnZ2dcvHgRa9euRXx8PPLz8wEUnq3ZpEkTNG/eHMOHD8ft27exZMkS+Pn5QafTmZf7uHr1KmrVqoW5c+cWCXX/9s033+D555+Hq6srOnfubF6e446cnBx07NgRf/zxB4YOHYrWrVsjOzsbp0+fxsaNG3H16tUiw51EZOekXbuWiKqyklb0F0IIo9Eo6tSpI+rUqSMKCgqKtK9YsUJ06NBBuLm5CQcHB/HQQw+J6dOni6ysrBKfa+PGjaJbt27C09NTKJVKERAQIMLDw8XevXtLVWtOTo6YN2+eePjhh4WLi4tQq9WiXr164s033xSXLl0qsu3q1atF7dq1hVqtFi1atBA7duwQERERombNmuZt4uLiBAAxd+7cEp9Tp9MJR0dHAUCsXr262G0yMzPFxIkTRd26dYVarRbe3t6iffv2Yt68eUKv15fqtRGRfWBPGREREZEd4JwyIiIiIjvAUEZERERkBxjKiIiIiOwAQxkRERGRHWAoIyIiIrIDDGVEREREdqDKXfvSZDLh1q1bcHV1hUwmk7ocIiIiquSEEMjMzERgYCDk8pL7w6pcKLt16xaCgoKkLoOIiIiqmOvXr6N69eol3l/lQpmrqyuAwv8YNzc3iashIiKiyk6n0yEoKMicQUpS5ULZnSFLNzc3hjIiIiIqN/ebNsWJ/kRERER2gKGMiIiIyA4wlBERERHZAYYyIiIiIjvAUEZERERkBxjKiIiIiOwAQxkRERGRHWAoIyIiIrIDDGVEREREdoChjIiIiMgOSBrKfvvtN/Tp0weBgYGQyWTYtGnTfffZu3cvWrVqBY1Gg7p16yIqKsrmdRIRERHZmqShLDs7G82bN8fixYtLtX1cXBx69eqFxx9/HDExMXj77bfx4osvYseOHTaulIiIiMi2JL0geY8ePdCjR49Sb79kyRLUqlUL8+fPBwA0atQI+/fvx0cffYSwsDBblUlERERkc5KGMksdOnQIoaGhRdrCwsLw9ttvl7hPfn4+8vPzzbd1Op2tyiOiKi7HYMCOS5eQW1AgdSl2SQiByb/8Ale1WupSiAAA8gI5TEoTAGDTwIGo7eEhaT0VKpQlJCTAz8+vSJufnx90Oh1yc3Ph6Oh41z6RkZGYPn16eZVIROXMJAS+PX0az//wA6q7uUlayw3+0UdUYdRI8cFzRx5FdNMTOBUUh3w7+GOqQoWyspg4cSJGjx5tvq3T6RAUFCRhRVRRCCFgFELqMuye3mjEylOnkJyTc8/tLqelISomBi5W7iXJ0uvN39tTKAqtXVvqEuySEAJeTk54qVUrqUuhKkoYgYQNciTslQMmGV5M7IwGEx5FDa1W6tIqVijz9/dHYmJikbbExES4ubkV20sGABqNBhqNpjzKIwmk5ubCaCrsek7KycHXMTFWCVIGoxEfHz36wI9Dd/t3iLK2mV26IKxOHZs9fml4ODpKPgRCRMVLv1GArRNSkBBT+D7UqJcTnpjsAY2rfawQVqFCWbt27bBt27YibTt37kS7du0kqogsJYTA1fR0GP4OUpbI1uux+NgxiL9D1/KYGCtXRw/qfr0fBSYT+jVsiCa+vlZ9XqVcjiA3N8hkMqs+LhFVDkIInP0pB7tmpkGfLaB2keGJyR5o3NtZ6tKKkDSUZWVl4dKlS+bbcXFxiImJgaenJ2rUqIGJEyfi5s2bWLlyJQDg1Vdfxaeffopx48bhf//7H/bs2YP169dj69atUr2EKkVvNOKPxESYLOyJOnrzJrZfugSNQoEfzp+3UXX/aObnh+5W6C0RAB6pXh2PBwc/8GNVdkq5HK7skSYiO3U71oBt76YCAKq1UqNXpBe01eyvX0rSio4fP47HH3/cfPvO3K+IiAhERUUhPj4e165dM99fq1YtbN26FaNGjcKiRYtQvXp1LF26lMthPCAhBI7cvIk9cXHYdP48nEuY87P36lWrPq+2DB/iuQUFqOPhgSHNmwMAAl1dMahpUyj+1UPC3hIiIvo3v4ZqhES4wsFNjrYvukKusM/PCZkQVWsms06ng1arRUZGBtwkPlPLlrL1evx8+TLyjUZz2+bYWJxMSICDsmgWj0lIsPjxg93dLdo+ISsLY9q1Q5CbG/xdXNC7fn0o5PYxhk9ERJWL0SBw6AsdmvZ3hjZQ+h6x0mYP6SulB2Y0mfDm9u1Ye+YM3P7ufforI6NMj1VTq8VLrVqhrqdnsffX8vBAm2rVylwrERGRLaXGGbBlfAoSzxpw/Vg+Bq7wgUxunz1j/8VQVkHdzs5G3Y8/BgBk/utstrS8vLu2/fecKF1+PsZ16AB3B4ci2zipVGhXvTp7r4iIqEISQuCP77Lxy+x0GHIFHNzkaPW8S4UJZABDWYV0OTUVdT/5pNj7Ng8cCH8XFwCAl5MTT80nIqJKLyfNiB3T0nBpTy4AoEZbDXrO9ISrf8WKORWrWkKuwVAkkMllMsSOGAGVXI4aWi0nuRMRUZWSfMmA9S/eRnayCXIl8NjbWoQMca1QPWR3MJRVIPuvXUPHFSvMt0Nr18a2QYOgUigkrIqIiEg67kFKOHoo4OAmR685XvBrWHGvrcpQVgHczs6G37x5Rdqa+PoievBgzgEjIqIqJ/WqAe7VlZArZVBqZOi/2BtOHnKoHCv2Z2LFrr4KEELcFchmdemC06+9xkBGRERVihACJ1ZnIqp/Ao4s++dat9pAZYUPZAB7yuzaiVu30Pvbb823XdRqJL3zzl3rjBEREVV2WclGRE9ORdz+wlUGEs7oIUyiQs4dKwk/3e3QnAMHMH7XrrvaMyZMgJwT+YmIqIq5tDcX0VNSkZtmglIjQ6cxWrR8zqXSndzGUGZnwjduxPo//yzS1qtePXzTvz8DGRERVSmGXBN+mZuOU+uzAQA+9VXoPccL3nVVEldmGwxldmTR4cNFAln04MF4vFYtqHl2JRERVUG6W0b8+WMOACAkwhUdR2qhVFfeDgqGMjuQkpODwd9/jx2XL5vb8idPZhgjIqIqzauOCk9M9YCLrwLB7Rzuv0MFV/FPVagEuq5cWSSQxbzyCgMZERFVObr4Aqx/6TZuxuSb25r0da4SgQxgT5nkRkVH41Riovn22ddfRyMfHwkrIiIiKn+xO3Lw8/Q05OlMyE5Ow9Dv/SrdRP77YSiT0If792PhkSPm29fefhtBWq2EFREREZUvfbYJuyPTcGZT4dwx/yZq9J7tWeUCGcBQJqmJu3ebvz/16qsMZEREVKXcOpWPLeNTkHHDCMiAR15yQ/vX3KBQVb1ABjCUSSLXYMDQH38031711FNo5ucnYUVERETlK+FPPdYMuQ1hBNwCFOj1oReqt9ZIXZakGMokMG3v3iJLXwxq2lTCaoiIiMqfX2MVaj/qALWzHKGTPeDgxnMPGcokMPfgQfP3Z157jYvCEhFRpSeEQGx0Lmo96gCNqxwymQxPLvCGUsPPwDsYS8uZSQjz9yv79cNDvr4SVkNERGR7eToTtoxLxU/vpGDXrDRzOwNZUewpK2djduwwf9+nQQMJKyEiIrK968fysHViKjITjJApAM9gJYQQVfLsyvthKCtHQogiS2C4O1SNxfCIiKjqMRoEDizOwJFlmYAA3IOU6DXbE4HNqvZk/nthKCtHI6Ojzd8v6NZNwkqIiIhsJ+NmATaPTkbCnwYAQNOnnNFlgjvUzpw1dS8MZeXk58uX8cnRo+bbbz/yiITVEBER2Y7KUYbMRCMc3OTo9p4HGnRzkrqkCoGhrJyErV5t/v7kK69wLJ2IiCoVfbbJ3BPm5KlAv0XecPVTwNWfUaO02I9YDgxGo/n7/o0aoYW/v4TVEBERWVfcgTws7R2Ps1uzzW2BzTUMZBZiKCsHY37+2fz94p49JayEiIjIegryBfbMScPGV5KQnWTC72uyIP619BNZhhG2HPx7Lpm/i4uElRAREVlH8iUDtoxLQdKFwsn8LQa6oPMYLafnPACGMhu7qdOZv983bJiElRARET04IQROrsnC3vnpMOoBJ085ur/viTqdHaUurcJjKLOxnVeumL9/tEYNCSshIiJ6cAln9NgdmQ4AqNXRAT1meMLZWyFtUZUEQ5mNbTx7FgDg7cTTgYmIqOILaKpB2xdd4eKrQMvnXDhcaUUMZTZ2LjkZABBWp47ElRAREVnOkGvCvo8z0GqwK9yrF8aGx952l7aoSoqhzMZyDIUTIHvWqydxJURERJZJPKfHlnEpSI0rQMKfejz3tS97xmyIoczGErKyAAD1vbwkroSIiKh0hEngWFQm9n2cAVMB4OwjR/vXeGalrTGU2VBmfr75+9oeHhJWQkREVDqZCQXYNikV144UfobV6+qIsOkecHTnZH5bYyizobNJSebvPRwcJKyEiIjo/hLP67H+f0nI05mgcpShywR3NO3vzB6ycsJQZkO/x8cDKDzzkj/QRERk77xqq+AaoIB7DSV6z/aER02V1CVVKQxlNrT5wgUA/0z2JyIisjeJ5/XwqauCXCmDUi3DM5/7wNFDDoWKnQnljde+tKE/b98GAHTjchhERGRnTAUCBz/PwKrwRBz68p+rz7j4KhjIJMKeMhty1WgAAF2Cg6UthIiI6F/SbxRg64QU3IrRF96+XgAhBKfaSIyhzEbS8/LME/0beHtLXA0REVHhdSvP/pSDXTPToM8WULvI8MRkDzTu7Sx1aQSGMpu5kpZm/r5ttWoSVkJERATk6UzYOSMN57fnAACqtVSj14de0FZjFLAXPBI2kpGXBwAIcnODlsthEBGRxLKTjLi0JxcyBdDhdTe0He4GuZLDlfaEocxGTEIAAK7rdPfZkoiIyDb+PU/Mq44K3Wd4QFtdicBmGokro+Lw7EsbuZCSAgB4pHp1iSshIqKqKDXOgG8G38bNk/9cXaZRT2cGMjvGUGYjV9PTAQA32FNGRETlSAiBUxuzsHJAIuL/0GN3ZBrE36M3ZN84fGkjLmo1ACDAxUXiSoiIqKrISTNix7Q0XNqTCwCo0VaDnjM9udRFBcFQZiN6oxEA0IZnXhIRUTmIO5CH7ZNTkJ1kglwJdBypxcMRrpDJGcgqCoYyGzGYTAAAtUIhcSVERFTZ3YzJx8ZXCtfG9KqtRK/ZXvBrpJa4KrIUQ5mN6PILJ1aq5Jy2R0REthXYXI26XRzh4qtA5zFaqBz52VMRMZTZyKXUVKlLICKiSkoIgT++y0bDMCdoXOWQyWTou8CL645VcAxlNhLo6goAyDYYJK6EiIgqk6xkI6InpyJufx6uH8tH79leAMBAVgkwlNlI/t8T/et5ekpcCRERVRaX9+YiemoqclJNUKgLhy15IfHKg6HMRk4nJgIANEr+FxMR0YMx5Jqwd146YtZlAwB86qvQe44XvOuqJK6MrImJwUacVIW/KDkcviQiogeQGmfAD28lIzWuAAAQEuGCjiPdoVSzd6yyYSizkTtLYVT7e24ZERFRWTi4y5GfZYKzjxw9Z3ohuL2D1CWRjTCU2cidOWV3VvYnIiIqrdx0Ixy0hWdVOnko0P9TH7gFKuDkwbUvKzMuZGIjf/197UsuHktERJaI3ZGDpT0TcHZLjrnN/yE1A1kVwFBmI5l6PQCAl4AlIqLS0GebsH1yKjaPSUGezoQzP2bzQuJVjOShbPHixQgODoaDgwPatm2Lo0eP3nP7hQsXokGDBnB0dERQUBBGjRqFvLy8cqq29HydnQEArhy+JCKi+7h1Kh9fP5OIM5uyARnwyEuueOZzHy51UcVIOqds3bp1GD16NJYsWYK2bdti4cKFCAsLQ2xsLHx9fe/afs2aNZgwYQKWL1+O9u3b48KFCxg6dChkMhkWLFggwSsomeHvOWWOKp6uTERExTMVCBz+SoeDS3QQRsAtQIGekZ4ICuFk/qpI0p6yBQsW4KWXXsKwYcPQuHFjLFmyBE5OTli+fHmx2x88eBAdOnTAoEGDEBwcjG7duuG55567b++aFO5ckJzXviQiopIk/KnHgcWFgaxhDydEfOfPQFaFSZYY9Ho9Tpw4gdDQ0H+KkcsRGhqKQ4cOFbtP+/btceLECXMIu3LlCrZt24aePXuW+Dz5+fnQ6XRFvspDck7hBE1O9CciopIENteg/etu6Bnpid5zPOHgxj/kqzLJhi+Tk5NhNBrh5+dXpN3Pzw/nz58vdp9BgwYhOTkZjz76KIQQKCgowKuvvop33323xOeJjIzE9OnTrVr7/fx7YqaSPWVERPS3PJ0Je+emo+1LbvCoUfgR3OF1rcRVkb2oUIlh7969mDVrFj777DP8/vvv+P7777F161bMmDGjxH0mTpyIjIwM89f169dtXmfB30OXAKB1YDc0EREB14/n4eunE3D6h2xsn5zCMyvpLpL1lHl7e0OhUCDx72tE3pGYmAh/f/9i95kyZQpeeOEFvPjiiwCApk2bIjs7Gy+//DImTZoEeTG9UhqNBhqNxvov4B4M/wplnFNGRFS1GQ0CBz/LwOGlmYAA3IOU6DzWnWdW0l0kSwxqtRqtW7fG7t27zW0mkwm7d+9Gu3btit0nJyfnruCl+HvOlj39xXHnzEsAUHFOGRFRlZV61YA1zyfi8FeFgaxJP2dEbPRDYLPy7SygikHSJTFGjx6NiIgIhISEoE2bNli4cCGys7MxbNgwAMCQIUNQrVo1REZGAgD69OmDBQsWoGXLlmjbti0uXbqEKVOmoE+fPuZwZg/YU0ZERLf+yMf64Ukw5Ao4uMnR7T0PNOjmJHVZZMckDWXh4eFISkrC1KlTkZCQgBYtWiA6Oto8+f/atWtFesYmT54MmUyGyZMn4+bNm/Dx8UGfPn0wc+ZMqV5Cse70lMkAKBjKiIiqJL9GangEK+HgJkfPmZ5w9eflpuneZMKexv3KgU6ng1arRUZGBtzc3GzyHOeTk9Fo8WIAgJg2zSbPQURE9ufG7/kIaKqGQlU4Xywn1QhHdzlkcs4fq8pKmz3YjWMDpqqVc4mIqrwCvcAvc9Pw7ZDbOPTFP+thOnkqGMio1NiXagN3lsTw+/v6l0REVHklXzJgy7gUJF0wAADyM00QQvDsSrIYQ5kNGP8OZVw4loio8hJC4OSaLPy6IAMF+QJOnnJ0f98TdTo7Sl0aVVAMZTZQwFBGRFSpZScbsX1KKuL25QEAanV0QI8ZnnD2tp+VAKjiYSizgTuhjGdeEhFVTvmZJtw4ng+lRoZOY7Ro+ZwLhyvpgTGU2QB7yoiIKh+TUUCuKAxenrVU6DHLE161VPCuq5K4MqosmBpsIDknBwAg519NRESVQuJZPb5+OgHXj+eZ2xo84cRARlbFUGYDd3rIzicnS1wJERE9CGESOLpch9WDEpF8qQC/fZRhV5f1o8qFw5c2oP97Rf9Ha9SQuBIiIiqrzIQCbJuUimtH8gEA9bo6Imy6B+eOkc0wlNnAnVCmtqPrcRIRUenF7sjBz9PTkKczQeUoQ5cJ7mja35mBjGyKocwGdPmFf1UxlBERVTzXj+Vh85gUAIB/EzV6z/aER03OHSPbYyizgZTcXABAjsEgcSVERGSp6iEa1O/mCM9gFdq/5ma+jiWRrTGU2YCrWg0AyGUoIyKye6YCgROrM9H0KRc4aOWQyWR4cp4Xr1lJ5Y6hzAYMf69TVs/LS+JKiIjoXtKvF2DrxBTcitEj4Yweved6QSaTMZCRJBjKbMDw90R/FRePJSKyS0IInP0pB7tmpkGfLaB2kaFOZ0dO5CdJMZTZwJ0V/RnKiIjsT57OhJ0z0nB+e+FC39VaqtHrQy9oq/EjkaTFn0AbyPj77EsVz74kIrIrt8/r8f2IZGQmGCFTAB1ed0Pb4W6QK9lDRtJjKLOBxOxsAEB+QYHElRAR0b+5BiggBOAepESv2Z4IbKaRuiQiM4YyG/BzdgYAZPHsSyIiyWUmFsDFVwGZTAZHrQLPfO4NbXUl1E6cYkL2hT+RNmD8e05ZsFYrcSVERFWXEAKnNmZhWe8E/Lk5x9zuU1/NQEZ2iT+VNmD8+2K1Ck70JyKSRE6aEZtGpuDn99JgyBW4uDuXFxInu8fhSxsw3QllPLWaiKjcxR3Iw/ZJKchONkGuBB57W4uQIa5c7oLsHkOZDdwZvpTzDYCIqNwU5Av8tjAdJ1ZlAQC8aivRa7YX/BqpJa6MqHQYymyAw5dEROUv8aweJ1YXBrIWA13QeYwWKke+D1PFwVBmA3d6yjh8SURUfqq11OCxkVp411WhTmdHqcshshj/hLABE3vKiIhsLivZiB9HJSPtr3+WH2r7ohsDGVVY7CmzgTvDl5xTRkRkG5f25iJ6Sipy00zITTNhYJSv1CURPTCGMhs4ER8PgKGMiMjaDLkm/DI3HafWF145xae+CqGTPSSuisg6GMpsoJG3N87cvo3ErCypSyEiqjQSz+qxZXwKUuMKL2EXEuGCjiPdoVTzD2CqHBjKbODOnLJaHvzrjYjIGq4fz8P6F5NgKgCcfeToOdMLwe0dpC6LyKoYymzAxDllRERWFdhcA98GKrj6KxE23QOO7gqpSyKyOoYyG7hzIQ+GMiKisovbn4sabR2gUMmgUMnw7Fe+0LjKuDI/VVpcs8EG2FNGRFR2+mwTtk9OwcZXk3Hwswxzu4ObnIGMKjX2lNkAQxkRUdncOpWPLeNTkHHDCMgAmYLvo1R1MJTZAEMZEZFlTAUCh7/S4eASHYQRcAtQoNeHXqjeWiN1aUTlhqHMBu6EMkYyIqL7y7hZgC3jU3ArRg8AaNTLCaGTPODgxhk2VLUwlNkAe8qIiErPVCCQFGuA2kWGJyZ7oHFvZ6lLIpIEQ5kNMJQREd2b0SCgUBW+R3rUVKHPXC9411NBW40fS1R1PVDfcF5enrXqqFQYyoiISnb9eB6W9Y7HtaP/fIbU6ezIQEZVnsWhzGQyYcaMGahWrRpcXFxw5coVAMCUKVOwbNkyqxdYETGUERHdzWgQ+G1hOtYOS0LGTSMOLdFJXRKRXbE4lH3wwQeIiorCnDlzoFarze1NmjTB0qVLrVpcRXXkxg0A4Ho6RER/S71qwJrnE3FkaSYggKZPOeOpT72lLovIrlgcylauXIkvv/wSgwcPhkLxz2UumjdvjvPnz1u1uIqqhb8/ACCdw7tEVMUJIXBqYxZWPpuIhD8NcHCT48mPvNB9hifUTjy7kujfLB7Av3nzJurWrXtXu8lkgsFgsEpRFd2dyyz5OvMMIiKq2v46nI+f30sDANRoq0HPmZ5w9efcMaLiWPyb0bhxY+zbtw81a9Ys0r5x40a0bNnSaoVVZIJzyoiIAAA1H9GgUS8n+DVSIWSIK2Ryvi8SlcTiUDZ16lRERETg5s2bMJlM+P777xEbG4uVK1diy5YttqixwuHisURUVRXkF67M3/oFFzhqFZDJZOj1oSfn2BKVgsUD+n379sVPP/2EXbt2wdnZGVOnTsW5c+fw008/4YknnrBFjRXOneFL9pQRUVWSfMmA1c8l4tASHXa+n2ZuZyAjKp0yDex37NgRO3futHYtlcad4Uu+ERFRVSCEwMk1Wdg7Px1GPeDkKcdDfTinlshSFveU1a5dGykpKXe1p6eno3bt2lYpqqLj8CURVRVZyUZ891oydkcWBrJaHR0w9Ht/1OnsKHVpRBWOxT1lV69ehdFovKs9Pz8fN2/etEpRFR2HL4moKog/nY/vXk9GbpoJSo0MncZo0fI5F44SEJVRqUPZ5s2bzd/v2LEDWq3WfNtoNGL37t0IDg62anEVFYcviagq8KihglItg099FXrP8YJ3XZXUJRFVaKUOZf369QNQGDQiIiKK3KdSqRAcHIz58+dbtbiKipdZIqLKKu1aAdyDCs+qdNDKMWCpD9yqKaFU8/2O6EGVOpSZTCYAQK1atXDs2DF4e/PyGCW5M3zJtygiqiyESeBoVCb2f5yBblM90LS/CwDAsxZ7x4isxeI5ZXFxcbaoo1Lh8CURVSaZCQXY9m4qrh3NBwBcO5ZvDmVEZD1lWhIjOzsbv/76K65duwa9Xl/kvrfeessqhVVkHL4kosoidkcOfp6ehjydCSpHGbpMcEfT/lzugsgWLA5lJ0+eRM+ePZGTk4Ps7Gx4enoiOTkZTk5O8PX1ZSgDhy+JqOLTZ5uwOzINZzblAAD8H1Kh12wveAZzuJLIVixep2zUqFHo06cP0tLS4OjoiMOHD+Ovv/5C69atMW/ePFvUWOGwp4yIKrrbsQac+TEHkAGPvOyGQav9GMiIbMzinrKYmBh88cUXkMvlUCgUyM/PR+3atTFnzhxERESgf//+tqizQuGcMiKq6Kq30uDxd9zh11iFoBAHqcshqhIs7ilTqVSQywt38/X1xbVr1wAAWq0W169ft251FRSHL4mookm/UYANLych9arB3BYyxJWBjKgcWdxT1rJlSxw7dgz16tVDp06dMHXqVCQnJ2PVqlVo0qSJLWqscDh8SUQVhRACZ3/Kwa6ZadBnC+yckYbwZb5Sl0VUJVncUzZr1iwEBAQAAGbOnAkPDw+89tprSEpKwhdffGFxAYsXL0ZwcDAcHBzQtm1bHD169J7bp6en44033kBAQAA0Gg3q16+Pbdu2Wfy8tnQlLQ0Ahy+JyL7l6UzYMi4V295NhT5boFpLNcKme0pdFlGVZXFPWUhIiPl7X19fREdHl/nJ161bh9GjR2PJkiVo27YtFi5ciLCwMMTGxsLX9+6/1PR6PZ544gn4+vpi48aNqFatGv766y+4u7uXuQZbqKHV4lpGBvILCqQuhYioWNeP52HbxFTo4o2QKYD2r7nhkRfdIFfyj0kiqVjcU1aS33//Hb1797ZonwULFuCll17CsGHD0LhxYyxZsgROTk5Yvnx5sdsvX74cqamp2LRpEzp06IDg4GB06tQJzZs3t8ZLsDonFc9UIiL7c/VQHtYOS4Iu3gj3ICUGrfJF+1e1DGREErMolO3YsQNjx47Fu+++iytXrgAAzp8/j379+uHhhx82X4qpNPR6PU6cOIHQ0NB/ipHLERoaikOHDhW7z+bNm9GuXTu88cYb8PPzQ5MmTTBr1iwYjcYSnyc/Px86na7Il63x7EsismdBIRoENFGj6VPOiNjoh8BmGqlLIiJYEMqWLVuGHj16ICoqCrNnz8YjjzyC1atXo127dvD398eZM2csmtuVnJwMo9EIPz+/Iu1+fn5ISEgodp8rV65g48aNMBqN2LZtG6ZMmYL58+fjgw8+KPF5IiMjodVqzV9BQUGlrvFBMZIRkT0QQuB8dA6MhsI/GBUqGcKX+6D7DE+ona02YEJED6jUv42LFi3C7NmzkZycjPXr1yM5ORmfffYZTp8+jSVLlqBRo0a2rBNA4UXRfX198eWXX6J169YIDw/HpEmTsGTJkhL3mThxIjIyMsxf5bFsh7j/JkRE5SInzYhNI1Pw09gU7P80w9yucmQYI7I3pZ7of/nyZTz77LMAgP79+0OpVGLu3LmoXr16mZ7Y29sbCoUCiYmJRdoTExPh7+9f7D4BAQFQqVRQKBTmtkaNGiEhIQF6vR5qtfqufTQaDTSa8u2a5/AlEdmDqwfzsG1SCrKTTJArAScPBjEie1bq39Dc3Fw4OTkBKAwbGo3GvDRGWajVarRu3Rq7d+82t5lMJuzevRvt2rUrdp8OHTrg0qVLReauXbhwAQEBAcUGMqlw8VgiklJBvsCeOWnY8HISspNM8KylxPPf+uHhoW5Sl0ZE92DRkhhLly6Fi4sLAKCgoABRUVHw9vYuso0lFyQfPXo0IiIiEBISgjZt2mDhwoXIzs7GsGHDAABDhgxBtWrVEBkZCQB47bXX8Omnn2LkyJF48803cfHiRcyaNctuL4LOnjIiKm8pVwz4aWwKki4UrszfYqALOo/RcriSqAIodSirUaMGvvrqK/Ntf39/rFq1qsg2MpnMooAUHh6OpKQkTJ06FQkJCWjRogWio6PNk/+vXbtmvqQTAAQFBWHHjh0YNWoUmjVrhmrVqmHkyJEYP358qZ+zPNwZviQiKm9ypQzpNwrg5ClH9/c9Uaezo9QlEVEpyUQVSxA6nQ5arRYZGRlwc7NNV37A/PlIyMpCzCuvoHkJ8+OIiKzFkGsq0hN29WAefOqr4OytuMdeRFReSps92J9tA5zoT0Tl5fLeXHzZPR5/HckztwW3d2AgI6qALL7MEpUeIxkR2Yoh14S989IRsy4bAHA8KhM12zpIXBURPQiGMhuoUuPBRFTuEs/psWVcClLjCq+vGxLhgo4j3aUtiogeGEOZDXD4kohsQZgEjkVlYt/HGTAVAM4+cvSc6YXg9uwhI6oMGMpsgOuUEZEtxO3Pw68LClflr9fVEWHTPeDozrljRJVFmULZ5cuXsWLFCly+fBmLFi2Cr68vtm/fjho1auChhx6ydo0VDnvKiMgWanV0QNOnnBHYXI2mTzvzPYaokrH47Mtff/0VTZs2xZEjR/D9998jKysLAHDq1ClMmzbN6gVWZHy7JKIHoc82Yc+cNOSmGwEU/qHXfYYnmj3jwkBGVAlZHMomTJiADz74ADt37ixyaaMuXbrg8OHDVi2uouJEfyJ6ULdO5ePrZxJxYmUWfn4/TepyiKgcWDx8efr0aaxZs+audl9fXyQnJ1ulqIqOw5dEVFamAoHDS3U4+LkOwgi4BSjQapCL1GURUTmwOJS5u7sjPj4etWrVKtJ+8uRJVKtWzWqFVWSc6E9EZZF+owDbJqbg5kk9AKBRTyeETvaAgxvX+SaqCiz+TR84cCDGjx+PhIQEyGQymEwmHDhwAGPHjsWQIUNsUWOFxZ4yIiqtGyfy8fXTCbh5Ug+1iwy9PvRE7zleDGREVYjFv+2zZs1Cw4YNERQUhKysLDRu3BiPPfYY2rdvj8mTJ9uixgqnil1OlIiswLueCg5uclRrqUbERn807u0sdUlEVM4sHr5Uq9X46quvMGXKFJw5cwZZWVlo2bIl6tWrZ4v6KiQOXxJRaSRd0MO7ngoymQwObnKEr/CFm78CciXfPYiqIotD2f79+/Hoo4+iRo0aqFGjhi1qqvA40Z+I7sVoEDj4WQYOL81Et2keaP5M4UR+9+pcz5uoKrN4+LJLly6oVasW3n33XZw9e9YWNVUajGRE9F+pVw1Y83wiDn+VCQgg+YJB6pKIyE5YHMpu3bqFMWPG4Ndff0WTJk3QokULzJ07Fzdu3LBFfRUSZ5QR0X8JIXBqYxZWPpuIhD8NcHCT48mPvND1XQ+pSyMiO2FxKPP29saIESNw4MABXL58Gc8++yy+/vprBAcHo0uXLraoscLh8CUR/VtOmhGbRqbg5/fSYMgVqNFWg6Hf+6HBE05Sl0ZEduSBJjDUqlULEyZMQPPmzTFlyhT8+uuv1qqrQuNEfyL6t9S4Alzemwu5Eug4UouHI1whk/MdgoiKKnMoO3DgAL755hts3LgReXl56Nu3LyIjI61ZW4XHnjKiqksIYX4PqN5Kg67vuiOwuQZ+jdT32ZOIqiqLhy8nTpyIWrVqoUuXLrh27RoWLVqEhIQErFq1Ct27d7dFjRUO1ykjqtqSLurxzfO3kXLln0n8LQe6MpAR0T1Z3FP222+/4Z133sGAAQPg7e1ti5oqPA5fElVNQgicXJOFvfPTYdQDe2an49kvfKQui4gqCItD2YEDB2xRR6XCif5EVU9WshHRk1MRtz8PAFC7owO6z/CUuCoiqkhKFco2b96MHj16QKVSYfPmzffc9sknn7RKYZUBIxlR1XBpby6ip6QiN80EpUaGTmO1aDnQhX+YEZFFShXK+vXrh4SEBPj6+qJfv34lbieTyWA0Gq1VW4XFGWVEVcflvbn4YUQyAMCnvgq953jBu65K4qqIqCIqVSgzmUzFfk/F4/AlUdVR61EHBLZQI7C5Bh1HaqFU8/eeiMrG4rMvV65cifz8/Lva9Xo9Vq5caZWiKjpO9CeqvIRJ4I+NWSjQF/6my5UyDFzhi8ffcWcgI6IHYnEoGzZsGDIyMu5qz8zMxLBhw6xSVEVX8HdvInvKiCoXXXwB1r+YhB3vpWH/x/+8DypU/F0nogdn8dmX/14Q8d9u3LgBrVZrlaIqC75NE1UesTtysGN6KvJ1AipHGTxrPdAFUYiI7lLqd5WWLVtCJpNBJpOha9euUCr/2dVoNCIuLo6Lx/6HQm5xRyQR2Rl9tgm7I9NwZlMOAMC/iRq9Z3vCoyYn8xORdZU6lN056zImJgZhYWFwcXEx36dWqxEcHIynn37a6gUSEUkl8bweP76djIwbRkAGPPKSG9q/5sbhSiKyiVKHsmnTpgEAgoODER4eDgcHB5sVRURkDzQucuSmmeAWoECvD71QvbVG6pKIqBKzeFJERESELeogIrILeToTHNwKpx64V1ei/2Jv+NRXm9uIiGylVKHM09MTFy5cgLe3Nzw8PO55VmFqaqrViiMiKi9CCJz9KQe7I9Pw5HxvBLcvHA0ICuGoABGVj1KFso8++giurq7m77nUAxFVJnk6E3bOSMP57YWT+U9tzDKHMiKi8lKqUPbvIcuhQ4faqpZKh9GVyP5dP5aHrRNTkZlghEwBdHjdDW2Hu0ldFhFVQRZPkvj9999x+vRp8+0ff/wR/fr1w7vvvgu9Xm/V4oiIbMVoEPhtYTrW/i8JmQlGuAcpMWiVL9q9ooVcyT+piKj8WRzKXnnlFVy4cAEAcOXKFYSHh8PJyQkbNmzAuHHjrF4gEZEtxB3Iw5GlmYAAmj7ljIiNfghsxrMriUg6FoeyCxcuoEWLFgCADRs2oFOnTlizZg2ioqLw3XffWbs+IiKbqNvZES2fc8GTC7zQfYYn1M48u5KIpGXxu5AQAqa/r+24a9cu9OzZEwAQFBSE5ORk61ZHRGQlOWlGRE9NRU6q0dwWOskDDbo5SVgVEdE/LF6nLCQkBB988AFCQ0Px66+/4vPPPwcAxMXFwc/Pz+oFVjRCCKlLIKL/iDuQh+2TU5CdZEJ+lgl9F3hLXRIR0V0sDmULFy7E4MGDsWnTJkyaNAl169YFAGzcuBHt27e3eoEVGZcOIZJWQX7hZP4Tq7IAAF61lXjkJZ5ZSUT2yeJQ1qxZsyJnX94xd+5cKBQKqxRFRPSgki7qsWVcKpIvGgAALQa6oPMYLVSOnDtGRPbJ4lB2x4kTJ3Du3DkAQOPGjdGqVSurFUVE9CCuHszD9yOSYNQDTp5ydH/fE3U6O0pdFhHRPVkcym7fvo3w8HD8+uuvcHd3BwCkp6fj8ccfx9q1a+Hj42PtGomILBLQTA0XHwW8aqvQfYYnnL3Zi09E9s/ifvw333wTWVlZ+PPPP5GamorU1FScOXMGOp0Ob731li1qJCK6r5sx+eYTbTQucgxa5Yf+n3kzkBFRhWFxKIuOjsZnn32GRo0amdsaN26MxYsXY/v27VYtriLiuZdE5cuQa8LOGalY8/xtnFqfbW538VXwZBsiqlAsHr40mUxQqVR3tatUKvP6ZVSIHwdEtpV4Vo8t41OQGlcAAMhMNN5nDyIi+2VxT1mXLl0wcuRI3Lp1y9x28+ZNjBo1Cl27drVqcURExREmgaPLdVg9KBGpcQVw8VXg2a980PEtrdSlERGVmcU9ZZ9++imefPJJBAcHIygoCABw/fp1NGnSBKtXr7Z6gURE/5aZUIBtk1Jx7Ug+AKBeV0eETfeAozvnjhFRxWZxKAsKCsLvv/+O3bt3m5fEaNSoEUJDQ61eHBHRf+kSjLh+PB8qRxm6THBH0/7OnDtGRJWCRaFs3bp12Lx5M/R6Pbp27Yo333zTVnUREZkJk4BMXhi8qrXQIOw9D1RvpYFHzbvntxIRVVSlnlP2+eef47nnnsPx48dx8eJFvPHGG3jnnXdsWVuFxGtfElnXrVP5iHo6EcmXDea2pk+5MJARUaVT6lD26aefYtq0aYiNjUVMTAy+/vprfPbZZ7asrcLjkApR2ZkKBA5+noE1Q24j+aIBv32ULnVJREQ2VepQduXKFURERJhvDxo0CAUFBYiPj7dJYURUdaXfKMC3Q2/jwGIdhBFo1MsJPWd5SV0WEZFNlXpOWX5+Ppydnc235XI51Go1cnNzbVIYEVU9Qgic/SkHu2amQZ8toHaR4YnJHmjc2/n+OxMRVXAWTfSfMmUKnJyczLf1ej1mzpwJrfaftYEWLFhgveqIqEq5sCsX295NBQBUa6lGrw+9oK1m8UniREQVUqnf7R577DHExsYWaWvfvj2uXLlivs05VET0IOo97oigEA1qttOg7XA3yJV8TyGiqqPUoWzv3r02LKPy4LmXRKVnNAicXJuFFuEuUKplkCtlGLDMB3IFwxgRVT0cF7AhfqwQlSw1zoAt41OQeNaAzIQCPP6OBwAwkBFRlWXxtS9tYfHixQgODoaDgwPatm2Lo0ePlmq/tWvXQiaToV+/frYtkIisRgiBUxuzsHJAIhLPGuDgJkdgC43UZRERSU7yULZu3TqMHj0a06ZNw++//47mzZsjLCwMt2/fvud+V69exdixY9GxY8dyqpSIHlROmhGbRqbg5/fSYMgVqNFWg6Hf+6HBE07335mIqJKTPJQtWLAAL730EoYNG4bGjRtjyZIlcHJywvLly0vcx2g0YvDgwZg+fTpq165djtUSUVndjMlHVP8EXNqTC7kS6DRGiwFf+cDVn7MoiIgAiUOZXq/HiRMnilzMXC6XIzQ0FIcOHSpxv/fffx++vr4YPnz4fZ8jPz8fOp2uyBcRlT8XXwUMuQJetZV4/ls/tBnmZr6eJRERlTGU7du3D88//zzatWuHmzdvAgBWrVqF/fv3W/Q4ycnJMBqN8PPzK9Lu5+eHhISEYvfZv38/li1bhq+++qpUzxEZGQmtVmv+CgoKsqhGS/Hal0T/yE4xmr/XBirx7Jc+eGGdH/waqSWsiojIPlkcyr777juEhYXB0dERJ0+eRH5+PgAgIyMDs2bNsnqB/5aZmYkXXngBX331Fby9vUu1z8SJE5GRkWH+un79uk1r/Deu20ZVlRACv3+TiS/D4hF34J+rfgQ200DlKPmsCSIiu2TxZI4PPvgAS5YswZAhQ7B27Vpze4cOHfDBBx9Y9Fje3t5QKBRITEws0p6YmAh/f/+7tr98+TKuXr2KPn36mNtMJhMAQKlUIjY2FnXq1Cmyj0ajgUbDM7uIyktWshHRk1MRtz8PAHB+ew5qdXCUuCoiIvtncSiLjY3FY489dle7VqtFenq6RY+lVqvRunVr7N6927yshclkwu7duzFixIi7tm/YsCFOnz5dpG3y5MnIzMzEokWLbD40SUT3dmlvLqKnpCI3zQSlRoZOY7Ro+ZyL1GUREVUIFocyf39/XLp0CcHBwUXa9+/fX6YzIUePHo2IiAiEhISgTZs2WLhwIbKzszFs2DAAwJAhQ1CtWjVERkbCwcEBTZo0KbK/u7s7ANzVTkTlx5Brwt556YhZlw0A8KmvQu85XvCuq5K4MiKiisPiUPbSSy9h5MiRWL58OWQyGW7duoVDhw5h7NixmDJlisUFhIeHIykpCVOnTkVCQgJatGiB6Oho8+T/a9euQS7nHBQie3b1UL45kIVEuKDjSHco1ZxTSURkCZmw8HRBIQRmzZqFyMhI5OTkACictzV27FjMmDHDJkVak06ng1arRUZGBtzc3Kz++HqjEZq/59aljR8PdwcHqz8HkT36ZW46anVwQHB7/swTEf1babOHxaHsDr1ej0uXLiErKwuNGzeGi0vFmDdSnqEsffx4aBnKqBLKTCjAL3PT0fVdDzh7KaQuh4jIrpU2e5R5KW21Wo3GjRuXdXciqqBid+Tg5+lpyNMVnvn85PzSLU9DRET3ZnEoe/zxx++5/taePXseqCAisk/6bBN2R6bhzKbCaQv+D6nw6JtaiasiIqo8LA5lLVq0KHLbYDAgJiYGZ86cQUREhLXqIiI7cutUPraMT0HGDSMgAx550RXtX9dCoeJkfiIia7E4lH300UfFtr/33nvIysp64IKIyL5c2puLTSOTIYyAW4ACPSM9ERTCuZJERNZmtbUmnn/+eSxfvtxaD1dh8dqXVNkEhWjgFqBAo55OiPjOn4GMiMhGyjzR/78OHToEB55pWASvfUkVkRACfx3KR812GshkMmhc5HhhrR8c3XmWJRGRLVkcyvr371/kthAC8fHxOH78eJkWjyUi+5GnM2HnjDSc356DrpPc0eo5VwBgICMiKgcWhzKttujZVnK5HA0aNMD777+Pbt26Wa0wIipf14/nYdvEVOjijZApAEMuh+KJiMqTRaHMaDRi2LBhaNq0KTw8PGxVExGVI6NB4OBnGTi8NBMQgHuQEr1meyKwmUbq0oiIqhSLQplCoUC3bt1w7tw5hjKiSiDtLwO2jEtBwp8GAEDTp5zRZYI71M683iwRUXmzePiySZMmuHLlCmrVqmWLeoioHOVmmJB43gAHNzm6TfdAgyecpC6JiKjKsjiUffDBB+aLj7du3RrOzs5F7rfF9SQrEs7CIXtnKhCQKwvPDA5spkHPWZ4Iaq2Bq7/VTsYmIqIyKPUYxfvvv4/s7Gz07NkTp06dwpNPPonq1avDw8MDHh4ecHd355Dmf3BBDLI3Vw/mYWnveCRd1JvbGvdyZiAjIrIDpX4nnj59Ol599VX88ssvtqyHiGygIF/gt0XpOLGy8Kobh5boeCFxIiI7U+pQdmel+k6dOtmsGCKyvuRLhZP5ky4UTuZvMdAFncfwQuJERPbGojELrlBPVHEIIXByTRZ+XZCBgnwBJ085ur/viTqdHaUujYiIimFRKKtfv/59g1lqauoDFURE1nF+ew52R6YDAGp1dECPGZ5w9ubK/ERE9sqiUDZ9+vS7VvSnonhBcrIXDcKccGZTDup0dkDL51zY001EZOcsCmUDBw6Er6+vrWqpdPghSOXJkGvCsa8z0WaYG5QaGeQKGZ75wps/h0REFUSpQxnf2InsV+I5PbaMS0FqXAHy0k3oMqFweRr+3hIRVRwWn31JRPZDmASORWVi38cZMBUAzj5y1H6ME/mJiCqiUocyk8lkyzqIyEKZCQXYNikV147kAwDqdXVE2HQPOLpzMj8RUUXEZbyJKqC/juRh86gU5OlMUDnK0GW8O5o+7czhSiKiCoyhzMo4yEvlwaOGEkII+D+kQq/ZXvAMVkldEhERPSCGMhtinwVZky6+AG4Bhb+ybgFKDFzhC686KihU/EkjIqoMSn1BciKShqlA4ODnGfiqRzyu/JZrbvdtqGYgIyKqRBjKiOxY+o0CfDv0Ng4s1sFUAMQdyJO6JCIishEOXxLZISEEzm7Jwa4P0qDPFlC7yPDEZA807u0sdWlERGQjDGVEdiZPZ8LOGWk4vz0HAFCtpRq9PvSCthp/XYmIKjO+y1sZF9mlB3XtaB7Ob8+BTAF0eN0NbYe7Qa7k3DEiosqOocyGuGYUlUX9UCe0e8WA2p0cENhMI3U5RERUTjjRn0hiqXEGbHwtCdnJRnPbo29qGciIiKoYhjIiiQghcGpjFlYOSETcvjzsmZ0udUlERCQhDl8SSSAnzYgd09JwaU/humM12mrQeYxW4qqIiEhKDGVE5ezqwTxsm5SC7CQT5Ergsbe1CBniCpmccxCJiKoyhjIr47mXdC/no3Pw09gUAIBXbSV6zfGCX0O1xFUREZE9YCizIfZ70H/VfswB7jWUCG7vgM5jtFA5clonEREVYigjsiEhBC7uykW9ro6QyWVQO8kRscEPameGMSIiKoqfDEQ2kpVsxHevJePHUSn4fU2WuZ2BjIiIisOeMiIbuLQ3F9FTUpGbZoJSI4NCzcFsIiK6N4YyIisy5Jrwy9x0nFqfDQDwqa9C7zle8K6rkrgyIiKydwxlVsZrX1Zdt8/r8dM7KUiNKwAAhES4ouNILZTsJSMiolJgKLMhXvuyajEVAOnXC+DsI0fPmV4Ibu8gdUlERFSBMJQRPYCCfAGlpjB8+zdRo888LwSFaODorpC4MiIiqmh4GhhRGcXuyMGXYbdwO1Zvbqsf6sRARkREZcJQRmQhfbYJ2yenYPOYFGQnm3AsKlPqkoiIqBLg8CWRBW6dyseW8SnIuGEEZMAjL7mh/WtuUpdFRESVAEOZlfHcy8rJVCBw+CsdDi7RQRgBtwAFen3oheqtNVKXRkRElQRDmQ3x3MvK4+zWHBxYrAMANOrlhNBJHnBw4+g/ERFZD0MZUSk07u2Ei7tz0aCbIxr3dpa6HCIiqoT4pz5RMfJ0Juydnw5DrgkAIFfI8NTH3gxkRERkM+wpI/qP68fzsG1iKnTxRhTkC4S+6yF1SUREVAUwlBH9zWgQOLA4A0eWZQICcA9SonFvJ6nLIiKiKoKhzMp47cuKKTXOgC3jU5B41gAAaNrfGV0muEPtxBF+IiIqHwxlNsRrX1YMl3/NxU9jU2DIFXBwk6PbdA80eII9ZEREVL4YyqjK822ggkIlQ0AzNXrO9ISrP38tiIio/PHTh6qklCsGeNVWAQBc/ZUY/I0vPGoqIZOzd5OIiKTBCTNUpRTkC+yZnYblfRNwaW+uud2zloqBjIiIJGUXoWzx4sUIDg6Gg4MD2rZti6NHj5a47VdffYWOHTvCw8MDHh4eCA0Nvef2RHckXdRj1cBEnFiVBQgg4bRe6pKIiIjMJA9l69atw+jRozFt2jT8/vvvaN68OcLCwnD79u1it9+7dy+ee+45/PLLLzh06BCCgoLQrVs33Lx5s5wrLx7PvbQ/Qgj8/k0mVoUnIvmiAU6ecvT/1BuPvqmVujQiIiIzmZB4DYe2bdvi4YcfxqeffgoAMJlMCAoKwptvvokJEybcd3+j0QgPDw98+umnGDJkyH231+l00Gq1yMjIgJub2wPX/1/peXnwmD0bAKCfPBkqhcLqz0Gll5VsRPTkVMTtzwMA1OrogB4zPOHszeNCRETlo7TZQ9KJ/nq9HidOnMDEiRPNbXK5HKGhoTh06FCpHiMnJwcGgwGenp7F3p+fn4/8/HzzbZ1O92BFU4VyKyYfcfvzoNTI0GmMFi2fc+FSJUREZJckHb5MTk6G0WiEn59fkXY/Pz8kJCSU6jHGjx+PwMBAhIaGFnt/ZGQktFqt+SsoKOiB66aKo36oEzq+pcUL6/zQapArAxkREdktyeeUPYgPP/wQa9euxQ8//AAHB4dit5k4cSIyMjLMX9evXy/nKqk8JZ7V49uI28hKMprbHnnZDd51VRJWRUREdH+SDl96e3tDoVAgMTGxSHtiYiL8/f3vue+8efPw4YcfYteuXWjWrFmJ22k0Gmg0GqvUS/ZLmASORmVi/8cZMBUAvy5IR69IL6nLIiIiKjVJe8rUajVat26N3bt3m9tMJhN2796Ndu3albjfnDlzMGPGDERHRyMkJKQ8SiU7posvwPoXk/DbgsJAVq+rI7qMd5e6LCIiIotIvqL/6NGjERERgZCQELRp0wYLFy5EdnY2hg0bBgAYMmQIqlWrhsjISADA7NmzMXXqVKxZswbBwcHmuWcuLi5wcXGR7HXcwQuSl6/YHTn4eXoa8nQmqBxl6DLBHU37O3PuGBERVTiSh7Lw8HAkJSVh6tSpSEhIQIsWLRAdHW2e/H/t2jXI5f906H3++efQ6/V45plnijzOtGnT8N5775Vn6ffFYGBbZ37MxvZJqQAA/yZq9J7tCY+anDtGREQVk+TrlJU3W69TlpabC885cwAAhilToJRX6HMp7Jo+x4TVAxNRL9QJ7V9zg0LFEExERPanQqxTRmQJU4HA2a05eKiPE2RyGdROcgzZ4A+lhmGMiIgqPoYyqhDSbxRg64QU3IrRIy/DhJAhrgDAQEZERJUGQxnZNSEEzv6Ug10z06DPFlC7yODszSFhIiKqfBjKrKxKTdCzsTydCTtnpOH89hwAQLWWavT60AvaavyxJSKiyoefbjbEgbWyuxmTj5/GpiAzwQiZAujwuhvaDneDXMn/VSIiqpwYysguKdUyZCcb4R6kRK/ZnghsxqsyEBFR5cZQRnZDn22C2rlwvphfYzWe+sQb1VtpzG1ERESVGT/tSHJCCJzamIUvnohH4nm9ub12R0cGMiIiqjL4iUeSykkzYtPIFPz8XuGlkk6ty5K6JCIiIklw+NLKqtgFEh5I3IE8bJ+cguwkE+RKoONILR6OcJW6LCIiIkkwlNkQr31ZvIJ8gd8WpePEysJeMc9aSvSe4wW/RmqJKyMiIpIOQxmVu7Nbss2BrMVAF3Qeo4XKkSPpRERUtTGUUblr+pQz/jqcj8a9nFCns6PU5RAREdkFdk+QzWUlG7FzRioMuSYAgEwuQ5+5XgxkRERE/8KeMrKpy3tzET01FTmpJsjkMoRO8pC6JCIiIrvEUGZlPPeykCHXhL3z0hGzLhsA4FNfhRbhLhJXRUREZL8Yymyoqp57mXhOjy3jUpAaVwAACIlwQceR7lCqq+r/CBER0f0xlJFVxf6cgy3jUmAqAJx95Og50wvB7R2kLouIiMjuMZSRVVVrUXityqAQDcKme8DRXSF1SURERBUCQxk9sMSzevg1Llz41cVXgSEb/OAWoODiuURERBbgkhhUZvpsE7ZPTsXKAYm4uCfX3K4NVDKQERERWYg9ZVZWVa59eetUPrZOSEX69QJABqReNQDgumNERERlxVBmQ5Wxt8hUIHD4Kx0OLtFBGAG3AAV6feiF6q01UpdGRERUoTGUUaml3yjA1gkpuBWjBwA06umE0MkecHDjKDgREdGDYiijUku6YMCtGD3ULjI8MdkDjXs7S10SERFRpcFQRvckhDAPw9br4ojHx7mjbhdHuFfnjw4REZE1cdyJSnT9eB5WDkhEZmKBuS1kiCsDGRERkQ0wlFlZZTj30mgQ2LcoHWuHJeH2OQMOfKqTuiQiIqJKj10eVETqVQO2jk9Bwp8GAEDTp5zRZYK7tEURERFVAQxlBKBw7tgf32Xjl9npMOQKOLjJ0e09DzTo5iR1aURERFUCQxkBAE5tyMbO99MAADXaatBzpidc/fnjQUREVF74qUsAgIf6OCFmbRYa93HCwxGukMkr38K3RERE9oyhrIoqyBc4/UMWWgxwgUwug8pRjiHr/SBXMowRERFJgaHMyirCtS+TLxmwZVwKki4YUJAn8PBQNwBgICMiIpIQQ5mN2GO8EULg5Jos7J2fDqMecPKUwzNYJXVZREREBIayKiMr2YjoyamI258HAKjV0QE9ZnjC2VshcWVEREQEMJRVCX8dzsOWcSnISTVBoQY6j3VHy+dczJdPIiIiIukxlFUBDu5y5OlM8KmvQu85XvCuyyFLIiIie8NQVknlZhjhqC0cmvRrqMazX/ogsIUGSjV7x4iIiOwRr31pZVKfeylMAkeX6/BFaDwSz+rN7TXaODCQERER2TH2lNmIFPO1MhMKsG1SKq4dyQcAnN2aDb/G6nKvg4iIiCzHUFZJxO7Iwc/T05CnM0HlKEOX8e5o+rSz1GURERFRKTGUVXD6bBN2R6bjzKZsAID/Qyr0mu3F9ceIiIgqGIayCu7s1pzCQCYDHnnRFe1f10Kh4twxIiKiioahrIJr/owz4v/Qo0k/JwSFOEhdDhEREZURz760Mltf+zL9RgG2TkyBPscEAJDJZejxgScDGRERUQXHnjIbsfYAohACZ7fkYNcHadBnC2hc5Qh918PKz0JERERSYSirAPJ0JuyckYbz23MAANVaqvFwhKvEVREREZE1MZTZuevH87BtYip08UbIFECH193Qdrgb5EpO5iciKg9CCBQUFMBoNEpdCtkphUIBpVL5wGuUMpTZsT83Z2PbpFRAAO5BSvSa7YnAZhqpyyIiqjL0ej3i4+ORk5MjdSlk55ycnBAQEAC1uuyLtjOU2bGa7Rzg6C5H3c6O6DLBHWpnnpdBRFReTCYT4uLioFAoEBgYCLVaLcnVWsi+CSGg1+uRlJSEuLg41KtXD3J52T6vGcrsiBACN47nI+jhwjMpXXwUGPqDP1y8FRJXRkRU9ej1ephMJgQFBcHJyUnqcsiOOTo6QqVS4a+//oJer4eDQ9lWRGDXi5WVdUGMnDQjNo1MwdphSYjd+U83OQMZEZG0ytrrQVWLNX5O2FNmI5Z0cccdyMP2ySnITjJBrgRyUjiZlIiIqKphKJNQQb7AbwvTcWJVFgDAq7YSvWZ7wa9R2ScJEhERUcXEUCaRpIt6bBmXiuSLBgBAi4Eu6DxGC5Uju8mJiIiqIiYAiehuGpF80QAnTzn6f+qNJyZ7MJAREZFVHTp0CAqFAr169brrvr1790ImkyE9Pf2u+4KDg7Fw4cIibb/88gt69uwJLy8vODk5oXHjxhgzZgxu3rxpo+qBvLw8vPHGG/Dy8oKLiwuefvppJCYm3nOfxMREDB06FIGBgXByckL37t1x8eLFIttcvnwZTz31FHx8fODm5oYBAwbc9bgzZ85E+/bt4eTkBHd3d2u/tGIxBZQjk/Gf0wDqdHbEE1M9MPR7f9Tp7ChhVUREVFktW7YMb775Jn777TfcunWrzI/zxRdfIDQ0FP7+/vjuu+9w9uxZLFmyBBkZGZg/f74VKy5q1KhR+Omnn7Bhwwb8+uuvuHXrFvr371/i9kII9OvXD1euXMGPP/6IkydPombNmggNDUV2djYAIDs7G926dYNMJsOePXtw4MAB6PV69OnTByaTyfxYer0ezz77LF577TWbvb7/4vCllZV0QfJLe3Oxd146wpf6wNW/8L+9xQCX8iyNiIgekBACOQaDJM/tpFJZdBJZVlYW1q1bh+PHjyMhIQFRUVF49913LX7eGzdu4K233sJbb72Fjz76yNweHByMxx57rNieNmvIyMjAsmXLsGbNGnTp0gUAsGLFCjRq1AiHDx/GI488ctc+Fy9exOHDh3HmzBk89NBDAIDPP/8c/v7++Pbbb/Hiiy/iwIEDuHr1Kk6ePAk3NzcAwNdffw0PDw/s2bMHoaGhAIDp06cDAKKiomzy+opjF6Fs8eLFmDt3LhISEtC8eXN88sknaNOmTYnbb9iwAVOmTMHVq1dRr149zJ49Gz179izHiu/vzq+NIdeEX+am49T6woR++CsdnpjiKV1hRERUZjkGA1wiIyV57qyJE+FswWrx69evR8OGDdGgQQM8//zzePvttzFx4kSLF8DdsGED9Ho9xo0bV+z99xra69GjB/bt21fi/TVr1sSff/5Z7H0nTpyAwWAwhyQAaNiwIWrUqIFDhw4VG8ry8/MBoMg6YXK5HBqNBvv378eLL76I/Px8yGQyaDT/XCHHwcEBcrkc+/fvL/J85U3y4ct169Zh9OjRmDZtGn7//Xc0b94cYWFhuH37drHbHzx4EM899xyGDx+OkydPol+/fujXrx/OnDlTzpXfX+JZPVYOSDQHspAIVzw+3kPiqoiIqCpYtmwZnn/+eQBA9+7dkZGRgV9//dXix7l48SLc3NwQEBBg8b5Lly5FTExMiV/btm0rcd+EhASo1eq7Qp+fnx8SEhKK3edOaJs4cSLS0tKg1+sxe/Zs3LhxA/Hx8QCARx55BM7Ozhg/fjxycnKQnZ2NsWPHwmg0mreRiuQ9ZQsWLMBLL72EYcOGAQCWLFmCrVu3Yvny5ZgwYcJd2y9atAjdu3fHO++8AwCYMWMGdu7ciU8//RRLliwp19pLIhNAx3NNsHpQIkwFgIuvAj1meiK4XdlW+CUiIvvgpFIha+JEyZ67tGJjY3H06FH88MMPAAClUonw8HAsW7YMnTt3tuh5hRBlvrxUtWrVyrRfWalUKnz//fcYPnw4PD09oVAoEBoaih49epinF/n4+GDDhg147bXX8PHHH0Mul+O5555Dq1atJF8oWNJQptfrceLECUz81w+4XC5HaGgoDh06VOw+hw4dwujRo4u0hYWFYdOmTcVun5+fb+7OBACdTvfghd9H+0uN0f2PEJgA1OvqiLDpHnB058r8REQVnUwms2gIUSrLli1DQUEBAgMDzW1CCGg0Gnz66afQarXm+VQZGRl39Ualp6dDq9UCAOrXr4+MjAzEx8db3Fv2IMOX/v7+0Ov1SE9PL1JfYmIi/P39S3zM1q1bIyYmBhkZGdDr9fDx8UHbtm0REhJi3qZbt264fPkykpOToVQq4e7uDn9/f9SuXdui12dtkkbC5ORkGI1G+Pn5FWm/V9dkQkKCRdtHRkZCq9Wav4KCgqxT/D0cqR2LG55JCJvugb4LvRjIiIio3BQUFGDlypWYP39+kaHCU6dOITAwEN9++y0AmC+cfeLEiSL7X7lyBRkZGahfvz4A4JlnnoFarcacOXOKfb57TfR/kOHL1q1bQ6VSYffu3ea22NhYXLt2De3atbvv/4NWq4WPjw8uXryI48ePo2/fvndt4+3tDXd3d+zZswe3b9/Gk08+ed/HtSXJhy9tbeLEiUV61nQ6nU2DmZeTE6KHDgIiZGhWh2dXEhFR+dqyZQvS0tIwfPhwc2/XHU8//TSWLVuGV199Fa6urnjxxRcxZswYKJVKNG3aFNevX8f48ePxyCOPoH379gCAoKAgfPTRRxgxYgR0Oh2GDBmC4OBg3LhxAytXroSLi0uJy2I8yPClVqvF8OHDMXr0aHh6esLNzQ1vvvkm2rVrV2SSf8OGDREZGYmnnnoKQOGJCT4+PqhRowZOnz6NkSNHol+/fujWrZt5nztncfr4+ODQoUMYOXIkRo0ahQYNGpi3uXbtGlJTU3Ht2jUYjUbExMQAAOrWrQsXFxt9vgsJ5efnC4VCIX744Yci7UOGDBFPPvlksfsEBQWJjz76qEjb1KlTRbNmzUr1nBkZGQKAyMjIKEvJRERUReTm5oqzZ8+K3NxcqUuxSO/evUXPnj2Lve/IkSMCgDh16pQQovA1Tps2TTRs2FA4OjqKWrVqiZdfflkkJSXdte/OnTtFWFiY8PDwEA4ODqJhw4Zi7Nix4tatWzZ7Lbm5ueL1118XHh4ewsnJSTz11FMiPj6+yDYAxIoVK8y3Fy1aJKpXry5UKpWoUaOGmDx5ssjPzy+yz/jx44Wfn59QqVSiXr16Yv78+cJkMhXZJiIiQgC46+uXX34psdaSfl5Kmz1kf78gybRt2xZt2rTBJ598AgAwmUyoUaMGRowYUexE//DwcOTk5OCnn34yt7Vv3x7NmjUr1UR/nU4HrVaLjIwM83g6ERHRf+Xl5SEuLg61atUqssQCUXHu9fNS2uwh+fDl6NGjERERgZCQELRp0wYLFy5Edna2+WzMIUOGoFq1aoj8e12YkSNHolOnTpg/fz569eqFtWvX4vjx4/jyyy+lfBlERERED0TyUBYeHo6kpCRMnToVCQkJaNGiBaKjo82T+a9du1bkFNX27dtjzZo1mDx5Mt59913Uq1cPmzZtQpMmTaR6CUREREQPTPLhy/LG4UsiIioNDl+SJawxfCn5iv5ERERExFBGRER0T1VsQInKyBo/JwxlRERExVD9fVmjnJwciSuhiuDOz4nKgsth/ZfkE/2JiIjskUKhgLu7O27fvg0AcHJyKvM1IKnyEkIgJycHt2/fhru7OxSKsl/Fh6GMiIioBHeusXgnmBGV5M71Mx8EQxkREVEJZDIZAgIC4OvrC4PBIHU5ZKdUKtUD9ZDdwVBGRER0HwqFwiofukT3won+RERERHaAoYyIiIjIDjCUEREREdmBKjen7M7ibjqdTuJKiIiIqCq4kznut8BslQtlmZmZAICgoCCJKyEiIqKqJDMzE1qttsT7q9wFyU0mE27dugVXV1ebLQKo0+kQFBSE69ev86LnEuOxsA88DvaDx8I+8DjYj/I4FkIIZGZmIjAwEHJ5yTPHqlxPmVwuR/Xq1cvludzc3PjLZid4LOwDj4P94LGwDzwO9sPWx+JePWR3cKI/ERERkR1gKCMiIiKyAwxlNqDRaDBt2jRoNBqpS6nyeCzsA4+D/eCxsA88DvbDno5FlZvoT0RERGSP2FNGREREZAcYyoiIiIjsAEMZERERkR1gKCMiIiKyAwxlZbR48WIEBwfDwcEBbdu2xdGjR++5/YYNG9CwYUM4ODigadOm2LZtWzlVWvlZciy++uordOzYER4eHvDw8EBoaOh9jx2VjqW/E3esXbsWMpkM/fr1s22BVYilxyI9PR1vvPEGAgICoNFoUL9+fb5HWYGlx2HhwoVo0KABHB0dERQUhFGjRiEvL6+cqq28fvvtN/Tp0weBgYGQyWTYtGnTfffZu3cvWrVqBY1Gg7p16yIqKsrmdQIABFls7dq1Qq1Wi+XLl4s///xTvPTSS8Ld3V0kJiYWu/2BAweEQqEQc+bMEWfPnhWTJ08WKpVKnD59upwrr3wsPRaDBg0SixcvFidPnhTnzp0TQ4cOFVqtVty4caOcK69cLD0Od8TFxYlq1aqJjh07ir59+5ZPsZWcpcciPz9fhISEiJ49e4r9+/eLuLg4sXfvXhETE1POlVculh6Hb775Rmg0GvHNN9+IuLg4sWPHDhEQECBGjRpVzpVXPtu2bROTJk0S33//vQAgfvjhh3tuf+XKFeHk5CRGjx4tzp49Kz755BOhUChEdHS0zWtlKCuDNm3aiDfeeMN822g0isDAQBEZGVns9gMGDBC9evUq0ta2bVvxyiuv2LTOqsDSY/FfBQUFwtXVVXz99de2KrFKKMtxKCgoEO3btxdLly4VERERDGVWYumx+Pzzz0Xt2rWFXq8vrxKrBEuPwxtvvCG6dOlSpG306NGiQ4cONq2zqilNKBs3bpx46KGHirSFh4eLsLAwG1ZWiMOXFtLr9Thx4gRCQ0PNbXK5HKGhoTh06FCx+xw6dKjI9gAQFhZW4vZUOmU5Fv+Vk5MDg8EAT09PW5VZ6ZX1OLz//vvw9fXF8OHDy6PMKqEsx2Lz5s1o164d3njjDfj5+aFJkyaYNWsWjEZjeZVd6ZTlOLRv3x4nTpwwD3FeuXIF27ZtQ8+ePculZvqHlJ/ZVe6C5A8qOTkZRqMRfn5+Rdr9/Pxw/vz5YvdJSEgodvuEhASb1VkVlOVY/Nf48eMRGBh41y8glV5ZjsP+/fuxbNkyxMTElEOFVUdZjsWVK1ewZ88eDB48GNu2bcOlS5fw+uuvw2AwYNq0aeVRdqVTluMwaNAgJCcn49FHH4UQAgUFBXj11Vfx7rvvlkfJ9C8lfWbrdDrk5ubC0dHRZs/NnjKqsj788EOsXbsWP/zwAxwcHKQup8rIzMzECy+8gK+++gre3t5Sl1PlmUwm+Pr64ssvv0Tr1q0RHh6OSZMmYcmSJVKXVqXs3bsXs2bNwmeffYbff/8d33//PbZu3YoZM2ZIXRqVI/aUWcjb2xsKhQKJiYlF2hMTE+Hv71/sPv7+/hZtT6VTlmNxx7x58/Dhhx9i165daNasmS3LrPQsPQ6XL1/G1atX0adPH3ObyWQCACiVSsTGxqJOnTq2LbqSKsvvREBAAFQqFRQKhbmtUaNGSEhIgF6vh1qttmnNlVFZjsOUKVPwwgsv4MUXXwQANG3aFNnZ2Xj55ZcxadIkyOXsQykvJX1mu7m52bSXDGBPmcXUajVat26N3bt3m9tMJhN2796Ndu3aFbtPu3btimwPADt37ixxeyqdshwLAJgzZw5mzJiB6OhohISElEeplZqlx6Fhw4Y4ffo0YmJizF9PPvkkHn/8ccTExCAoKKg8y69UyvI70aFDB1y6dMkcjAHgwoULCAgIYCAro7Ich5ycnLuC152gLHiJ6nIl6We2zU8lqITWrl0rNBqNiIqKEmfPnhUvv/yycHd3FwkJCUIIIV544QUxYcIE8/YHDhwQSqVSzJs3T5w7d05MmzaNS2JYiaXH4sMPPxRqtVps3LhRxMfHm78yMzOlegmVgqXH4b949qX1WHosrl27JlxdXcWIESNEbGys2LJli/D19RUffPCBVC+hUrD0OEybNk24urqKb7/9Vly5ckX8/PPPok6dOmLAgAFSvYRKIzMzU5w8eVKcPHlSABALFiwQJ0+eFH/99ZcQQogJEyaIF154wbz9nSUx3nnnHXHu3DmxePFiLolh7z755BNRo0YNoVarRZs2bcThw4fN93Xq1ElEREQU2X79+vWifv36Qq1Wi4ceekhs3bq1nCuuvCw5FjVr1hQA7vqaNm1a+RdeyVj6O/FvDGXWZemxOHjwoGjbtq3QaDSidu3aYubMmaKgoKCcq658LDkOBoNBvPfee6JOnTrCwcFBBAUFiddff12kpaWVf+GVzC+//FLs+/6d//+IiAjRqVOnu/Zp0aKFUKvVonbt2mLFihXlUqtMCPaLEhEREUmNc8qIiIiI7ABDGREREZEdYCgjIiIisgMMZURERER2gKGMiIiIyA4wlBERERHZAYYyIiIiIjvAUEZERERkBxjKiKjcREVFwd3dXeoyykwmk2HTpk333Gbo0KHo169fudRDRJULQxkRWWTo0KGQyWR3fV26dEnq0hAVFWWuRy6Xo3r16hg2bBhu375tlcePj49Hjx49AABXr16FTCZDTExMkW0WLVqEqKgoqzxfSd577z3z61QoFAgKCsLLL7+M1NRUix6HAZLIviilLoCIKp7u3btjxYoVRdp8fHwkqqYoNzc3xMbGwmQy4dSpUxg2bBhu3bqFHTt2PPBj+/v733cbrVb7wM9TGg899BB27doFo9GIc+fO4X//+x8yMjKwbt26cnl+IrI+9pQRkcU0Gg38/f2LfCkUCixYsABNmzaFs7MzgoKC8PrrryMrK6vExzl16hQef/xxuLq6ws3NDa1bt8bx48fN9+/fvx8dO3aEo6MjgoKC8NZbbyE7O/uetclkMvj7+yMwMBA9evTAW2+9hV27diE3Nxcmkwnvv/8+qlevDo1GgxYtWiA6Otq8r16vx4gRIxAQEAAHBwfUrFkTkZGRRR77zvBlrVq1AAAtW7aETCZD586dARTtffryyy8RGBgIk8lUpMa+ffvif//7n/n2jz/+iFatWsHBwQG1a9fG9OnTUVBQcM/XqVQq4e/vj2rVqiE0NBTPPvssdu7cab7faDRi+PDhqFWrFhwdHdGgQQMsWrTIfP97772Hr7/+Gj/++KO5123v3r0AgOvXr2PAgAFwd3eHp6cn+vbti6tXr96zHiJ6cAxlRGQ1crkcH3/8Mf788098/fXX2LNnD8aNG1fi9oMHD0b16tVx7NgxnDhxAhMmTIBKpQIAXL58Gd27d8fTTz+NP/74A+vWrcP+/fsxYsQIi2pydHSEyWRCQUEBFi1ahPnz52PevHn4448/EBYWhieffBIXL14EAHz88cfYvHkz1q9fj9jYWHzzzTcIDg4u9nGPHj0KANi1axfi4+Px/fff37XNs88+i5SUFPzyyy/mttTUVERHR2Pw4MEAgH379mHIkCEYOXIkzp49iy+++AJRUVGYOXNmqV/j1atXsWPHDqjVanObyWRC9erVsWHDBpw9exZTp07Fu+++i/Xr1wMAxo4diwEDBqB79+6Ij49HfHw82rdvD4PBgLCwMLi6umLfvn04cOAAXFxc0L17d+j1+lLXRERlIIiILBARESEUCoVwdnY2fz3zzDPFbrthwwbh5eVlvr1ixQqh1WrNt11dXUVUVFSx+w4fPly8/PLLRdr27dsn5HK5yM3NLXaf/z7+hQsXRP369UVISIgQQojAwEAxc+bMIvs8/PDD4vXXXxdCCPHmm2+KLl26CJPJVOzjAxA//PCDEEKIuLg4AUCcPHmyyDYRERGib9++5tt9+/YV//vf/8y3v/jiCxEYGCiMRqMQQoiuXbuKWbNmFXmMVatWiYCAgGJrEEKIadOmCblcLpydnYWDg4MAIACIBQsWlLiPEEK88cYb4umnny6x1jvP3aBBgyL/B/n5+cLR0VHs2LHjno9PRA+Gc8qIyGKPP/44Pv/8c/NtZ2dnAIW9RpGRkTh//jx0Oh0KCgqQl5eHnJwcODk53fU4o0ePxosvvohVq1aZh+Dq1KkDoHBo848//sA333xj3l4IAZPJhLi4ODRq1KjY2jIyMuDi4gKTyYS8vDw8+uijWLp0KXQ6HW7duoUOHToU2b5Dhw44deoUgMKhxyeeeAINGjRA9+7d0bt3b3Tr1u2B/q8GDx6Ml156CZ999hk0Gg2++eYbDBw4EHK53Pw6Dxw4UKRnzGg03vP/DQAaNGiAzZs3Iy8vD6tXr0ZMTAzefPPNItssXrwYy5cvx7Vr15Cbmwu9Xo8WLVrcs95Tp07h0qVLcHV1LdKel5eHy5cvl+F/gIhKi6GMiCzm7OyMunXrFmm7evUqevfujddeew0zZ86Ep6cn9u/fj+HDh0Ov1xcbLt577z0MGjQIW7duxfbt2zFt2jSsXbsWTz31FLKysvDKK6/grbfeumu/GjVqlFibq6srfv/9d8jlcgQEBMDR0REAoNPp7vu6WrVqhbi4OGzfvh27du3CgAEDEBoaio0bN95335L06dMHQghs3boVDz/8MPbt24ePPvrIfH9WVhamT5+O/v3737Wvg4NDiY+rVqvNx+DDDz9Er169MH36dMyYMQMAsHbtWowdOxbz589Hu3bt4Orqirlz5+LIkSP3rDcrKwutW7cuEobvsJeTOYgqK4YyIrKKEydOwGQyYf78+eZeoDvzl+6lfv36qF+/PkaNGoXnnnsOK1aswFNPPYVWrVrh7Nmzd4W/+5HL5cXu4+bmhsDAQBw4cACdOnUytx84cABt2rQpsl14eDjCw8PxzDPPoHv37khNTYWnp2eRx7szf8toNN6zHgcHB/Tv3x/ffPMNLl26hAYNGqBVq1bm+1u1aoXY2FiLX+d/TZ48GV26dMFrr71mfp3t27fH66+/bt7mvz1darX6rvpbtWqFdevWwdfXF25ubg9UExFZhhP9icgq6tatC4PBgE8++QRXrlzBqlWrsGTJkhK3z83NxYgRI7B371789ddfOHDgAI4dO2Yelhw/fjwOHjyIESNGICYmBhcvXsSPP/5o8UT/f3vnnXcwe/ZsrFu3DrGxsZgwYQJiYmIwcuRIAMCCBQvw7bff4vz587hw4QI2bNgAf3//Yhe89fX1haOjI6Kjo5GYmIiMjIwSn3fw4MHYunUrli9fbp7gf8fUqVOxcuVKTJ8+HX/++SfOnTuHtWvXYvLkyRa9tnbt2qFZs2aYNWsWAKBevXo4fvw4duzYgQsXLmDKlCk4duxYkX2Cg4Pxxx9/IDY2FsnJyTAYDBg8eDC8vb3Rt29f7Nu3D3Fxcdi7dy/eeust3Lhxw6KaiMgyDGVEZBXNmzfHggULMHv2bDRp0gTffPNNkeUk/kuhUCAlJQVDhgxB/fr1MWDAAPTo0QPTp08HADRr1gy//vorLly4gI4dO6Jly5aYOnUqAgMDy1zjW2+9hdGjR2PMmDFo2rQpoqOjsXnzZtSrVw9A4dDnnDlzEBISgocffhhXr17Ftm3bzD1//6ZUKvHxxx/jiy++QGBgIPr27Vvi83bp0gWenp6IjY3FoEGDitwXFhaGLVu24Oeff8bDDz+MRx55BB999BFq1qxp8esbNWoUli5diuvXr+OVV15B//79ER4ejrZt2yIlJaVIrxkAvPTSS2jQoAFCQkLg4+ODAwcOwMnJCb/99htq1KiB/v37o1GjRhg+fDjy8vLYc0ZkYzIhhJC6CCIiIqKqjj1lRERERHaAoYyIiIjIDjCUEREREdkBhjIiIiIiO8BQRkRERGQHGMqIiIiI7ABDGREREZEdYCgjIiIisgMMZURERER2gKGMiIiIyA4wlBERERHZgf8DxT6K92jvsBIAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 700x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y_probs = model_pipeline.predict_proba(X_test)[:, 1]\n",
+    "fpr, tpr, thresholds, auc = compute_roc_metrics(y_test, y_probs)\n",
+    "plot_roc_curve(fpr, tpr, auc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fffb6a9f-5d4e-4f6c-9b14-5eddf38b3aaf",
+   "metadata": {},
+   "source": [
+    "The model achieves an AUC of 99.2%, which is very high. This result is largely driven by the model’s strong ability to correctly identify non-fraudulent transactions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "23e75742-6404-421d-84e3-da7f2691e2c5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "feature_names = get_feature_names(preprocessor, low_card, high_card, numeric_cols)\n",
+    "plot_feature_importance(model_pipeline, feature_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "b1a577e7-0afd-41ae-8056-d3f5382096aa",
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  12.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=5, model__n_estimators=200, model__subsample=0.9; total time=   8.6s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   5.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.75; total time=  24.2s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=   7.8s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  11.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.5s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  12.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.4s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  12.1s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=  10.7s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=200, model__subsample=0.75; total time=   8.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   7.5s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.9; total time=   7.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  19.8s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=   9.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=   8.6s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.75; total time=  17.7s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.75; total time=   7.0s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.75; total time=  12.9s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.9; total time=   6.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   5.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.75; total time=  18.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  23.0s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.6; total time=  17.7s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.75; total time=  14.2s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  13.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.9; total time=   8.0s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=  11.0s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.75; total time=  15.7s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  21.3s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.9; total time=  11.2s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.75; total time=  12.3s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.9; total time=  14.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.75; total time=   7.1s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  12.4s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.9; total time=   6.2s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.6; total time=   7.7s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.6; total time=   5.8s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.75; total time=  23.6s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  19.5s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   6.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  13.5s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  23.4s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  24.4s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.9; total time=   7.0s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  18.3s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.9; total time=  12.0s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=   8.4s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=   9.8s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.9; total time=  14.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.6; total time=   7.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  10.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=5, model__n_estimators=200, model__subsample=0.9; total time=   8.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.75; total time=  18.8s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.75; total time=   6.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.75; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=   9.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.6; total time=  20.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.9; total time=   6.0s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  24.1s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  23.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.9; total time=   7.1s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.6; total time=  11.1s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  10.3s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.75; total time=  19.8s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.6; total time=   6.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.6; total time=   7.7s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  12.0s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.6; total time=   7.8s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.6; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.75; total time=  23.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  19.3s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.4s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  11.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.9; total time=   5.1s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.9; total time=   7.5s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=  10.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=200, model__subsample=0.75; total time=   9.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.75; total time=  14.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  19.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   5.4s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  10.1s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.75; total time=  19.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.75; total time=   6.7s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.75; total time=  12.4s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.9; total time=   6.2s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.6; total time=   7.5s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.75; total time=  19.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.75; total time=   7.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  19.1s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.4s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.75; total time=  13.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.5s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.9; total time=   7.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=  10.0s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=  11.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.75; total time=  16.0s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.6; total time=  10.5s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.5s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.1s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.75; total time=  12.6s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.9; total time=  14.1s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=   9.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.6; total time=   7.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  10.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=5, model__n_estimators=200, model__subsample=0.9; total time=   8.5s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.6; total time=   5.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  22.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  11.4s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=400, model__subsample=0.6; total time=  17.8s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=4, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.9; total time=   5.4s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  24.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=  10.1s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=200, model__subsample=0.75; total time=   8.3s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   6.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  18.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.2s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.9; total time=  12.1s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.6; total time=   8.5s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  11.2s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=   9.9s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.6; total time=   4.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.75; total time=  12.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  10.4s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   5.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=5, model__n_estimators=100, model__subsample=0.9; total time=   5.7s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  22.9s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=4, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=   9.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  12.6s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.75; total time=   6.5s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=4, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.75; total time=  14.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  14.8s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=400, model__subsample=0.6; total time=  24.5s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.01, model__max_depth=8, model__min_child_weight=2, model__n_estimators=100, model__subsample=0.6; total time=   8.2s\n",
+      "[CV] END model__colsample_bytree=0.6, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.6; total time=  10.6s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.05, model__max_depth=6, model__min_child_weight=5, model__n_estimators=400, model__subsample=0.6; total time=  18.9s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.1, model__max_depth=8, model__min_child_weight=3, model__n_estimators=200, model__subsample=0.75; total time=  12.9s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.9; total time=  10.3s\n",
+      "[CV] END model__colsample_bytree=0.75, model__learning_rate=0.1, model__max_depth=6, model__min_child_weight=2, model__n_estimators=200, model__subsample=0.75; total time=  10.9s\n",
+      "[CV] END model__colsample_bytree=0.9, model__learning_rate=0.01, model__max_depth=6, model__min_child_weight=3, model__n_estimators=100, model__subsample=0.6; total time=   4.4s\n"
+     ]
+    }
+   ],
+   "source": [
+    "shap_values, X_transformed = compute_shap_values(model_pipeline, X_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "1c76e59a-e908-4919-8fb8-6532c4cde293",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x950 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_shap_summary(shap_values, X_transformed, feature_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b3a7319-0179-4f8c-a351-8de138923668",
+   "metadata": {},
+   "source": [
+    "Two of the engineered features, age and geographical distance (geo_distance), appear to contribute meaningfully to the model’s predictions, as they rank relatively high in the SHAP feature importance list."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e1ad2b7-5f32-4cfd-a444-b3c719e4f2c9",
+   "metadata": {},
+   "source": [
+    "# Model Registration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "827b0634-9dd5-446b-8fe8-409b11d22b46",
+   "metadata": {},
+   "source": [
+    "## Preparing Model Artifacts Using ADS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "023ea197-3978-4334-a5cb-cfebc3b9c968",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_sample = {\n",
+    "    'Unnamed: 0': 684365,\n",
+    "    'trans_date_trans_time': '2019-10-19 11:14:57',\n",
+    "    'cc_num': 581508178315,\n",
+    "    'merchant': 'fraud_Lynch Ltd',\n",
+    "    'category': 'shopping_pos',\n",
+    "    'amt': 131.6,\n",
+    "    'first': 'Michael',\n",
+    "    'last': 'Vargas',\n",
+    "    'gender': 'M',\n",
+    "    'street': '933 Martin Rapids',\n",
+    "    'city': 'Desdemona',\n",
+    "    'state': 'TX',\n",
+    "    'zip': 76445,\n",
+    "    'lat': 32.2819,\n",
+    "    'long': -98.5673,\n",
+    "    'city_pop': 407,\n",
+    "    'job': 'Clothing/textile technologist',\n",
+    "    'dob': '1978-08-08',\n",
+    "    'trans_num': 'd4eabf36041cd28680705e9464315fc0',\n",
+    "    'unix_time': 1350645297,\n",
+    "    'merch_lat': 31.742311,\n",
+    "    'merch_long': -97.657385,\n",
+    "    'merch_zipcode': 76634.0\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "2fcfcce5-1f0e-4fd9-99ad-98dc5d1c7dc3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "artifact_dir = 'local_path'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50fd2c1e-d9bf-4f09-a7ab-d35cb9d820c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "artifact_object = GenericModel(estimator=model_pipeline,artifact_dir=artifact_dir)\n",
+    "artifact_object.prepare(\n",
+    "    inference_conda_env='oci://pub-conda-env@<your_name_sapce>/cpu/generalml_p311_cpu_x86_64_v1/1.0/generalml_p311_cpu_x86_64_v1', # this kernel shuold also run GenericModel method\n",
+    "    inference_python_version=\"3.11\",\n",
+    "    X_sample=X_sample,\n",
+    "    force_overwrite=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76a807e3-1d15-4402-8000-6e770a4b1cfb",
+   "metadata": {},
+   "source": [
+    "Important Note:\n",
+    "- If you specify inference_conda_env=generalml_p311_cpu_x86_64_v1 in the prepare function below, the base version of this environment will be used, which does not include the category_encoders library.\n",
+    "- Therefore, if your scoring depends on category_encoders, you must publish an updated conda environment that includes this library and provide its URL, as shown in the example below.\n",
+    "- For more details on publishing a conda environment, see: https://docs.oracle.com/en-us/iaas/Content/data-science/using/conda_publishs_object.htm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c059a79-9d8d-4dfd-8601-45ea4ee4fe4a",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "## Customizing the Model Artifacts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "383645d8-6a70-4670-a992-6aa4412fb15a",
+   "metadata": {},
+   "source": [
+    "We would like to add the feature engineering to the deployment script (rather than ad hoc on the client side). For that we need:\n",
+    "1. Add the create_features logic in the score.py:\n",
+    "A. Copy the create_features function from pre_processing.py and paste it into score.py\n",
+    "B. Modify the predict function to call feature_engineering after pre_inference:\n",
+    "features = pre_inference(data, input_schema_path)\n",
+    "features = create_features(features) # added to apply the customization yhat = post_inference(model.predict(features))\n",
+    "2. Update the deserialize function in score.py\n",
+    "A. add 'import StringIO'\n",
+    "B. Wrap the json_data in the str path:\n",
+    "if \"pandas.core.frame.DataFrame\" in data_type or isinstance(json_data, str):\n",
+    "return pd.read_json(StringIO(json_data), dtype=fetch_data_type_from_schema(input_schema_path)) # add StringIO for better practice\n",
+    "C. In case you would like to use the same json format as above, please change:\n",
+    "return pd.DataFrame.from_dict(json_data)->return pd.DataFrame.from_dict([json_data])\n",
+    "4. In case of installing new libareries requires to scoring (like category_encoders in our case):\n",
+    "A. Publish your custom conda environment\n",
+    "B. Update the runtime.yaml file by replacnig the INFERENCE_ENV_PATH value with the path to your published custom conda environment. Example:\n",
+    "INFERENCE_ENV_PATH: 'oci://pub-conda-env@<'your_name_space'>/conda_environments/cpu/General Machine Learning for CPUs on Python 3.11/1.0/generalml_p311_cpu_x86_64_v1'\n",
+    "5. Another option to modify score.py is to add the score_py_uri argument to the prepare() method rather than adjusting it ad hoc. The score_py_uri argument points to a pre-created score.py file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "86d6a5c2-27a5-4235-b29e-e76019f8a19a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start loading model.pkl from model directory /home/datascience/code/anomaly_detection/fraud_detection/sklearn_artifact_dir4 ...\n",
+      "Model is successfully loaded.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "algorithm: null\n",
+       "artifact_dir:\n",
+       "  /home/datascience/code/anomaly_detection/fraud_detection/sklearn_artifact_dir4:\n",
+       "  - - .model-ignore\n",
+       "    - score.py\n",
+       "    - runtime.yaml\n",
+       "    - model.pkl\n",
+       "framework: null\n",
+       "model_deployment_id: null\n",
+       "model_id: null"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Reloading in required in order to update the model in the memory for the next steps\n",
+    "artifact_object.reload()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbc11f06-6906-4387-a6af-701cde87d005",
+   "metadata": {},
+   "source": [
+    "# Test model health"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7dd47150-c93e-492e-9eba-20c4aec7d011",
+   "metadata": {},
+   "source": [
+    "Two tests are recommended:\n",
+    "\n",
+    "1. Verify method – validates the logic in the score.py file by testing the model’s inference pipeline end-to-end.\n",
+    "2. Introspect – ensures that the model artifact directory is correctly structured and contains all required components.\n",
+    "Both tests must pass before model registration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "83c65e73-5952-41c2-9665-a5f29025dc42",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start loading model.pkl from model directory /home/datascience/code/anomaly_detection/fraud_detection/sklearn_artifact_dir4 ...\n",
+      "Model is successfully loaded.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'prediction': [0]}"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "artifact_object.verify(X_sample)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "04c18ab8-94a3-4d6f-af31-f6a502c3bcab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['.model-ignore', 'score.py', 'runtime.yaml', 'model.pkl']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Test key</th>\n",
+       "      <th>Test name</th>\n",
+       "      <th>Result</th>\n",
+       "      <th>Message</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>runtime_env_path</td>\n",
+       "      <td>Check that field MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is set</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>runtime_env_python</td>\n",
+       "      <td>Check that field MODEL_DEPLOYMENT.INFERENCE_PYTHON_VERSION is set to a value of 3.6 or higher</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>runtime_path_exist</td>\n",
+       "      <td>Check that the file path in MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is correct.</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>runtime_version</td>\n",
+       "      <td>Check that field MODEL_ARTIFACT_VERSION is set to 3.0</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>runtime_yaml</td>\n",
+       "      <td>Check that the file \"runtime.yaml\" exists and is in the top level directory of the artifact directory</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>score_load_model</td>\n",
+       "      <td>Check that load_model() is defined</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>score_predict</td>\n",
+       "      <td>Check that predict() is defined</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>score_predict_arg</td>\n",
+       "      <td>Check that all other arguments in predict() are optional and have default values</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>score_predict_data</td>\n",
+       "      <td>Check that the only required argument for predict() is named \"data\"</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>score_py</td>\n",
+       "      <td>Check that the file \"score.py\" exists and is in the top level directory of the artifact directory</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>score_syntax</td>\n",
+       "      <td>Check for Python syntax errors</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              Test key  \\\n",
+       "0     runtime_env_path   \n",
+       "1   runtime_env_python   \n",
+       "2   runtime_path_exist   \n",
+       "3      runtime_version   \n",
+       "4         runtime_yaml   \n",
+       "5     score_load_model   \n",
+       "6        score_predict   \n",
+       "7    score_predict_arg   \n",
+       "8   score_predict_data   \n",
+       "9             score_py   \n",
+       "10        score_syntax   \n",
+       "\n",
+       "                                                                                                Test name  \\\n",
+       "0                                             Check that field MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is set   \n",
+       "1           Check that field MODEL_DEPLOYMENT.INFERENCE_PYTHON_VERSION is set to a value of 3.6 or higher   \n",
+       "2                             Check that the file path in MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is correct.   \n",
+       "3                                                   Check that field MODEL_ARTIFACT_VERSION is set to 3.0   \n",
+       "4   Check that the file \"runtime.yaml\" exists and is in the top level directory of the artifact directory   \n",
+       "5                                                                      Check that load_model() is defined   \n",
+       "6                                                                         Check that predict() is defined   \n",
+       "7                        Check that all other arguments in predict() are optional and have default values   \n",
+       "8                                     Check that the only required argument for predict() is named \"data\"   \n",
+       "9       Check that the file \"score.py\" exists and is in the top level directory of the artifact directory   \n",
+       "10                                                                         Check for Python syntax errors   \n",
+       "\n",
+       "    Result Message  \n",
+       "0   Passed          \n",
+       "1   Passed          \n",
+       "2   Passed          \n",
+       "3   Passed          \n",
+       "4   Passed          \n",
+       "5   Passed          \n",
+       "6   Passed          \n",
+       "7   Passed          \n",
+       "8   Passed          \n",
+       "9   Passed          \n",
+       "10  Passed          "
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "artifact_object.introspect()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3ea7bee-d50b-4b38-989a-916ced0140f4",
+   "metadata": {},
+   "source": [
+    "# Saving and Deploying the Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "009cb82f-445f-4452-9eb0-fca1770ab9bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_id = artifact_object.save(\n",
+    "    display_name=\"fraud-detection-pipeline\",\n",
+    "    description=\"Fraud detection sklearn pipeline with feature engineering\",\n",
+    "    ignore_pending_changes=True)\n",
+    "\n",
+    "print(f\"Model saved: {model_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "210491e6-a5d0-4f59-bc8d-06a823e630ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "deployed_model = artifact_object.deploy(\n",
+    "    display_name=\"fraud-detection-pipeline\",\n",
+    "    deployment_log_group_id=\"<log_group_ocid>\",\n",
+    "    deployment_predict_log_id=\"<log_ocid>\",\n",
+    "    deployment_instance_shape=\"VM.Standard.E4.Flex\",\n",
+    "    deployment_ocpus=1,\n",
+    "    deployment_memory_in_gbs=16\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c82d1e03-2207-4002-a0f4-6ea1593f5a82",
+   "metadata": {},
+   "source": [
+    "# Scoring"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "dc93f46d-9b62-4722-8a41-d60459fdb471",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'prediction': [0]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "from oci.auth.signers import get_resource_principals_signer\n",
+    "endpoint='<your_endpoint>\n",
+    "\n",
+    "signer = get_resource_principals_signer()\n",
+    "response = requests.post(\n",
+    "    endpoint,\n",
+    "    json=X_sample,\n",
+    "    auth=signer\n",
+    ")\n",
+    "print(response.json())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:generalml_p311_cpu_x86_64_v1]",
+   "language": "python",
+   "name": "conda-env-generalml_p311_cpu_x86_64_v1-py"
+  },
+  "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/artifact_examples/runtime.yaml b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/artifact_examples/runtime.yaml
new file mode 100644
index 000000000..38d2bd62f
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/artifact_examples/runtime.yaml
@@ -0,0 +1,23 @@
+
+MODEL_ARTIFACT_VERSION: '3.0'
+MODEL_DEPLOYMENT:
+  INFERENCE_CONDA_ENV:
+    INFERENCE_ENV_PATH: 'oci://pub-conda-env@fro8fl9kuqli/conda_environments/cpu/General Machine Learning for CPUs on Python 3.11/1.0/generalml_p311_cpu_x86_64_v1' #changed to private conda environment paht
+    INFERENCE_ENV_SLUG: ''
+    INFERENCE_ENV_TYPE: published
+    INFERENCE_PYTHON_VERSION: '3.11'
+MODEL_PROVENANCE:
+  PROJECT_OCID: ''
+  TENANCY_OCID: ''
+  TRAINING_CODE:
+    ARTIFACT_DIRECTORY: /home/datascience/anomaly_detection_project/regression/artifact2
+  TRAINING_COMPARTMENT_OCID: ''
+  TRAINING_CONDA_ENV:
+    TRAINING_ENV_PATH: ''
+    TRAINING_ENV_SLUG: ''
+    TRAINING_ENV_TYPE: ''
+    TRAINING_PYTHON_VERSION: ''
+  TRAINING_REGION: ''
+  TRAINING_RESOURCE_OCID: ''
+  USER_OCID: ''
+  VM_IMAGE_INTERNAL_ID: ''
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/artifact_examples/score.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/artifact_examples/score.py
new file mode 100644
index 000000000..0e8df8aca
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/artifact_examples/score.py
@@ -0,0 +1,175 @@
+# score.py 1.0 generated by ADS 2.11.19 on 20260513_095702
+import json
+import os
+import cloudpickle
+import pandas as pd
+import numpy as np
+from functools import lru_cache
+
+
+model_name = 'model.pkl'
+
+
+"""
+   Inference script. This script is used for prediction by scoring server when schema is known.
+"""
+
+
+@lru_cache(maxsize=10)
+def load_model(model_file_name=model_name):
+    """
+    Loads model from the serialized format
+
+    Returns
+    -------
+    model:  a model instance on which predict API can be invoked
+    """
+    model_dir = os.path.dirname(os.path.realpath(__file__))
+    contents = os.listdir(model_dir)
+    if model_file_name in contents:
+        print(f'Start loading {model_file_name} from model directory {model_dir} ...')
+        with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), model_file_name), "rb") as file:
+            loaded_model = cloudpickle.load(file)
+
+        print("Model is successfully loaded.")
+        return loaded_model
+    else:
+        raise Exception(f'{model_file_name} is not found in model directory {model_dir}')
+
+@lru_cache(maxsize=1)
+def fetch_data_type_from_schema(input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
+    """
+    Returns data type information fetch from input_schema.json.
+
+    Parameters
+    ----------
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data_type: data type fetch from input_schema.json.
+
+    """
+    data_type = {}
+    if os.path.exists(input_schema_path):
+        schema = json.load(open(input_schema_path))
+        for col in schema['schema']:
+            data_type[col['name']] = col['dtype']
+    else:
+        print("input_schema has to be passed in in order to recover the same data type. pass `X_sample` in `ads.model.framework.sklearn_model.SklearnModel.prepare` function to generate the input_schema. Otherwise, the data type might be changed after serialization/deserialization.")
+    return data_type
+
+def deserialize(data, input_schema_path):
+    """
+    Deserialize json serialization data to data in original type when sent to predict.
+
+    Parameters
+    ----------
+    data: serialized input data.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data: deserialized input data.
+
+    """
+
+    import base64
+    from io import BytesIO, StringIO
+    if isinstance(data, bytes):
+        return data
+
+    data_type = data.get('data_type', '') if isinstance(data, dict) else ''
+    json_data = data.get('data', data) if isinstance(data, dict) else data
+
+    if "numpy.ndarray" in data_type:
+        load_bytes = BytesIO(base64.b64decode(json_data.encode('utf-8')))
+        return np.load(load_bytes, allow_pickle=True)
+    if "pandas.core.series.Series" in data_type:
+        return pd.Series(json_data)
+    if "pandas.core.frame.DataFrame" in data_type or isinstance(json_data, str):
+        return pd.read_json(StringIO(json_data), dtype=fetch_data_type_from_schema(input_schema_path)) #added StringIO
+    if isinstance(json_data, dict):
+        return pd.DataFrame.from_dict(json_data)
+
+    return json_data
+
+
+
+def pre_inference(data, input_schema_path):
+    """
+    Preprocess data
+
+    Parameters
+    ----------
+    data: Data format as expected by the predict API of the core estimator.
+    input_schema_path: path of input schema.
+
+    Returns
+    -------
+    data: Data format after any processing.
+
+    """
+    return deserialize(data, input_schema_path)
+
+def post_inference(yhat):
+    """
+    Post-process the model results
+
+    Parameters
+    ----------
+    yhat: Data format after calling model.predict.
+
+    Returns
+    -------
+    yhat: Data format after any processing.
+
+    """
+    if isinstance(yhat, pd.core.frame.DataFrame):
+        yhat = yhat.values
+    if isinstance(yhat, np.ndarray):
+        yhat = yhat.tolist()
+    return yhat
+
+# def predict(data, model=load_model(), input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
+#     """
+#     Returns prediction given the model and data to predict
+
+#     Parameters
+#     ----------
+#     model: Model instance returned by load_model API.
+#     data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Pandas DataFrame.
+#     input_schema_path: path of input schema.
+
+#     Returns
+#     -------
+#     predictions: Output from scoring server
+#         Format: {'prediction': output from model.predict method}
+
+#     """
+#     features = pre_inference(data, input_schema_path)
+#     yhat = post_inference(
+#         model.predict(features)
+#     )
+#     return {'prediction': yhat}
+
+def predict(data, model=load_model(), input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
+    features = pre_inference(data, input_schema_path)
+
+    forecast_obj = model.get_forecast(
+        steps=1,
+        exog=features
+    )
+
+    prediction = float(forecast_obj.predicted_mean.iloc[0])
+
+    conf_int = forecast_obj.conf_int()
+
+    lower_bound = float(conf_int.iloc[0, 0])
+    upper_bound = float(conf_int.iloc[0, 1])
+
+    return {
+        'prediction': prediction,
+        'lower_prediction_interval': lower_bound,
+        'upper_prediction_interval': upper_bound
+    }
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/data_extraction/data_creation.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/data_extraction/data_creation.ipynb
new file mode 100644
index 000000000..0e84ac9d2
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/data_extraction/data_creation.ipynb
@@ -0,0 +1,201 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7843cee4-5abc-4855-987a-edd1b184079c",
+   "metadata": {},
+   "source": [
+    "This notebook is used to split the data into multiple datasets:\n",
+    "1. A train&test dataset for R&R\n",
+    "2. Daily datasets used to simulate production daily data\n",
+    "\n",
+    "The train&test dataset is stored locally on the block volume, while the daily datasets are stored in OCI Object Storage under different object names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "dd2ac2ea-f62b-4dd6-939c-9459d67b9d52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import oci"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f73026b6-7867-44fe-bc54-8bad1fb54846",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "signer = oci.auth.signers.get_resource_principals_signer()\n",
+    "object_storage_client = oci.object_storage.ObjectStorageClient(\n",
+    "    config={},\n",
+    "    signer=signer\n",
+    ")\n",
+    "namespace_name = object_storage_client.get_namespace().data\n",
+    "bucket_name = 'anomaly-detection-regression'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "485ae187-4114-4211-b191-884ca0ebf8f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path='/home/datascience/anomaly_detection_project/regression/data/walmart_cleaned.csv'\n",
+    "df = pd.read_csv(path)\n",
+    "\n",
+    "date_col = 'Date'\n",
+    "df[date_col] = pd.to_datetime(df[date_col])\n",
+    "df = df.sort_values(date_col)\n",
+    "unique_dates = df[date_col].drop_duplicates().sort_values()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fa4defab-8b2d-4aaf-9684-ec5711dbd968",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(383040, 17)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[date_col] = pd.to_datetime(df[date_col])\n",
+    "train_dates = unique_dates[:130]\n",
+    "future_dates = unique_dates[130:]\n",
+    "train_df = df[df[date_col].isin(train_dates)].copy()\n",
+    "train_df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "8ed7f167-95a2-446e-bbbc-be82f2232891",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_df.to_csv('/home/datascience/anomaly_detection_project/regression/data/walmart_train.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "4384a140-995d-42db-8f72-74a355026e17",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Uploaded: daily_files/2012-08-03.csv\n",
+      "Uploaded: daily_files/2012-08-10.csv\n",
+      "Uploaded: daily_files/2012-08-17.csv\n",
+      "Uploaded: daily_files/2012-08-24.csv\n",
+      "Uploaded: daily_files/2012-08-31.csv\n",
+      "Uploaded: daily_files/2012-09-07.csv\n",
+      "Uploaded: daily_files/2012-09-14.csv\n",
+      "Uploaded: daily_files/2012-09-21.csv\n",
+      "Uploaded: daily_files/2012-09-28.csv\n",
+      "Uploaded: daily_files/2012-10-05.csv\n",
+      "Uploaded: daily_files/2012-10-12.csv\n",
+      "Uploaded: daily_files/2012-10-19.csv\n",
+      "Uploaded: daily_files/2012-10-26.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "for current_date in future_dates:\n",
+    "\n",
+    "    daily_df = df[df[date_col] == current_date].copy()\n",
+    "\n",
+    "    date_str = current_date.strftime('%Y-%m-%d')\n",
+    "\n",
+    "    object_name = f'daily_files/{date_str}.csv'\n",
+    "\n",
+    "    csv_bytes = daily_df.to_csv(index=False).encode('utf-8')\n",
+    "\n",
+    "    object_storage_client.put_object(\n",
+    "        namespace_name=namespace_name,\n",
+    "        bucket_name=bucket_name,\n",
+    "        object_name=object_name,\n",
+    "        put_object_body=csv_bytes,\n",
+    "        content_type='text/csv'\n",
+    "    )\n",
+    "\n",
+    "    print(f'Uploaded: {object_name}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2562171e-89c9-4cbc-837b-d65f9785e181",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for current_date in future_dates:\n",
+    "\n",
+    "    daily_df = df[df[date_col] == current_date].copy()\n",
+    "\n",
+    "    date_str = current_date.strftime('%Y-%m-%d')\n",
+    "\n",
+    "    object_name = f'daily_files/{date_str}.csv'\n",
+    "\n",
+    "    csv_bytes = daily_df.to_csv(index=False).encode('utf-8')\n",
+    "\n",
+    "    object_storage_client.put_object(\n",
+    "        namespace_name=namespace_name,\n",
+    "        bucket_name=bucket_name,\n",
+    "        object_name=object_name,\n",
+    "        put_object_body=csv_bytes,\n",
+    "        content_type='text/csv'\n",
+    "    )\n",
+    "\n",
+    "    print(f'Uploaded: {object_name}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3fc4ece1-bf3b-41bc-a953-5b9f5c11a1e2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:generalml_p311_cpu_x86_64_v1]",
+   "language": "python",
+   "name": "conda-env-generalml_p311_cpu_x86_64_v1-py"
+  },
+  "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/graphs.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/graphs.py
new file mode 100644
index 000000000..8e0cade20
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/graphs.py
@@ -0,0 +1,49 @@
+import matplotlib.pyplot as plt
+
+def plot_store_vs_overall_sales(df, agg_df, store_id=1, sales_col='Weekly_Sales', date_col='Date'):
+    store_df = df[df['Store'] == store_id][[date_col, sales_col]].copy()
+    store_sales = (
+        store_df.groupby(date_col, as_index=False)[sales_col]
+        .sum()
+        .sort_values(date_col)
+    )
+
+    overall_sales = agg_df[[date_col, sales_col]].copy().sort_values(date_col)
+
+    fig, axes = plt.subplots(2, 1, figsize=(14, 8), sharex=True)
+
+    axes[0].plot(store_sales[date_col], store_sales[sales_col], linewidth=1.8)
+    axes[0].set_title(f'Store {store_id} Weekly Sales')
+    axes[0].set_ylabel('Weekly Sales')
+
+    axes[1].plot(overall_sales[date_col], overall_sales[sales_col], linewidth=1.8)
+    axes[1].set_title('Overall Weekly Sales')
+    axes[1].set_xlabel('Date')
+    axes[1].set_ylabel('Weekly Sales')
+
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_forecast(train_df, test_df, sales_col, forecast, title, conf_int=None):
+    plt.figure(figsize=(14, 6))
+
+    plt.plot(train_df.index, train_df[sales_col], label='Train')
+    plt.plot(test_df.index, test_df[sales_col], label='Actual')
+    plt.plot(test_df.index, forecast, linestyle='--', label='Forecast')
+
+    if conf_int is not None:
+        plt.fill_between(
+            test_df.index,
+            conf_int.iloc[:, 0],
+            conf_int.iloc[:, 1],
+            alpha=0.2
+        )
+
+    plt.title(title)
+    plt.xlabel('Date')
+    plt.ylabel(sales_col)
+    plt.legend()
+    plt.show()
+
+    
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/models.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/models.py
new file mode 100644
index 000000000..66a0e860a
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/models.py
@@ -0,0 +1,22 @@
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+
+def fit_model(train_df,order_value, seasonal_order_value, trend_cols,sales_col):
+
+    y_series = train_df[sales_col]
+
+    X = train_df[trend_cols] if trend_cols else None
+
+    model = SARIMAX(
+        y_series,
+        exog=X,
+        order=order_value,
+        seasonal_order=seasonal_order_value,
+        enforce_stationarity=False,
+        enforce_invertibility=False
+    )
+
+    results = model.fit(disp=False)
+
+    print(results.summary())
+
+    return results
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/utils.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/utils.py
new file mode 100644
index 000000000..c71af4f8a
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/utils.py
@@ -0,0 +1,78 @@
+import pandas as pd
+
+def create_aggregated_df(df):
+    agg_df = (
+        df.groupby('Date', as_index=False)
+          .agg({
+              'Store': 'nunique',
+              'Dept': 'count',
+              'IsHoliday': 'sum',
+              'Weekly_Sales': 'sum',
+              'Temperature': 'mean',
+              'Fuel_Price': 'mean',
+              'MarkDown1': 'mean',
+              'MarkDown2': 'mean',
+              'MarkDown3': 'mean',
+              'MarkDown4': 'mean',
+              'MarkDown5': 'mean',
+              'CPI': 'mean',
+              'Unemployment': 'mean',
+              'Type': 'mean',
+              'Size': 'mean'
+          })
+          .sort_values('Date')
+          .reset_index(drop=True)
+    )
+
+    return agg_df
+
+
+
+def walk_forward_forecast(results, test_df, trend_cols, sales_col):
+    predictions = []
+    lower_bounds = []
+    upper_bounds = []
+
+    current_results = results
+
+    for i in range(len(test_df)):
+
+        next_row = test_df.iloc[[i]]
+
+        X_next = next_row[trend_cols] if trend_cols else None
+
+        # Forecast next step
+        forecast_obj = current_results.get_forecast(
+            steps=1,
+            exog=X_next
+        )
+
+        forecast = forecast_obj.predicted_mean.iloc[0]
+
+        conf_int = forecast_obj.conf_int()
+
+        lower = conf_int.iloc[0, 0]
+        upper = conf_int.iloc[0, 1]
+
+        predictions.append(forecast)
+        lower_bounds.append(lower)
+        upper_bounds.append(upper)
+
+        # Update model state with actual observation
+        current_results = current_results.append(
+            endog=next_row[sales_col],
+            exog=X_next,
+            refit=False
+        )
+
+    forecast_series = pd.Series(
+        predictions,
+        index=test_df.index
+    )
+
+    conf_int_df = pd.DataFrame({
+        'lower': lower_bounds,
+        'upper': upper_bounds
+    }, index=test_df.index)
+
+    return forecast_series, conf_int_df
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/walmart_eda.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/walmart_eda.ipynb
new file mode 100644
index 000000000..d211df54e
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/model_training_and_deployment/walmart_eda.ipynb
@@ -0,0 +1,1678 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "360a4ee7",
+   "metadata": {},
+   "source": [
+    "# Anomaly Detection for Regression Unlabled Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38c92eb1-0856-4fe6-8a68-64de08bff361",
+   "metadata": {},
+   "source": [
+    "This notebook demonstrates how to perform anomaly detection for a continuous unlabeled target variable using time series regression.\n",
+    "For this demonstration, we use the cleaned Walmart dataset. We will analyze the time series sales data and use it for detecting anomalies in overall sales.\n",
+    "\n",
+    "The algorithm developed and deployed in this notebook will later be used in another project (under the same parent folder) for daily monitoring and anomaly detection in production.\n",
+    "\n",
+    "The notebook covers the following topics:\n",
+    "1. Dataset overview and exploratory data analysis\n",
+    "2. Time series modeling, validation, and its application to anomaly detection\n",
+    "3. Custom model registration and deployment\n",
+    "4. Model invocation\n",
+    "\n",
+    "\n",
+    "\n",
+    "Data resource: https://www.kaggle.com/datasets/ujjwalchowdhury/walmartcleaned \\\n",
+    "Conda environment: generalml_p311_cpu_x86_64_v1\n",
+    "\n",
+    "Author: Assaf Rabinowicz, Data Science Team, EMEA"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2ea031a-eb39-4915-94f2-9f66a9c43c4a",
+   "metadata": {},
+   "source": [
+    "# Importing Packages and Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "83876df3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from statsmodels.tsa.statespace.sarimax import SARIMAX\n",
+    "\n",
+    "import oci\n",
+    "from oci.auth.signers import get_resource_principals_signer\n",
+    "import ads\n",
+    "from ads.model.generic_model import GenericModel\n",
+    "\n",
+    "#Importing three helpers modules \n",
+    "import utils\n",
+    "import graphs\n",
+    "import models\n",
+    "\n",
+    "ads.set_auth(auth='resource_principal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "5e2fa99e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(383040, 18)"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "path='/home/datascience/anomaly_detection_project/regression/data/walmart_train.csv' # the data was copied and paste to the Notebook Block volume\n",
+    "df = pd.read_csv(path)\n",
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "id": "22eda8cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Unnamed: 0.1</th>\n",
+       "      <th>Unnamed: 0</th>\n",
+       "      <th>Store</th>\n",
+       "      <th>Date</th>\n",
+       "      <th>IsHoliday</th>\n",
+       "      <th>Dept</th>\n",
+       "      <th>Weekly_Sales</th>\n",
+       "      <th>Temperature</th>\n",
+       "      <th>Fuel_Price</th>\n",
+       "      <th>MarkDown1</th>\n",
+       "      <th>MarkDown2</th>\n",
+       "      <th>MarkDown3</th>\n",
+       "      <th>MarkDown4</th>\n",
+       "      <th>MarkDown5</th>\n",
+       "      <th>CPI</th>\n",
+       "      <th>Unemployment</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Size</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2010-02-05</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>24924.50</td>\n",
+       "      <td>42.31</td>\n",
+       "      <td>2.572</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>211.096358</td>\n",
+       "      <td>8.106</td>\n",
+       "      <td>3</td>\n",
+       "      <td>151315</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>330761</td>\n",
+       "      <td>332087</td>\n",
+       "      <td>35</td>\n",
+       "      <td>2010-02-05</td>\n",
+       "      <td>0</td>\n",
+       "      <td>83.0</td>\n",
+       "      <td>5015.30</td>\n",
+       "      <td>27.19</td>\n",
+       "      <td>2.784</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>135.352461</td>\n",
+       "      <td>9.262</td>\n",
+       "      <td>2</td>\n",
+       "      <td>103681</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>330762</td>\n",
+       "      <td>332088</td>\n",
+       "      <td>35</td>\n",
+       "      <td>2010-02-05</td>\n",
+       "      <td>0</td>\n",
+       "      <td>95.0</td>\n",
+       "      <td>62831.98</td>\n",
+       "      <td>27.19</td>\n",
+       "      <td>2.784</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>135.352461</td>\n",
+       "      <td>9.262</td>\n",
+       "      <td>2</td>\n",
+       "      <td>103681</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>330763</td>\n",
+       "      <td>332089</td>\n",
+       "      <td>35</td>\n",
+       "      <td>2010-02-05</td>\n",
+       "      <td>0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>10870.40</td>\n",
+       "      <td>27.19</td>\n",
+       "      <td>2.784</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>135.352461</td>\n",
+       "      <td>9.262</td>\n",
+       "      <td>2</td>\n",
+       "      <td>103681</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>330764</td>\n",
+       "      <td>332090</td>\n",
+       "      <td>35</td>\n",
+       "      <td>2010-02-05</td>\n",
+       "      <td>0</td>\n",
+       "      <td>56.0</td>\n",
+       "      <td>345.00</td>\n",
+       "      <td>27.19</td>\n",
+       "      <td>2.784</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>135.352461</td>\n",
+       "      <td>9.262</td>\n",
+       "      <td>2</td>\n",
+       "      <td>103681</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Unnamed: 0.1  Unnamed: 0  Store        Date  IsHoliday  Dept  Weekly_Sales  \\\n",
+       "0             0           0      1  2010-02-05          0   1.0      24924.50   \n",
+       "1        330761      332087     35  2010-02-05          0  83.0       5015.30   \n",
+       "2        330762      332088     35  2010-02-05          0  95.0      62831.98   \n",
+       "3        330763      332089     35  2010-02-05          0  26.0      10870.40   \n",
+       "4        330764      332090     35  2010-02-05          0  56.0        345.00   \n",
+       "\n",
+       "   Temperature  Fuel_Price  MarkDown1  MarkDown2  MarkDown3  MarkDown4  \\\n",
+       "0        42.31       2.572        0.0        0.0        0.0        0.0   \n",
+       "1        27.19       2.784        0.0        0.0        0.0        0.0   \n",
+       "2        27.19       2.784        0.0        0.0        0.0        0.0   \n",
+       "3        27.19       2.784        0.0        0.0        0.0        0.0   \n",
+       "4        27.19       2.784        0.0        0.0        0.0        0.0   \n",
+       "\n",
+       "   MarkDown5         CPI  Unemployment  Type    Size  \n",
+       "0        0.0  211.096358         8.106     3  151315  \n",
+       "1        0.0  135.352461         9.262     2  103681  \n",
+       "2        0.0  135.352461         9.262     2  103681  \n",
+       "3        0.0  135.352461         9.262     2  103681  \n",
+       "4        0.0  135.352461         9.262     2  103681  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>dtype</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Unnamed: 0.1</th>\n",
+       "      <td>int64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Unnamed: 0</th>\n",
+       "      <td>int64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Store</th>\n",
+       "      <td>int64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <td>str</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>IsHoliday</th>\n",
+       "      <td>int64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Dept</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Weekly_Sales</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Temperature</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Fuel_Price</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>MarkDown1</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>MarkDown2</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>MarkDown3</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>MarkDown4</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>MarkDown5</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>CPI</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Unemployment</th>\n",
+       "      <td>float64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Type</th>\n",
+       "      <td>int64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Size</th>\n",
+       "      <td>int64</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                dtype\n",
+       "Unnamed: 0.1    int64\n",
+       "Unnamed: 0      int64\n",
+       "Store           int64\n",
+       "Date              str\n",
+       "IsHoliday       int64\n",
+       "Dept          float64\n",
+       "Weekly_Sales  float64\n",
+       "Temperature   float64\n",
+       "Fuel_Price    float64\n",
+       "MarkDown1     float64\n",
+       "MarkDown2     float64\n",
+       "MarkDown3     float64\n",
+       "MarkDown4     float64\n",
+       "MarkDown5     float64\n",
+       "CPI           float64\n",
+       "Unemployment  float64\n",
+       "Type            int64\n",
+       "Size            int64"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display(df.head())\n",
+    "display(df.dtypes.to_frame('dtype'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a9c0273-fc8b-44f2-8ac0-7f04705ebe5b",
+   "metadata": {},
+   "source": [
+    "* The data includes the following hierarchy: Walmart consists of multiple stores, and each store contains multiple departments (Dept).\n",
+    "* In addition, the dataset is time-series based, meaning that each store-department combination appears on a weekly basis.\n",
+    "* Besides the structural columns, the dataset also contains several additional features that can be used as input variables for the model."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3a31479-6d11-4340-b067-5ce94addc571",
+   "metadata": {},
+   "source": [
+    "# Data Processing and Exploration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "fdb4139c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape: 383,040 rows x 17 columns\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The data is relatively clean; only a few minor adjustments are required:\n",
+    "# dropping the index column and converting the Date column to datetime format.\n",
+    "\n",
+    "if 'Unnamed: 0' in df.columns:\n",
+    "    df = df.drop(columns=['Unnamed: 0'])\n",
+    "\n",
+    "df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n",
+    "\n",
+    "print(f'Shape: {df.shape[0]:,} rows x {df.shape[1]} columns')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "e64ddd60",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "There are no missing values.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Checking missing values by column.\n",
+    "\n",
+    "missing = pd.DataFrame({\n",
+    "    'column': df.columns,\n",
+    "    'missing_count': df.isna().sum().values,\n",
+    "})\n",
+    "missing['missing_pct'] = (missing['missing_count'] / len(df) * 100).round(3)\n",
+    "missing = missing.sort_values(['missing_count', 'column'], ascending=[False, True]).reset_index(drop=True)\n",
+    "missing_nonzero = missing[missing['missing_count'] > 0].reset_index(drop=True)\n",
+    "\n",
+    "if missing_nonzero.empty:\n",
+    "    print('There are no missing values.')\n",
+    "else:\n",
+    "    display(missing_nonzero)\n",
+    "    print('Columns with missing values:', len(missing_nonzero))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "a0843547",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Numerical columns (16): ['Unnamed: 0.1', 'Store', 'IsHoliday', 'Dept', 'Weekly_Sales', 'Temperature', 'Fuel_Price', 'MarkDown1', 'MarkDown2', 'MarkDown3', 'MarkDown4', 'MarkDown5', 'CPI', 'Unemployment', 'Type', 'Size']\n",
+      "Categorical columns (0): []\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Let's separate the variables into numerical and categorical groups\n",
+    "# in order to inspect the basic statistics for each group.\n",
+    "\n",
+    "num_cols = df.select_dtypes(include=['number']).columns.tolist()\n",
+    "cat_cols = df.select_dtypes(include=['object', 'category', 'bool']).columns.tolist()\n",
+    "\n",
+    "print(f'Numerical columns ({len(num_cols)}): {num_cols}')\n",
+    "print(f'Categorical columns ({len(cat_cols)}): {cat_cols}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "id": "e0159ba0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Unnamed: 0.1</th>\n",
+       "      <th>Store</th>\n",
+       "      <th>IsHoliday</th>\n",
+       "      <th>Dept</th>\n",
+       "      <th>Weekly_Sales</th>\n",
+       "      <th>Temperature</th>\n",
+       "      <th>Fuel_Price</th>\n",
+       "      <th>MarkDown1</th>\n",
+       "      <th>MarkDown2</th>\n",
+       "      <th>MarkDown3</th>\n",
+       "      <th>MarkDown4</th>\n",
+       "      <th>MarkDown5</th>\n",
+       "      <th>CPI</th>\n",
+       "      <th>Unemployment</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Size</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.00000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "      <td>383040.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>210287.787153</td>\n",
+       "      <td>22.193797</td>\n",
+       "      <td>0.069692</td>\n",
+       "      <td>44.243599</td>\n",
+       "      <td>16017.546461</td>\n",
+       "      <td>59.029180</td>\n",
+       "      <td>3.317363</td>\n",
+       "      <td>2096.169787</td>\n",
+       "      <td>964.15273</td>\n",
+       "      <td>511.620121</td>\n",
+       "      <td>898.072541</td>\n",
+       "      <td>1416.678974</td>\n",
+       "      <td>170.748664</td>\n",
+       "      <td>8.042668</td>\n",
+       "      <td>2.410516</td>\n",
+       "      <td>136768.145870</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>121687.023644</td>\n",
+       "      <td>12.782512</td>\n",
+       "      <td>0.254628</td>\n",
+       "      <td>30.473053</td>\n",
+       "      <td>22786.408121</td>\n",
+       "      <td>18.653297</td>\n",
+       "      <td>0.453193</td>\n",
+       "      <td>5568.159572</td>\n",
+       "      <td>5326.78905</td>\n",
+       "      <td>5798.466066</td>\n",
+       "      <td>3805.301164</td>\n",
+       "      <td>4228.839267</td>\n",
+       "      <td>38.965892</td>\n",
+       "      <td>1.863513</td>\n",
+       "      <td>0.665964</td>\n",
+       "      <td>60962.131332</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>-4988.940000</td>\n",
+       "      <td>-2.060000</td>\n",
+       "      <td>2.472000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-265.76000</td>\n",
+       "      <td>-29.100000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>126.064000</td>\n",
+       "      <td>4.077000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>34875.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>210402.500000</td>\n",
+       "      <td>22.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>37.000000</td>\n",
+       "      <td>7630.350000</td>\n",
+       "      <td>60.420000</td>\n",
+       "      <td>3.353000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>182.260441</td>\n",
+       "      <td>7.907000</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>140167.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>420693.000000</td>\n",
+       "      <td>45.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>99.000000</td>\n",
+       "      <td>693099.360000</td>\n",
+       "      <td>100.140000</td>\n",
+       "      <td>4.308000</td>\n",
+       "      <td>88646.760000</td>\n",
+       "      <td>104519.54000</td>\n",
+       "      <td>141630.610000</td>\n",
+       "      <td>67474.850000</td>\n",
+       "      <td>108519.280000</td>\n",
+       "      <td>225.697078</td>\n",
+       "      <td>14.313000</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>219622.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Unnamed: 0.1          Store      IsHoliday           Dept  \\\n",
+       "count  383040.000000  383040.000000  383040.000000  383040.000000   \n",
+       "mean   210287.787153      22.193797       0.069692      44.243599   \n",
+       "std    121687.023644      12.782512       0.254628      30.473053   \n",
+       "min         0.000000       1.000000       0.000000       1.000000   \n",
+       "50%    210402.500000      22.000000       0.000000      37.000000   \n",
+       "max    420693.000000      45.000000       1.000000      99.000000   \n",
+       "\n",
+       "        Weekly_Sales    Temperature     Fuel_Price      MarkDown1  \\\n",
+       "count  383040.000000  383040.000000  383040.000000  383040.000000   \n",
+       "mean    16017.546461      59.029180       3.317363    2096.169787   \n",
+       "std     22786.408121      18.653297       0.453193    5568.159572   \n",
+       "min     -4988.940000      -2.060000       2.472000       0.000000   \n",
+       "50%      7630.350000      60.420000       3.353000       0.000000   \n",
+       "max    693099.360000     100.140000       4.308000   88646.760000   \n",
+       "\n",
+       "          MarkDown2      MarkDown3      MarkDown4      MarkDown5  \\\n",
+       "count  383040.00000  383040.000000  383040.000000  383040.000000   \n",
+       "mean      964.15273     511.620121     898.072541    1416.678974   \n",
+       "std      5326.78905    5798.466066    3805.301164    4228.839267   \n",
+       "min      -265.76000     -29.100000       0.000000       0.000000   \n",
+       "50%         0.00000       0.000000       0.000000       0.000000   \n",
+       "max    104519.54000  141630.610000   67474.850000  108519.280000   \n",
+       "\n",
+       "                 CPI   Unemployment           Type           Size  \n",
+       "count  383040.000000  383040.000000  383040.000000  383040.000000  \n",
+       "mean      170.748664       8.042668       2.410516  136768.145870  \n",
+       "std        38.965892       1.863513       0.665964   60962.131332  \n",
+       "min       126.064000       4.077000       1.000000   34875.000000  \n",
+       "50%       182.260441       7.907000       3.000000  140167.000000  \n",
+       "max       225.697078      14.313000       3.000000  219622.000000  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if num_cols:\n",
+    "    num_desc = df[num_cols].describe()\n",
+    "    num_desc = num_desc.drop(index=['25%', '75%'], errors='ignore')\n",
+    "    display(num_desc)\n",
+    "else:\n",
+    "    print('No numerical columns found.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "id": "3c96cf94-24ae-4bc7-ac34-e2e95e0023a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape: 130 rows x 16 columns\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Date</th>\n",
+       "      <th>Store</th>\n",
+       "      <th>Dept</th>\n",
+       "      <th>IsHoliday</th>\n",
+       "      <th>Weekly_Sales</th>\n",
+       "      <th>Temperature</th>\n",
+       "      <th>Fuel_Price</th>\n",
+       "      <th>MarkDown1</th>\n",
+       "      <th>MarkDown2</th>\n",
+       "      <th>MarkDown3</th>\n",
+       "      <th>MarkDown4</th>\n",
+       "      <th>MarkDown5</th>\n",
+       "      <th>CPI</th>\n",
+       "      <th>Unemployment</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Size</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2010-02-05</td>\n",
+       "      <td>45</td>\n",
+       "      <td>2955</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49750740.50</td>\n",
+       "      <td>33.277942</td>\n",
+       "      <td>2.717869</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>167.398405</td>\n",
+       "      <td>8.576731</td>\n",
+       "      <td>2.412183</td>\n",
+       "      <td>137430.535364</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2010-02-12</td>\n",
+       "      <td>45</td>\n",
+       "      <td>2956</td>\n",
+       "      <td>2956</td>\n",
+       "      <td>48336677.63</td>\n",
+       "      <td>33.361810</td>\n",
+       "      <td>2.696102</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>167.384138</td>\n",
+       "      <td>8.567309</td>\n",
+       "      <td>2.414073</td>\n",
+       "      <td>137622.780785</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2010-02-19</td>\n",
+       "      <td>45</td>\n",
+       "      <td>2977</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48276993.78</td>\n",
+       "      <td>37.038310</td>\n",
+       "      <td>2.673666</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>167.338966</td>\n",
+       "      <td>8.576351</td>\n",
+       "      <td>2.412160</td>\n",
+       "      <td>137278.637219</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2010-02-26</td>\n",
+       "      <td>45</td>\n",
+       "      <td>2951</td>\n",
+       "      <td>0</td>\n",
+       "      <td>43968571.13</td>\n",
+       "      <td>38.629563</td>\n",
+       "      <td>2.685642</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>167.691019</td>\n",
+       "      <td>8.561375</td>\n",
+       "      <td>2.412064</td>\n",
+       "      <td>137346.344629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2010-03-05</td>\n",
+       "      <td>45</td>\n",
+       "      <td>2944</td>\n",
+       "      <td>0</td>\n",
+       "      <td>46871470.30</td>\n",
+       "      <td>42.373998</td>\n",
+       "      <td>2.731816</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>167.727351</td>\n",
+       "      <td>8.572689</td>\n",
+       "      <td>2.414062</td>\n",
+       "      <td>137576.841033</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Date  Store  Dept  IsHoliday  Weekly_Sales  Temperature  Fuel_Price  \\\n",
+       "0 2010-02-05     45  2955          0   49750740.50    33.277942    2.717869   \n",
+       "1 2010-02-12     45  2956       2956   48336677.63    33.361810    2.696102   \n",
+       "2 2010-02-19     45  2977          0   48276993.78    37.038310    2.673666   \n",
+       "3 2010-02-26     45  2951          0   43968571.13    38.629563    2.685642   \n",
+       "4 2010-03-05     45  2944          0   46871470.30    42.373998    2.731816   \n",
+       "\n",
+       "   MarkDown1  MarkDown2  MarkDown3  MarkDown4  MarkDown5         CPI  \\\n",
+       "0        0.0        0.0        0.0        0.0        0.0  167.398405   \n",
+       "1        0.0        0.0        0.0        0.0        0.0  167.384138   \n",
+       "2        0.0        0.0        0.0        0.0        0.0  167.338966   \n",
+       "3        0.0        0.0        0.0        0.0        0.0  167.691019   \n",
+       "4        0.0        0.0        0.0        0.0        0.0  167.727351   \n",
+       "\n",
+       "   Unemployment      Type           Size  \n",
+       "0      8.576731  2.412183  137430.535364  \n",
+       "1      8.567309  2.414073  137622.780785  \n",
+       "2      8.576351  2.412160  137278.637219  \n",
+       "3      8.561375  2.412064  137346.344629  \n",
+       "4      8.572689  2.414062  137576.841033  "
+      ]
+     },
+     "execution_count": 75,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The data can be analyzed in different ways. In this demonstration, we focus on overall sales rather than on a specific store.\n",
+    "# Still, as shown in the graph below, the weekly sales of individual stores are highly correlated with the overall weekly sales across all stores.\n",
+    "agg_df = utils.create_aggregated_df(df)\n",
+    "print(f'Shape: {agg_df.shape[0]:,} rows x {agg_df.shape[1]} columns')\n",
+    "agg_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "d3c65923-d552-4367-a6c0-9cce015a5d52",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1400x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "graphs.plot_store_vs_overall_sales(df, agg_df, store_id=1, sales_col='Weekly_Sales', date_col='Date')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "ea58730f-cb5e-459d-9c4d-d51477492acc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_df = agg_df.iloc[:120]\n",
+    "test_df = agg_df.iloc[120:130]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4d700ed-e780-4228-9f48-4c6dd9221a48",
+   "metadata": {},
+   "source": [
+    "# Modeling and Validation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f232139-7b49-4edc-9fcc-408c0edd25e1",
+   "metadata": {},
+   "source": [
+    "* Time series data can be analyzed using a wide range of models. In this demonstration, we focus on a model that satisfies the following requirements:\n",
+    "    a. Supports forecasting, rather than only retrospective analysis\n",
+    "    b. Allows enriching the time series model with additional features, rather than relying solely on the raw time series\n",
+    "    c. Provides flexibility in modeling different correlation structures within the data\n",
+    "* The SARIMAX model was selected. Although it is limited to capturing primarily linear relationships, it is a powerful and flexible model that allows customization of several important components:\n",
+    "    - Autoregressive effect (AR) - previous observations are used to predict future values\n",
+    "    - Moving Average effect (MA) - previous prediction errors are used to improve short-term forecasting accuracy\n",
+    "    - Differencing effect - the original series is transformed using differencing to improve stationarity and stabilize parameter estimation. Predictions are later transformed back into the original time-series scale\n",
+    "    - Seasonality effect - seasonal patterns are modeled using the same concepts (AR, MA, and differencing), but applied to the seasonal structure embedded in the data. In our case, we assume yearly seasonality (52 weeks), meaning that the seasonal component is modeled using a lag of 52 observations\n",
+    "    - Exogenous features - additional variables are incorporated into the model as exogenous predictors to improve forecasting performance\n",
+    "The order of the AR, MA, and differencing components can be adjusted in the model.\n",
+    "* Different parameter combinations may be explored, and various diagnostic plots and statistical methods can assist in selecting appropriate orders.\n",
+    "    - In this demonstration, we simplify the process by using: AR order = 1, MA order = 1 for regular components, and seasonal AR and MA orders are set to 0\n",
+    "    - Differencing order = 1 for both, for both the regular and seasonal components.\n",
+    "    - One of the reason for setting seasonal AR and MA orders are set to 0 is the relatively small time-series data (only 120 samples for train)\n",
+    "* In addition to forecasting, the model also provides upper and lower prediction intervals for each predicted point. These intervals can be used for anomaly detection by defining observations whose actual weekly sales fall outside the interval as anomalies.\n",
+    "* Note that the prediction interval represents the estimated range within which future observations are expected to fall with high probability (95% confidence in this example). This confidence level, and consequently the width of the interval, can be adjusted based on the use case."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "id": "47baea10-4096-48cd-a69b-3637dfda7d85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sales_col = 'Weekly_Sales'\n",
+    "date_col = 'Date'\n",
+    "\n",
+    "order_value = (1,1,1) #(AR order, Difference order, MA order)\n",
+    "seasonal_order_value = (0,1,0,52) #(AR seasonality order, Difference seasonality order, MA seasonality order, Seasonal perdiod)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "854fe6a3-14b8-45f2-a4db-c6be41481a4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                      SARIMAX Results                                      \n",
+      "===========================================================================================\n",
+      "Dep. Variable:                        Weekly_Sales   No. Observations:                  120\n",
+      "Model:             SARIMAX(1, 1, 1)x(0, 1, [], 52)   Log Likelihood               -1033.368\n",
+      "Date:                             Wed, 13 May 2026   AIC                           2098.737\n",
+      "Time:                                     07:20:05   BIC                           2133.527\n",
+      "Sample:                                          0   HQIC                          2112.464\n",
+      "                                             - 120                                         \n",
+      "Covariance Type:                               opg                                         \n",
+      "================================================================================\n",
+      "                   coef    std err          z      P>|z|      [0.025      0.975]\n",
+      "--------------------------------------------------------------------------------\n",
+      "Store        -2.243e-07   6.59e+04   -3.4e-12      1.000   -1.29e+05    1.29e+05\n",
+      "Dept          2.651e+04   1.38e+04      1.918      0.055    -583.914    5.36e+04\n",
+      "Temperature   1.505e+05   7.35e+04      2.048      0.041    6479.959    2.94e+05\n",
+      "Fuel_Price     3.21e+06   9.33e+04     34.414      0.000    3.03e+06    3.39e+06\n",
+      "MarkDown1       11.2278    214.999      0.052      0.958    -410.162     432.618\n",
+      "MarkDown2      164.6737     60.548      2.720      0.007      46.002     283.345\n",
+      "MarkDown3       -0.0833     50.376     -0.002      0.999     -98.818      98.652\n",
+      "MarkDown4      -94.9637    311.621     -0.305      0.761    -705.730     515.803\n",
+      "MarkDown5       16.0468    149.067      0.108      0.914    -276.118     308.212\n",
+      "CPI          -8.759e+05   7.33e+05     -1.195      0.232   -2.31e+06    5.61e+05\n",
+      "Unemployment  -9.18e+06   1.23e+04   -747.812      0.000    -9.2e+06   -9.16e+06\n",
+      "Type          2.464e+08    763.944   3.23e+05      0.000    2.46e+08    2.46e+08\n",
+      "Size         -2474.9103    964.845     -2.565      0.010   -4365.971    -583.850\n",
+      "ar.L1            0.0143      0.251      0.057      0.955      -0.477       0.506\n",
+      "ma.L1           -0.3316      0.260     -1.278      0.201      -0.840       0.177\n",
+      "sigma2        3.443e+12      0.163   2.11e+13      0.000    3.44e+12    3.44e+12\n",
+      "===================================================================================\n",
+      "Ljung-Box (L1) (Q):                   0.37   Jarque-Bera (JB):                 1.46\n",
+      "Prob(Q):                              0.54   Prob(JB):                         0.48\n",
+      "Heteroskedasticity (H):               1.26   Skew:                            -0.18\n",
+      "Prob(H) (two-sided):                  0.59   Kurtosis:                         3.63\n",
+      "===================================================================================\n",
+      "\n",
+      "Warnings:\n",
+      "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n",
+      "[2] Covariance matrix is singular or near-singular, with condition number 8.76e+28. Standard errors may be unstable.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We first start using all features for modeling\n",
+    "trend_cols = ['Store','Dept','IsHoliday','Temperature','Fuel_Price','MarkDown1','MarkDown2','MarkDown3','MarkDown4','MarkDown5','CPI','Unemployment','Type','Size']\n",
+    "\n",
+    "results = models.fit_model(train_df,\n",
+    "    order_value,\n",
+    "    seasonal_order_value,\n",
+    "    trend_cols,\n",
+    "    sales_col\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db0d5f70-6781-45a7-b6d8-f7195b10a87e",
+   "metadata": {},
+   "source": [
+    "* The P>|z| column in the report indicates that several features are not statistically significant.\n",
+    "* These features could potentially be removed in order to simplify the model and improve its interpretability."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "id": "e8d487e6-0194-412e-b34b-7af642465f4d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                      SARIMAX Results                                      \n",
+      "===========================================================================================\n",
+      "Dep. Variable:                        Weekly_Sales   No. Observations:                  120\n",
+      "Model:             SARIMAX(1, 1, 1)x(0, 1, [], 52)   Log Likelihood               -1040.944\n",
+      "Date:                             Wed, 13 May 2026   AIC                           2101.888\n",
+      "Time:                                     08:01:05   BIC                           2123.632\n",
+      "Sample:                                          0   HQIC                          2110.468\n",
+      "                                             - 120                                         \n",
+      "Covariance Type:                               opg                                         \n",
+      "================================================================================\n",
+      "                   coef    std err          z      P>|z|      [0.025      0.975]\n",
+      "--------------------------------------------------------------------------------\n",
+      "Dept          2.161e+04   1.64e+04      1.315      0.189   -1.06e+04    5.38e+04\n",
+      "Temperature   1.403e+05   7.33e+04      1.913      0.056   -3423.997    2.84e+05\n",
+      "Fuel_Price    7.467e+05   1.14e+05      6.560      0.000    5.24e+05     9.7e+05\n",
+      "CPI          -6.701e+05   9.66e+05     -0.693      0.488   -2.56e+06    1.22e+06\n",
+      "Unemployment -5.682e+06   7623.746   -745.275      0.000    -5.7e+06   -5.67e+06\n",
+      "Type          3.639e+08   1565.211   2.33e+05      0.000    3.64e+08    3.64e+08\n",
+      "Size         -3862.3864    845.618     -4.568      0.000   -5519.768   -2205.005\n",
+      "ar.L1           -0.1613      0.166     -0.973      0.330      -0.486       0.164\n",
+      "ma.L1           -0.1610      0.136     -1.186      0.236      -0.427       0.105\n",
+      "sigma2        4.386e+12      0.011   4.15e+14      0.000    4.39e+12    4.39e+12\n",
+      "===================================================================================\n",
+      "Ljung-Box (L1) (Q):                   0.43   Jarque-Bera (JB):                 4.04\n",
+      "Prob(Q):                              0.51   Prob(JB):                         0.13\n",
+      "Heteroskedasticity (H):               1.77   Skew:                             0.41\n",
+      "Prob(H) (two-sided):                  0.19   Kurtosis:                         3.91\n",
+      "===================================================================================\n",
+      "\n",
+      "Warnings:\n",
+      "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n",
+      "[2] Covariance matrix is singular or near-singular, with condition number 7.77e+32. Standard errors may be unstable.\n"
+     ]
+    }
+   ],
+   "source": [
+    "trend_cols = ['Dept','Temperature','Fuel_Price','CPI','Unemployment','Type','Size'] # simplified model\n",
+    "\n",
+    "results = models.fit_model(train_df,\n",
+    "    order_value,\n",
+    "    seasonal_order_value,\n",
+    "    trend_cols,\n",
+    "    sales_col\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73ca3921-6f9a-4109-bdfb-c28d470cd5f3",
+   "metadata": {},
+   "source": [
+    "* Once the model is fitted, we can evaluate its performance on the test dataset.\n",
+    "* There are two common ways for forecasting the test set, which in this case contains 10 samples:\n",
+    "\n",
+    "  1. Multi-step forecasting - forecast all test samples at once using the model fitted up to sample 120.\n",
+    "  2. Walk-forward forecasting - iteratively forecast the next sample and then update the model using the newly observed value, and therefore it is more accurate.\n",
+    "\n",
+    "* Each approach is suitable for different use cases:\n",
+    "  * If the production model is expected to remain static, the first approach is more appropriate.\n",
+    "  * If the model can be continuously updated with new observations, the walk-forward approach is preferred."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "id": "24a47bcf-64fb-444e-aa97-b9d853ffd34d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1400x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "X_test = test_df[trend_cols]\n",
+    "\n",
+    "forecast_obj = results.get_forecast(\n",
+    "    steps=len(test_df),\n",
+    "    exog=X_test\n",
+    ")\n",
+    "\n",
+    "forecast = forecast_obj.predicted_mean\n",
+    "conf_int = forecast_obj.conf_int()\n",
+    "\n",
+    "graphs.plot_forecast(\n",
+    "    train_df=train_df,\n",
+    "    test_df=test_df,\n",
+    "    sales_col=sales_col,\n",
+    "    forecast=forecast,\n",
+    "    conf_int=conf_int,\n",
+    "    title='10-Step Forecast vs Actual'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "id": "d5459c58-0883-43a6-82da-5669126c507b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "forecast_series, conf_int_df = utils.walk_forward_forecast(\n",
+    "    results=results,\n",
+    "    test_df=test_df,\n",
+    "    trend_cols=trend_cols,\n",
+    "    sales_col=sales_col\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "id": "e5564602-be84-4951-a1b5-6ec242a7c494",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1400x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "graphs.plot_forecast(\n",
+    "    train_df=train_df,\n",
+    "    test_df=test_df,\n",
+    "    sales_col=sales_col,\n",
+    "    forecast=forecast_series,\n",
+    "    conf_int=conf_int_df,\n",
+    "    title='Walk-Forward Forecast vs Actual'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6d1bf51-30e7-429a-98b8-55061d980673",
+   "metadata": {},
+   "source": [
+    "# Model Registration and Deployment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b22db66f-c3e2-44ea-bfc8-27ad79329cd4",
+   "metadata": {},
+   "source": [
+    "* Here we use ADS to simplify model artifact preparation for model registration in the OCI Data Science Model Catalog and deployment to a dedicated model deployment server.\n",
+    "* ADS supports two approaches for model artifact preparation:\n",
+    "    - ADS Models: ADS provides direct support for frameworks such as Scikit-learn, PyTorch, XGBoost, and others. In these cases, the generated artifacts are framework-specific and typically do not require customization.\n",
+    "    - ADS Generic: ADS provides an initial artifact template, which may sometimes be sufficient as-is, but in many cases requires minor adjustments. This is the approach used here, since the statsmodels framework, from which the SARIMAX model is imported, is not currently included in the list of supported ADS Models.\n",
+    "* For ADS documentation: https://accelerated-data-science.readthedocs.io/en/latest/user_guide/model_registration/introduction.html\n",
+    "* Other resources focus on model regitration and deployment are also publicly available: https://github.com/oracle-devrel/technology-engineering/tree/main/data-platform/data-science/oracle-data-science/customizing-ads-model-deployment-artifacts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "id": "b57d0390-4b4c-4c2a-b5a2-d98e47173683",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   Dept  Temperature  Fuel_Price         CPI  Unemployment      Type  \\\n",
+      "0  2955    33.277942    2.717869  167.398405      8.576731  2.412183   \n",
+      "\n",
+      "            Size  \n",
+      "0  137430.535364  \n"
+     ]
+    }
+   ],
+   "source": [
+    "artifact_dir = '/home/datascience/anomaly_detection_project/regression/artifact2' # local folder for saving the prepared artifacts temporarily\n",
+    "X_sample = train_df[trend_cols].iloc[[0]].copy()\n",
+    "print(X_sample)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "id": "6e1d1d68-a1de-40d6-8e8d-bcbc7c9f09c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:ads.common:In the future model input will be serialized by `cloudpickle` by default. Currently, model input are serialized into a dictionary containing serialized input data and original data type information.Set `model_input_serializer=\"cloudpickle\"` to use cloudpickle model input serializer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "artifact_object = GenericModel(estimator=results,\n",
+    "                            artifact_dir=artifact_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "id": "d5489499-fb09-4bed-ad75-69eaa940641c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                                                                                                                                                                                                                       ?, ?it/s]"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "algorithm: null\n",
+       "artifact_dir:\n",
+       "  /home/datascience/anomaly_detection_project/regression/artifact2:\n",
+       "  - - input_schema.json\n",
+       "    - .model-ignore\n",
+       "    - test_json_output.json\n",
+       "    - score.py\n",
+       "    - model.pkl\n",
+       "    - runtime.yaml\n",
+       "    - .ipynb_checkpoints\n",
+       "    - .ipynb_checkpoints/runtime-checkpoint.yaml\n",
+       "framework: null\n",
+       "model_deployment_id: null\n",
+       "model_id: null"
+      ]
+     },
+     "execution_count": 124,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Here we use a custom inference_conda_env, since additional packages were installed in the `generalml_p311_cpu_x86_64_v1` environment and should also be available in production\n",
+    "artifact_object.prepare(inference_conda_env='oci://pub-conda-env@fro8fl9kuqli/cpu/generalml_p311_cpu_x86_64_v1/1.0/generalml_p311_cpu_x86_64_v1',\n",
+    "                        inference_python_version=\"3.11\",\n",
+    "                        X_sample=X_sample,\n",
+    "                        force_overwrite=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "847ad133-3066-46a7-b51d-d2c6757be88b",
+   "metadata": {},
+   "source": [
+    "* Some modifications are required in the prepared artifacts:\n",
+    "  * In `score.py`:\n",
+    "    * Adjust the `predict` function to extract the SARIMAX forecast, along with the lower and upper confidence bounds used for anomaly detection (see the example in the `artifact example` folder).\n",
+    "    * Update the dataframe deserialization logic to use `StringIO` when reading JSON input.\n",
+    "    * Import `StringIO` at the beginning of the file.\n",
+    "  * In `runtime.yaml`:\n",
+    "    * Replace the default `INFERENCE_ENV_PATH` value with the path specified in the `prepare()` function.\n",
+    "* After applying these adjustments, use the `reload()` method to reload the updated artifacts into memory.\n",
+    "* Then, we will verify and inspect the artifacts to ensure they are ready for registration and deployment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "id": "0224873a-95fc-4fc8-abf7-391c8a5adb68",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start loading model.pkl from model directory /home/datascience/anomaly_detection_project/regression/artifact2 ...\n",
+      "Model is successfully loaded.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "algorithm: null\n",
+       "artifact_dir:\n",
+       "  /home/datascience/anomaly_detection_project/regression/artifact2:\n",
+       "  - - input_schema.json\n",
+       "    - .model-ignore\n",
+       "    - test_json_output.json\n",
+       "    - score.py\n",
+       "    - model.pkl\n",
+       "    - runtime.yaml\n",
+       "framework: null\n",
+       "model_deployment_id: null\n",
+       "model_id: null"
+      ]
+     },
+     "execution_count": 125,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "artifact_object.reload()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 126,
+   "id": "a7a67900-d733-4006-925b-71182c027602",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Start loading model.pkl from model directory /home/datascience/anomaly_detection_project/regression/artifact2 ...\n",
+      "Model is successfully loaded.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'prediction': 39198244.41113508,\n",
+       " 'lower_prediction_interval': 35093432.406648,\n",
+       " 'upper_prediction_interval': 43303056.41562215}"
+      ]
+     },
+     "execution_count": 126,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "artifact_object.verify(X_sample, auto_serialize_data=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "id": "ccb5fdad-1939-452b-bd73-50365c46d486",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['input_schema.json', '.model-ignore', 'test_json_output.json', 'score.py', 'model.pkl', 'runtime.yaml']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Test key</th>\n",
+       "      <th>Test name</th>\n",
+       "      <th>Result</th>\n",
+       "      <th>Message</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>runtime_env_path</td>\n",
+       "      <td>Check that field MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is set</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>runtime_env_python</td>\n",
+       "      <td>Check that field MODEL_DEPLOYMENT.INFERENCE_PYTHON_VERSION is set to a value of 3.6 or higher</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>runtime_path_exist</td>\n",
+       "      <td>Check that the file path in MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is correct.</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>runtime_version</td>\n",
+       "      <td>Check that field MODEL_ARTIFACT_VERSION is set to 3.0</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>runtime_yaml</td>\n",
+       "      <td>Check that the file \"runtime.yaml\" exists and is in the top level directory of the artifact directory</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>score_load_model</td>\n",
+       "      <td>Check that load_model() is defined</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>score_predict</td>\n",
+       "      <td>Check that predict() is defined</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>score_predict_arg</td>\n",
+       "      <td>Check that all other arguments in predict() are optional and have default values</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>score_predict_data</td>\n",
+       "      <td>Check that the only required argument for predict() is named \"data\"</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>score_py</td>\n",
+       "      <td>Check that the file \"score.py\" exists and is in the top level directory of the artifact directory</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>score_syntax</td>\n",
+       "      <td>Check for Python syntax errors</td>\n",
+       "      <td>Passed</td>\n",
+       "      <td></td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              Test key  \\\n",
+       "0     runtime_env_path   \n",
+       "1   runtime_env_python   \n",
+       "2   runtime_path_exist   \n",
+       "3      runtime_version   \n",
+       "4         runtime_yaml   \n",
+       "5     score_load_model   \n",
+       "6        score_predict   \n",
+       "7    score_predict_arg   \n",
+       "8   score_predict_data   \n",
+       "9             score_py   \n",
+       "10        score_syntax   \n",
+       "\n",
+       "                                                                                                Test name  \\\n",
+       "0                                             Check that field MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is set   \n",
+       "1           Check that field MODEL_DEPLOYMENT.INFERENCE_PYTHON_VERSION is set to a value of 3.6 or higher   \n",
+       "2                             Check that the file path in MODEL_DEPLOYMENT.INFERENCE_ENV_PATH is correct.   \n",
+       "3                                                   Check that field MODEL_ARTIFACT_VERSION is set to 3.0   \n",
+       "4   Check that the file \"runtime.yaml\" exists and is in the top level directory of the artifact directory   \n",
+       "5                                                                      Check that load_model() is defined   \n",
+       "6                                                                         Check that predict() is defined   \n",
+       "7                        Check that all other arguments in predict() are optional and have default values   \n",
+       "8                                     Check that the only required argument for predict() is named \"data\"   \n",
+       "9       Check that the file \"score.py\" exists and is in the top level directory of the artifact directory   \n",
+       "10                                                                         Check for Python syntax errors   \n",
+       "\n",
+       "    Result Message  \n",
+       "0   Passed          \n",
+       "1   Passed          \n",
+       "2   Passed          \n",
+       "3   Passed          \n",
+       "4   Passed          \n",
+       "5   Passed          \n",
+       "6   Passed          \n",
+       "7   Passed          \n",
+       "8   Passed          \n",
+       "9   Passed          \n",
+       "10  Passed          "
+      ]
+     },
+     "execution_count": 127,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "artifact_object.introspect()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a6a8486-fa90-4154-95a5-dbe684c1e2ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Model registration in the model catalog\n",
+    "model_id = artifact_object.save(\n",
+    "    display_name=\"walmart_sarimax_2\",\n",
+    "    description=\"time series regression for anomaly detection.\",\n",
+    "    ignore_pending_changes=True)\n",
+    "\n",
+    "print(f\"Model saved: {model_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49e2e4ed-54a8-4c55-b70a-c14f7e01658a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Model deployment\n",
+    "deployed_model = artifact_object.deploy(\n",
+    "    display_name=\"walmart_sarimax_2\", \n",
+    "    deployment_log_group_id=\"ocid1.loggroup.oc1.eu-frankfurt-1.amaaaaaaeicj2tia4cocgvb633rdxs332osruo2jscng5ohsdypaqtco7mwq\",\n",
+    "    deployment_predict_log_id=\"ocid1.log.oc1.eu-frankfurt-1.amaaaaaaeicj2tiasvsazwagozz5s7xma73ne5cvgqubbxhl67jr2mz32rbq\",\n",
+    "    deployment_instance_shape=\"VM.Standard.E4.Flex\",\n",
+    "    deployment_ocpus=1,\n",
+    "    deployment_memory_in_gbs=16\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a5d42a3c-5f69-4ca5-a41d-a801260414dc",
+   "metadata": {},
+   "source": [
+    "# Scoring"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 136,
+   "id": "eea03074-f687-41ed-b789-7d7386d7c651",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "endpoint = \"<your_endpoint>\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 141,
+   "id": "712ae0ab-4108-4424-a681-7dd90e118b2b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'prediction': 39198244.41747442, 'lower_prediction_interval': 35093432.412987344, 'upper_prediction_interval': 43303056.421961494}\n"
+     ]
+    }
+   ],
+   "source": [
+    "payload = X_sample.to_dict(orient=\"list\")\n",
+    "\n",
+    "response = requests.post(\n",
+    "    endpoint,\n",
+    "    json=payload,\n",
+    "    auth=signer\n",
+    ")\n",
+    "\n",
+    "print(response.json())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:generalml_p311_cpu_x86_64_v1]",
+   "language": "python",
+   "name": "conda-env-generalml_p311_cpu_x86_64_v1-py"
+  },
+  "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_automation.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_automation.ipynb
new file mode 100644
index 000000000..ef93e3d00
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_automation.ipynb
@@ -0,0 +1,102 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9ff644b0-545f-4836-83e8-6b76880c29c6",
+   "metadata": {},
+   "source": [
+    "# Automating Anomaly Detection and Monitoring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "330c4762-0efa-4d3e-9b71-3a3b7531c49e",
+   "metadata": {},
+   "source": [
+    "* This notebook creates a job for running monitoring on the weekly data. The job executes the job_run folder, using job_run/monitoring.py as the entry point.\n",
+    "* To complete the automation workflow, the OCI Data Science Schedule feature should also be used to configure recurring weekly execution.\n",
+    "\n",
+    "Conda Environment: generalml_p311_cpu_x86_64_v1\n",
+    "\n",
+    "Author: Assaf Rabinowicz, Data Scientist EMEA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4dbf11c6-e9a7-45a0-b77c-8efca009c446",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ads.jobs import Job, DataScienceJob, PythonRuntime\n",
+    "from ads import set_auth\n",
+    "\n",
+    "set_auth(\"resource_principal\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b50edf8-9505-4cf6-91a4-b00f3a42e57c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job = (\n",
+    "    Job(name=\"Monitoring Walmart Anaomaly Detection\")\n",
+    "    .with_infrastructure(\n",
+    "        DataScienceJob()\n",
+    "        .with_log_group_id('<your_log_group_ocid>')\n",
+    "        .with_log_id('<your_log_ocid>')\n",
+    "        .with_shape_name(\"VM.Standard.E4.Flex\")\n",
+    "        .with_shape_config_details(memory_in_gbs=4, ocpus=1)\n",
+    "    )\n",
+    "    .with_runtime(\n",
+    "        PythonRuntime()\n",
+    "        .with_service_conda(\"generalml_p311_cpu_x86_64_v1\")\n",
+    "        .with_source(\"<your_folder_path>\") # example: /home/datascience/anomaly_detection_project/regression/src/production_monitoring_automation/job_folder\n",
+    "        .with_working_dir(\"<folder_name>\") # example: 'job_folder' \n",
+    "        .with_entrypoint(\"<your_entrypoint_file_name>\") # no need full path. Only file name, example: monitoring.py\n",
+    "        .with_output(\"output\", \"oci://<bucket_name>@<name_space>\") # the output will be deleted after deprovisioning\n",
+    "        .with_environment_variable(INPUT_FILE_NAME=\"PLACEHOLDER\") # this parameters is later customized in the job run using env_var\n",
+    "    )\n",
+    ")\n",
+    "job.create()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd151e42-c2cc-4d26-b4e3-0b440ffceaee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_run = job.run(\n",
+    "    name=\"walmart sales monitoring, '2012-08-03.csv'\",\n",
+    "    env_var={'INPUT_FILE_NAME': '2012-08-03.csv'} # in every run we can change these values.\n",
+    ")\n",
+    "job_run.watch()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:generalml_p311_cpu_x86_64_v1]",
+   "language": "python",
+   "name": "conda-env-generalml_p311_cpu_x86_64_v1-py"
+  },
+  "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/__init__.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/config.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/config.py
new file mode 100644
index 000000000..9fd2db3d0
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/config.py
@@ -0,0 +1,24 @@
+
+BUCKET_NAME = "anomaly-detection-regression"
+FOLDER_NAME = "daily_files"
+
+# Must match the model training / deployment input features
+FEATURE_COLS = [
+    "Dept",
+    "Temperature",
+    "Fuel_Price",
+    "CPI",
+    "Unemployment",
+    "Type",
+    "Size",
+]
+
+DATE_COL = "Date"
+TARGET_COL = "Weekly_Sales"
+
+MONITORING_NAMESPACE = "walmart_sales_forecast"
+MONITORING_METRIC_NAME = "weekly_sales"
+COMPARTMENT='<your_compartment_ocid>'
+
+ENDPOINT= "<your_endpoint>"
+
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/helper.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/helper.py
new file mode 100644
index 000000000..05db85cee
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/helper.py
@@ -0,0 +1,102 @@
+import io
+import pandas as pd
+import requests
+from datetime import datetime, timezone
+from oci.monitoring.models import Datapoint, MetricDataDetails, PostMetricDataDetails
+
+def read_csv_from_object_storage(client, namespace, bucket, folder_name, object_name):
+    full_object_name = f"{folder_name}/{object_name}"
+
+    resp = client.get_object(
+        namespace_name=namespace,
+        bucket_name=bucket,
+        object_name=full_object_name
+    )
+
+    return pd.read_csv(io.StringIO(resp.data.text))
+
+
+def call_deployed_model(endpoint, signer, payload):
+    response = requests.post(endpoint, json=payload, auth=signer, timeout=60)
+    return response.json()
+
+def create_aggregated_df(df):
+    agg_df = (
+        df.groupby('Date', as_index=False)
+          .agg({
+              'Store': 'nunique',
+              'Dept': 'count',
+              'IsHoliday': 'sum',
+              'Weekly_Sales': 'sum',
+              'Temperature': 'mean',
+              'Fuel_Price': 'mean',
+              'MarkDown1': 'mean',
+              'MarkDown2': 'mean',
+              'MarkDown3': 'mean',
+              'MarkDown4': 'mean',
+              'MarkDown5': 'mean',
+              'CPI': 'mean',
+              'Unemployment': 'mean',
+              'Type': 'mean',
+              'Size': 'mean'
+          })
+          .sort_values('Date')
+          .reset_index(drop=True)
+    )
+
+    return agg_df
+
+def push_forecast_metrics(
+    monitoring_client,
+    compartment_id,
+    namespace,
+    metric_name,
+    actual,
+    predicted,
+    lower,
+    upper,
+    resource_group=None,
+    timestamp=None):
+    ts = timestamp or datetime.now(timezone.utc)
+
+    metric_data = [
+        MetricDataDetails(
+            compartment_id=compartment_id,
+            namespace=namespace,
+            name=metric_name,
+            resource_group=resource_group,
+            dimensions={"series": "actual"},
+            datapoints=[Datapoint(timestamp=ts, value=float(actual))],
+        ),
+        MetricDataDetails(
+            compartment_id=compartment_id,
+            namespace=namespace,
+            name=metric_name,
+            resource_group=resource_group,
+            dimensions={"series": "predicted"},
+            datapoints=[Datapoint(timestamp=ts, value=float(predicted))],
+        ),
+        MetricDataDetails(
+            compartment_id=compartment_id,
+            namespace=namespace,
+            name=metric_name,
+            resource_group=resource_group,
+            dimensions={"series": "lower"},
+            datapoints=[Datapoint(timestamp=ts, value=float(lower))],
+        ),
+        MetricDataDetails(
+            compartment_id=compartment_id,
+            namespace=namespace,
+            name=metric_name,
+            resource_group=resource_group,
+            dimensions={"series": "upper"},
+            datapoints=[Datapoint(timestamp=ts, value=float(upper))],
+        ),
+    ]
+
+    payload = PostMetricDataDetails(
+        metric_data=metric_data,
+        batch_atomicity="NON_ATOMIC",
+    )
+
+    return monitoring_client.post_metric_data(payload)
\ No newline at end of file
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/monitoring.py b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/monitoring.py
new file mode 100644
index 000000000..77f6101fb
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/job_folder/monitoring.py
@@ -0,0 +1,78 @@
+import io
+import os
+import pandas as pd
+import requests
+
+import oci
+
+import helper
+import config
+
+
+bucket_name = config.BUCKET_NAME
+folder_name= config.FOLDER_NAME
+feature_cols = config.FEATURE_COLS
+date_col= config.DATE_COL
+target_col= config.TARGET_COL
+compartment_id=config.COMPARTMENT
+monitoring_namespace=config.MONITORING_NAMESPACE
+metric_name=config.MONITORING_METRIC_NAME
+endpoint=config.ENDPOINT
+
+input_file_name = os.getenv("INPUT_FILE_NAME")
+print(input_file_name)
+
+signer = oci.auth.signers.get_resource_principals_signer()
+object_storage_client = oci.object_storage.ObjectStorageClient(
+    config={},
+    signer=signer
+)
+
+namespace_name = object_storage_client.get_namespace().data
+
+df = helper.read_csv_from_object_storage(
+    client=object_storage_client,
+    namespace=namespace_name,
+    bucket=bucket_name,
+    folder_name=folder_name,
+    object_name=input_file_name
+)
+#df.head()
+
+agg_df = helper.create_aggregated_df(df)
+
+if len(agg_df) != 1:
+    raise ValueError(f"Expected exactly 1 aggregated row, got {len(agg_df)}")
+features_df = agg_df[feature_cols].copy()
+#features_df.head()
+
+features_df = features_df[feature_cols].copy()
+payload = features_df.to_dict(orient="list")
+
+result = helper.call_deployed_model(endpoint, signer, payload)
+
+prediction = float(result["prediction"])
+lower = float(result["lower_prediction_interval"])
+upper = float(result["upper_prediction_interval"])
+actual = float(agg_df[target_col].iloc[0])
+
+is_anomaly = actual < lower or actual > upper
+print(is_anomaly)
+
+monitoring_client = oci.monitoring.MonitoringClient(
+    config={},
+    signer=signer,
+    service_endpoint="https://telemetry-ingestion.eu-frankfurt-1.oraclecloud.com"
+)
+
+response = helper.push_forecast_metrics(
+    monitoring_client=monitoring_client,
+    compartment_id=compartment_id,
+    namespace=monitoring_namespace,
+    metric_name=metric_name,
+    actual=actual,
+    predicted=prediction,
+    lower=lower,
+    upper=upper,
+)
+print(response.data)
diff --git a/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/monitoring.ipynb b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/monitoring.ipynb
new file mode 100644
index 000000000..fe237d3de
--- /dev/null
+++ b/data-platform/data-science/oracle-data-science/anomaly-detection/files/sales_unlabeled_anomaly_detection/src/production_monitoring_automation/monitoring.ipynb
@@ -0,0 +1,522 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9f140a3a-f904-4775-94fa-8f2447ca1421",
+   "metadata": {},
+   "source": [
+    "# Anomaly Detection Monitoring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7eec7877-9771-4c3c-95e2-7be327e6012d",
+   "metadata": {},
+   "source": [
+    "* This notebook demonstrates how to use the deployed model for anomaly detection and for pushing metrics to the OCI Monitoring service.\n",
+    "* This notebook is intended for demonstration purposes only. The production-ready implementation is also available in `job_folder/monitoring.py`, which is used by `job_automation.py` for automated monitoring workflows.\n",
+    "* The notebook covers the following topics:\n",
+    "  * Importing weekly data from OCI Object Storage\n",
+    "  * Processing and aggregating the data to align with the business problem and model requirements\n",
+    "  * Using the deployed model to generate predictions and prediction intervals\n",
+    "  * Flagging anomalies, defined as observations that fall outside the prediction interval\n",
+    "  * Pushing metrics to OCI Monitoring\n",
+    "\n",
+    "Conda Environment: `generalml_p311_cpu_x86_64_v1`\n",
+    "\n",
+    "Author: Assaf Rabinowicz, Data Scientist EMEA"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5074ea87-0659-46c6-a2ce-8be0bb8ec39a",
+   "metadata": {},
+   "source": [
+    "# Package and Data Collection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a23766ac-0395-4bb2-bb1e-dd3cc41fccf3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import requests\n",
+    "import oci\n",
+    "import sys\n",
+    "import pandas as pd\n",
+    "\n",
+    "from job_folder import helper\n",
+    "from job_folder import config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "dd4e4e4b-ef96-48ac-8ef2-72b6483d4462",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bucket_name = config.BUCKET_NAME\n",
+    "folder_name= config.FOLDER_NAME\n",
+    "feature_cols = config.FEATURE_COLS\n",
+    "date_col= config.DATE_COL\n",
+    "target_col= config.TARGET_COL\n",
+    "compartment_id=config.COMPARTMENT\n",
+    "monitoring_namespace=config.MONITORING_NAMESPACE\n",
+    "metric_name=config.MONITORING_METRIC_NAME\n",
+    "endpoint=config.ENDPOINT\n",
+    "\n",
+    "signer = oci.auth.signers.get_resource_principals_signer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d5cfbac9-e404-4afa-81ed-77eefe06b0fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_file_name='2012-08-03.csv' # relevant only for this notebook. The file name will be sent as environment variable in the job."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "edc94103-5a08-4ba0-95e9-ee92ab0cf7c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "object_storage_client = oci.object_storage.ObjectStorageClient(\n",
+    "    config={},\n",
+    "    signer=signer\n",
+    ")\n",
+    "\n",
+    "namespace_name = object_storage_client.get_namespace().data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "32b75803-a616-4e8d-aacd-b927f23c5dfb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Unnamed: 0</th>\n",
+       "      <th>Store</th>\n",
+       "      <th>Date</th>\n",
+       "      <th>IsHoliday</th>\n",
+       "      <th>Dept</th>\n",
+       "      <th>Weekly_Sales</th>\n",
+       "      <th>Temperature</th>\n",
+       "      <th>Fuel_Price</th>\n",
+       "      <th>MarkDown1</th>\n",
+       "      <th>MarkDown2</th>\n",
+       "      <th>MarkDown3</th>\n",
+       "      <th>MarkDown4</th>\n",
+       "      <th>MarkDown5</th>\n",
+       "      <th>CPI</th>\n",
+       "      <th>Unemployment</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Size</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>321201</td>\n",
+       "      <td>33</td>\n",
+       "      <td>2012-08-03</td>\n",
+       "      <td>0</td>\n",
+       "      <td>52.0</td>\n",
+       "      <td>9.00</td>\n",
+       "      <td>92.13</td>\n",
+       "      <td>3.595</td>\n",
+       "      <td>238.26</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>2.88</td>\n",
+       "      <td>44.29</td>\n",
+       "      <td>767.86</td>\n",
+       "      <td>130.737871</td>\n",
+       "      <td>7.147</td>\n",
+       "      <td>3</td>\n",
+       "      <td>39690</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>147727</td>\n",
+       "      <td>15</td>\n",
+       "      <td>2012-08-03</td>\n",
+       "      <td>0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>1262.94</td>\n",
+       "      <td>73.13</td>\n",
+       "      <td>3.819</td>\n",
+       "      <td>7251.41</td>\n",
+       "      <td>216.62</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>4906.29</td>\n",
+       "      <td>1420.37</td>\n",
+       "      <td>138.173581</td>\n",
+       "      <td>8.193</td>\n",
+       "      <td>2</td>\n",
+       "      <td>123737</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>147728</td>\n",
+       "      <td>15</td>\n",
+       "      <td>2012-08-03</td>\n",
+       "      <td>0</td>\n",
+       "      <td>81.0</td>\n",
+       "      <td>4051.58</td>\n",
+       "      <td>73.13</td>\n",
+       "      <td>3.819</td>\n",
+       "      <td>7251.41</td>\n",
+       "      <td>216.62</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>4906.29</td>\n",
+       "      <td>1420.37</td>\n",
+       "      <td>138.173581</td>\n",
+       "      <td>8.193</td>\n",
+       "      <td>2</td>\n",
+       "      <td>123737</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>147729</td>\n",
+       "      <td>15</td>\n",
+       "      <td>2012-08-03</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>14832.84</td>\n",
+       "      <td>73.13</td>\n",
+       "      <td>3.819</td>\n",
+       "      <td>7251.41</td>\n",
+       "      <td>216.62</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>4906.29</td>\n",
+       "      <td>1420.37</td>\n",
+       "      <td>138.173581</td>\n",
+       "      <td>8.193</td>\n",
+       "      <td>2</td>\n",
+       "      <td>123737</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>321192</td>\n",
+       "      <td>33</td>\n",
+       "      <td>2012-08-03</td>\n",
+       "      <td>0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>35.00</td>\n",
+       "      <td>92.13</td>\n",
+       "      <td>3.595</td>\n",
+       "      <td>238.26</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>2.88</td>\n",
+       "      <td>44.29</td>\n",
+       "      <td>767.86</td>\n",
+       "      <td>130.737871</td>\n",
+       "      <td>7.147</td>\n",
+       "      <td>3</td>\n",
+       "      <td>39690</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Unnamed: 0  Store        Date  IsHoliday  Dept  Weekly_Sales  Temperature  \\\n",
+       "0      321201     33  2012-08-03          0  52.0          9.00        92.13   \n",
+       "1      147727     15  2012-08-03          0  27.0       1262.94        73.13   \n",
+       "2      147728     15  2012-08-03          0  81.0       4051.58        73.13   \n",
+       "3      147729     15  2012-08-03          0   4.0      14832.84        73.13   \n",
+       "4      321192     33  2012-08-03          0   5.0         35.00        92.13   \n",
+       "\n",
+       "   Fuel_Price  MarkDown1  MarkDown2  MarkDown3  MarkDown4  MarkDown5  \\\n",
+       "0       3.595     238.26       0.00       2.88      44.29     767.86   \n",
+       "1       3.819    7251.41     216.62       0.48    4906.29    1420.37   \n",
+       "2       3.819    7251.41     216.62       0.48    4906.29    1420.37   \n",
+       "3       3.819    7251.41     216.62       0.48    4906.29    1420.37   \n",
+       "4       3.595     238.26       0.00       2.88      44.29     767.86   \n",
+       "\n",
+       "          CPI  Unemployment  Type    Size  \n",
+       "0  130.737871         7.147     3   39690  \n",
+       "1  138.173581         8.193     2  123737  \n",
+       "2  138.173581         8.193     2  123737  \n",
+       "3  138.173581         8.193     2  123737  \n",
+       "4  130.737871         7.147     3   39690  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = helper.read_csv_from_object_storage(\n",
+    "    client=object_storage_client,\n",
+    "    namespace=namespace_name,\n",
+    "    bucket=bucket_name,\n",
+    "    folder_name=folder_name,\n",
+    "    object_name=input_file_name\n",
+    ")\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8b6023a-79df-4b6b-9e06-f9edaee93e7d",
+   "metadata": {},
+   "source": [
+    "# Date Processing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2c8ed05c-895e-41cd-948a-e04e4221a4fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Dept</th>\n",
+       "      <th>Temperature</th>\n",
+       "      <th>Fuel_Price</th>\n",
+       "      <th>CPI</th>\n",
+       "      <th>Unemployment</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Size</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2967</td>\n",
+       "      <td>79.944317</td>\n",
+       "      <td>3.568967</td>\n",
+       "      <td>175.157356</td>\n",
+       "      <td>7.232204</td>\n",
+       "      <td>2.402764</td>\n",
+       "      <td>136191.124031</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Dept  Temperature  Fuel_Price         CPI  Unemployment      Type  \\\n",
+       "0  2967    79.944317    3.568967  175.157356      7.232204  2.402764   \n",
+       "\n",
+       "            Size  \n",
+       "0  136191.124031  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agg_df = helper.create_aggregated_df(df)\n",
+    "\n",
+    "if len(agg_df) != 1:\n",
+    "    raise ValueError(f\"Expected exactly 1 aggregated row, got {len(agg_df)}\")\n",
+    "features_df = agg_df[feature_cols].copy()\n",
+    "features_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "aa44f3a6-355c-4d83-ba8c-d229e7f98ad9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "features_df = features_df[feature_cols].copy()\n",
+    "payload = features_df.to_dict(orient=\"list\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b5bba64-d23a-4e27-8b8a-44a689a596bc",
+   "metadata": {},
+   "source": [
+    "# Scoring and Metrics Collection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f2ae1d62-58f4-4d60-9b1b-e0ccee3c900e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = helper.call_deployed_model(endpoint, signer, payload)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "efd48e23-80e3-4f54-9961-44ced78a23b5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "prediction = float(result[\"prediction\"])\n",
+    "lower = float(result[\"lower_prediction_interval\"])\n",
+    "upper = float(result[\"upper_prediction_interval\"])\n",
+    "actual = float(agg_df[target_col].iloc[0])\n",
+    "\n",
+    "is_anomaly = actual < lower or actual > upper\n",
+    "print(is_anomaly)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61b3d464-e254-4eb6-9d0c-a65931afe9ba",
+   "metadata": {},
+   "source": [
+    "# Monitoring"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c2ebcb26-34fe-45ac-b98d-a69fd3a04c3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "monitoring_client = oci.monitoring.MonitoringClient(\n",
+    "    config={},\n",
+    "    signer=signer,\n",
+    "    service_endpoint=\"https://telemetry-ingestion.eu-frankfurt-1.oraclecloud.com\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6c342edf-9470-46ee-a259-31f93e9ed198",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "47485899.56"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "actual"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "eaa99680-cfd0-4b1f-9545-0f8974c709e1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "  \"failed_metrics\": [],\n",
+      "  \"failed_metrics_count\": 0\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = helper.push_forecast_metrics(\n",
+    "    monitoring_client=monitoring_client,\n",
+    "    compartment_id=compartment_id,\n",
+    "    namespace=monitoring_namespace,\n",
+    "    metric_name=metric_name,\n",
+    "    actual=actual,\n",
+    "    predicted=prediction,\n",
+    "    lower=lower,\n",
+    "    upper=upper,\n",
+    ")\n",
+    "print(response.data)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:generalml_p311_cpu_x86_64_v1]",
+   "language": "python",
+   "name": "conda-env-generalml_p311_cpu_x86_64_v1-py"
+  },
+  "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/data-platform/data-science/oracle-data-science/your-first-data-science-project/files/Guide for Your First Data Science Project prerequisites.pdf b/data-platform/data-science/oracle-data-science/your-first-data-science-project/files/Guide for Your First Data Science Project prerequisites.pdf
index ab9dab655..dc76e9426 100644
Binary files a/data-platform/data-science/oracle-data-science/your-first-data-science-project/files/Guide for Your First Data Science Project prerequisites.pdf and b/data-platform/data-science/oracle-data-science/your-first-data-science-project/files/Guide for Your First Data Science Project prerequisites.pdf differ