examples/notebooks/responsibleaidashboard-housing-decision-making.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "da845744",
   "metadata": {},
   "source": [
    "# Plan house improvements using causal analysis\n",
    "\n",
    "This notebook demonstrates the use of the Responsible AI Toolbox to make renovation decisions from historic apartments pricing data. It is based on a [similar notebook in the `responsible-ai-toolbox` repository](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/responsibleaidashboard-housing-decision-making.ipynb), but updated to use the AzureML Responsible AI components.\n",
    "\n",
    "First, we need to specify the version of the RAI components which are available in the workspace. This was specified when the components were uploaded, and will have defaulted to '1':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79d7602c",
   "metadata": {},
   "outputs": [],
   "source": [
    "version_string = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eac43a6a",
   "metadata": {},
   "source": [
    "We also need to give the name of the compute cluster we want to use in AzureML. Later in this notebook, we will create it if it does not already exist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83b67493",
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_name = \"cpucluster\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db6c766b",
   "metadata": {},
   "source": [
    "Finally, we need to specify a version for the data and components we will create while running this notebook. This should be unique for the workspace, but the specific value doesn't matter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b956222",
   "metadata": {},
   "outputs": [],
   "source": [
    "rai_house_improvement_version_string = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d38010",
   "metadata": {},
   "source": [
    "## Accessing the Data\n",
    "\n",
    "The following section examines the code necessary to create datasets and a model using components in AzureML.\n",
    "\n",
    "### Fetching the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6725e43c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = 'data/apartments-train.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "612d6538",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.model_selection import train_test_split\n",
    "import zipfile\n",
    "\n",
    "def split_label(dataset, target_feature):\n",
    "    X = dataset.drop([target_feature], axis=1)\n",
    "    y = dataset[[target_feature]]\n",
    "    return X, y\n",
    "\n",
    "def clean_data(X, y, target_feature):\n",
    "    features = X.columns.values.tolist()\n",
    "    classes = y[target_feature].unique().tolist()\n",
    "    pipe_cfg = {\n",
    "        'num_cols': X.dtypes[X.dtypes == 'int64'].index.values.tolist(),\n",
    "        'cat_cols': X.dtypes[X.dtypes == 'object'].index.values.tolist(),\n",
    "    }\n",
    "    num_pipe = Pipeline([\n",
    "        ('num_imputer', SimpleImputer(strategy='median')),\n",
    "        ('num_scaler', StandardScaler())\n",
    "    ])\n",
    "    cat_pipe = Pipeline([\n",
    "        ('cat_imputer', SimpleImputer(strategy='constant', fill_value='?')),\n",
    "        ('cat_encoder', OneHotEncoder(handle_unknown='ignore', sparse_output=False))\n",
    "    ])\n",
    "    feat_pipe = ColumnTransformer([\n",
    "        ('num_pipe', num_pipe, pipe_cfg['num_cols']),\n",
    "        ('cat_pipe', cat_pipe, pipe_cfg['cat_cols'])\n",
    "    ])\n",
    "    X = feat_pipe.fit_transform(X)\n",
    "    print(pipe_cfg['cat_cols'])\n",
    "    return X, feat_pipe, features, classes\n",
    "\n",
    "target_feature = 'SalePriceK'\n",
    "categorical_features = []\n",
    "\n",
    "all_data = pd.read_csv(data_path)\n",
    "all_data = all_data.drop(['Sold_HigherThan_Median','SalePrice'], axis=1)\n",
    "X, y = split_label(all_data, target_feature)\n",
    "X_train_original, X_test_original, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=7)\n",
    "\n",
    "X_train, feat_pipe, features, classes = clean_data(X_train_original, y_train, target_feature)\n",
    "y_train = y_train[target_feature].to_numpy()\n",
    "\n",
    "X_test = feat_pipe.transform(X_test_original)\n",
    "y_test = y_test[target_feature].to_numpy()\n",
    "\n",
    "train_data_df = X_train_original.copy()\n",
    "train_data_df[target_feature] = y_train\n",
    "\n",
    "test_data_df = X_test_original.copy()\n",
    "test_data_df[target_feature] = y_test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "219661db",
   "metadata": {},
   "source": [
    "### Get the Data to AzureML\n",
    "\n",
    "With the data now split into 'train' and 'test' DataFrames, we save them out to files in preparation for upload into AzureML:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6f3c2f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Saving to files\")\n",
    "\n",
    "train_filename = \"housing_improvement_train.parquet\"\n",
    "test_filename = \"housing_improvement_test.parquet\"\n",
    "\n",
    "train_data_df.to_parquet(train_filename, index=False)\n",
    "test_data_df.to_parquet(test_filename, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1dafde1",
   "metadata": {},
   "source": [
    "We are going to create two Datasets in AzureML, one for the train and one for the test datasets. The first step is to create an `MLClient` to perform the upload. The method we use assumes that there is a `config.json` file (downloadable from the Azure or AzureML portals) present in the same directory as this notebook file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3890eeec",
   "metadata": {},
   "outputs": [],
   "source": [
    "from azure.ai.ml import MLClient\n",
    "from azure.identity import DefaultAzureCredential\n",
    "ml_client = MLClient.from_config(credential=DefaultAzureCredential(exclude_shared_token_cache_credential=True),\n",
    "                     logging_enable=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83007b2",
   "metadata": {},
   "source": [
    "We can then define the Datasets, and create them in AzureML. This will also upload the Parquet files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1a2b8ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from azure.ai.ml.entities import Data\n",
    "from azure.ai.ml.constants import AssetTypes\n",
    "\n",
    "input_train_data = \"housing_improvement_train_pq\"\n",
    "input_test_data = \"housing_improvement_test_pq\"\n",
    "\n",
    "train_data = Data(\n",
    "    path=train_filename,\n",
    "    type=AssetTypes.URI_FILE,\n",
    "    description=\"RAI housing improvement example training data\",\n",
    "    name=input_train_data,\n",
    "    version=rai_house_improvement_version_string,\n",
    ")\n",
    "ml_client.data.create_or_update(train_data)\n",
    "\n",
    "test_data = Data(\n",
    "    path=test_filename,\n",
    "    type=AssetTypes.URI_FILE,\n",
    "    description=\"RAI housing improvement example test data\",\n",
    "    name=input_test_data,\n",
    "    version=rai_house_improvement_version_string,\n",
    ")\n",
    "ml_client.data.create_or_update(test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c998b4",
   "metadata": {},
   "source": [
    "## A model training pipeline\n",
    "\n",
    "Firstly, we should note that for this example, we do not actually require a model; we are going to undertake a causal analysis which purely works on the data. However, for our Responsible AI components, a model is required, since the portal shows the analyses under the Model view. To simplify the model creation process, we're going to use a pipeline. This will have two stages:\n",
    "\n",
    "1. The actual training component\n",
    "1. A model registration component\n",
    "\n",
    "We have to register the model in AzureML in order for our RAI insights components to use it.\n",
    "\n",
    "### The Training Component\n",
    "\n",
    "The training component is for this particular model. In this case, we are going to use the `DummyRegressor` from SciKit-Learn.\n",
    "\n",
    "We start by creating a directory to hold the component source:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a04f2eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.makedirs('component_src', exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc536e51",
   "metadata": {},
   "source": [
    "Now, the component source code itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4845496e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile component_src/dummy_regressor_script.py\n",
    "\n",
    "import argparse\n",
    "import os\n",
    "import shutil\n",
    "import tempfile\n",
    "\n",
    "\n",
    "from azureml.core import Run\n",
    "\n",
    "import mlflow\n",
    "import mlflow.sklearn\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.dummy import DummyRegressor\n",
    "\n",
    "def parse_args():\n",
    "    # setup arg parser\n",
    "    parser = argparse.ArgumentParser()\n",
    "\n",
    "    # add arguments\n",
    "    parser.add_argument(\"--training_data\", type=str, help=\"Path to training data\")\n",
    "    parser.add_argument(\"--target_column_name\", type=str, help=\"Name of target column\")\n",
    "    parser.add_argument(\"--model_output\", type=str, help=\"Path of output model\")\n",
    "\n",
    "    # parse args\n",
    "    args = parser.parse_args()\n",
    "\n",
    "    # return args\n",
    "    return args\n",
    "\n",
    "\n",
    "def main(args):\n",
    "    current_experiment = Run.get_context().experiment\n",
    "    tracking_uri = current_experiment.workspace.get_mlflow_tracking_uri()\n",
    "    print(\"tracking_uri: {0}\".format(tracking_uri))\n",
    "    mlflow.set_tracking_uri(tracking_uri)\n",
    "    mlflow.set_experiment(current_experiment.name)\n",
    "\n",
    "    # Read in data\n",
    "    print(\"Reading data\")\n",
    "    all_data = pd.read_parquet(args.training_data)\n",
    "\n",
    "    print(\"Extracting X_train, y_train\")\n",
    "    print(\"all_data cols: {0}\".format(all_data.columns))\n",
    "    y_train = all_data[args.target_column_name]\n",
    "    X_train = all_data.drop(labels=args.target_column_name, axis=\"columns\")\n",
    "    print(\"X_train cols: {0}\".format(X_train.columns))\n",
    "\n",
    "    print(\"Training model\")\n",
    "    # The estimator can be changed to suit\n",
    "    model = DummyRegressor()\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # Saving model with mlflow - leave this section unchanged\n",
    "    with tempfile.TemporaryDirectory() as td:\n",
    "        print(\"Saving model with MLFlow to temporary directory\")\n",
    "        tmp_output_dir = os.path.join(td, \"my_model_dir\")\n",
    "        mlflow.sklearn.save_model(sk_model=model, path=tmp_output_dir)\n",
    "\n",
    "        print(\"Copying MLFlow model to output path\")\n",
    "        for file_name in os.listdir(tmp_output_dir):\n",
    "            print(\"  Copying: \", file_name)\n",
    "            # As of Python 3.8, copytree will acquire dirs_exist_ok as\n",
    "            # an option, removing the need for listdir\n",
    "            shutil.copy2(src=os.path.join(tmp_output_dir, file_name), dst=os.path.join(args.model_output, file_name))\n",
    "\n",
    "\n",
    "# run script\n",
    "if __name__ == \"__main__\":\n",
    "    # add space in logs\n",
    "    print(\"*\" * 60)\n",
    "    print(\"\\n\\n\")\n",
    "\n",
    "    # parse args\n",
    "    args = parse_args()\n",
    "\n",
    "    # run main function\n",
    "    main(args)\n",
    "\n",
    "    # add space in logs\n",
    "    print(\"*\" * 60)\n",
    "    print(\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584d55f2",
   "metadata": {},
   "source": [
    "Now that the training script is saved on our local drive, we create a YAML file to describe it as a component to AzureML. This involves defining the inputs and outputs, specifing the AzureML environment which can run the script, and telling AzureML how to invoke the training script:spars3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaaec676",
   "metadata": {},
   "outputs": [],
   "source": [
    "from azure.ai.ml import load_component\n",
    "\n",
    "yaml_contents = f\"\"\"\n",
    "$schema: http://azureml/sdk-2-0/CommandComponent.json\n",
    "name: rai_dummy_training_component\n",
    "display_name: Dummy Regressor component for RAI example\n",
    "version: {rai_house_improvement_version_string}\n",
    "type: command\n",
    "inputs:\n",
    "  training_data:\n",
    "    type: mltable\n",
    "  target_column_name:\n",
    "    type: string\n",
    "outputs:\n",
    "  model_output:\n",
    "    type: mlflow_model\n",
    "code: ./component_src/\n",
    "environment: azureml:AML-RAI-Environment:{version_string}\n",
    "\"\"\" + r\"\"\"\n",
    "command: >-\n",
    "  python dummy_regressor_script.py\n",
    "  --training_data ${{{{inputs.training_data}}}}\n",
    "  --target_column_name ${{{{inputs.target_column_name}}}}\n",
    "  --model_output ${{{{outputs.model_output}}}}\n",
    "\"\"\"\n",
    "\n",
    "yaml_filename = \"RAIDummyTrainingComponent.yaml\"\n",
    "\n",
    "with open(yaml_filename, 'w') as f:\n",
    "    f.write(yaml_contents.format(yaml_contents))\n",
    "    \n",
    "train_component_definition = load_component(\n",
    "    source=yaml_filename\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baf9a00e",
   "metadata": {},
   "source": [
    "### Running a training pipeline\n",
    "\n",
    "The component to register the model is part of the suite of RAI components, so we do not have to define it here. As such, we are now ready to run the training pipeline itself.\n",
    "\n",
    "First, we need to make sure we have a compute cluster available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74cbe1ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "from azure.ai.ml.entities import AmlCompute\n",
    "\n",
    "all_compute_names = [x.name for x in ml_client.compute.list()]\n",
    "\n",
    "if compute_name in all_compute_names:\n",
    "    print(f\"Found existing compute: {compute_name}\")\n",
    "else:\n",
    "    my_compute = AmlCompute(\n",
    "        name=compute_name,\n",
    "        size=\"Standard_D2_v2\",\n",
    "        min_instances=0,\n",
    "        max_instances=8,\n",
    "        idle_time_before_scale_down=3600\n",
    "    )\n",
    "    ml_client.compute.begin_create_or_update(my_compute)\n",
    "    print(\"Initiated compute creation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "546750b0",
   "metadata": {},
   "source": [
    "Next, we define the name under which we want to register the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41fcade4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "model_name_suffix = int(time.time())\n",
    "model_name = 'rai_dummy_housing_model'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9383695a",
   "metadata": {},
   "source": [
    "Next, we define the pipeline using objects from the AzureML SDKv2. As mentioned above, there are two component jobs: one to train the model, and one to register it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9500b56",
   "metadata": {},
   "outputs": [],
   "source": [
    "from azure.ai.ml import dsl, Input\n",
    "\n",
    "register_component = ml_client.components.get(\n",
    "    name=\"register_model\", version=version_string\n",
    ")\n",
    "housing_improvement_train_pq = Input(\n",
    "    type=\"uri_file\", path=f\"{input_train_data}:{rai_house_improvement_version_string}\", mode=\"download\"\n",
    ")\n",
    "housing_improvement_test_pq = Input(\n",
    "    type=\"uri_file\", path=f\"{input_test_data}:{rai_house_improvement_version_string}\", mode=\"download\"\n",
    ")\n",
    "\n",
    "@dsl.pipeline(\n",
    "    compute=compute_name,\n",
    "    description=\"Register Model for RAI Housing Improvement example\",\n",
    "    experiment_name=f\"RAI_Housing_Improvement_Example_Model_Training_{model_name_suffix}\",\n",
    ")\n",
    "def my_training_pipeline(target_column_name, training_data):\n",
    "    trained_model = train_component_definition(\n",
    "        target_column_name=target_column_name,\n",
    "        training_data=training_data\n",
    "    )\n",
    "    trained_model.set_limits(timeout=3600)\n",
    "\n",
    "    _ = register_component(\n",
    "        model_input_path=trained_model.outputs.model_output,\n",
    "        model_base_name=model_name,\n",
    "        model_name_suffix=model_name_suffix,\n",
    "    )\n",
    "\n",
    "    return {}\n",
    "\n",
    "model_registration_pipeline_job = my_training_pipeline(target_feature, housing_improvement_train_pq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67f72c24",
   "metadata": {},
   "source": [
    "With the pipeline definition created, we can submit it to AzureML. We define a helper function to do the submission, which waits for the submitted job to complete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31066de2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from azure.ai.ml.entities import PipelineJob\n",
    "\n",
    "def submit_and_wait(ml_client, pipeline_job) -> PipelineJob:\n",
    "    created_job = ml_client.jobs.create_or_update(pipeline_job)\n",
    "    assert created_job is not None\n",
    "\n",
    "    while created_job.status not in ['Completed', 'Failed', 'Canceled', 'NotResponding']:\n",
    "        time.sleep(30)\n",
    "        created_job = ml_client.jobs.get(created_job.name)\n",
    "        print(\"Latest status : {0}\".format(created_job.status))\n",
    "    assert created_job.status == 'Completed'\n",
    "    return created_job\n",
    "\n",
    "# This is the actual submission\n",
    "training_job = submit_and_wait(ml_client, model_registration_pipeline_job)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f85a6f00",
   "metadata": {},
   "source": [
    "##  Creating the RAI Insights\n",
    "\n",
    "We have a registered model, and can now run a pipeline to create the RAI insights. First off, compute the name of the model we registered:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1d9236b",
   "metadata": {},
   "outputs": [],
   "source": [
    "expected_model_id = f'{model_name}_{model_name_suffix}:1'\n",
    "azureml_model_id = f'azureml:{expected_model_id}'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c519de18",
   "metadata": {},
   "source": [
    "Now, we create the RAI pipeline itself. There are four 'component stages' in this pipeline:\n",
    "\n",
    "1. Construct an empty `RAIInsights` object\n",
    "1. Run the RAI tool components\n",
    "1. Gather the tool outputs into a single `RAIInsights` object\n",
    "\n",
    "We start by loading the RAI component definitions for use in our pipeline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbcfd8d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "rai_constructor_component = ml_client.components.get(\n",
    "    name=\"rai_insights_constructor\", version=version_string\n",
    ")\n",
    "\n",
    "rai_causal_component = ml_client.components.get(\n",
    "    name=\"rai_insights_causal\", version=version_string\n",
    ")\n",
    "\n",
    "rai_gather_component = ml_client.components.get(\n",
    "    name=\"rai_insights_gather\", version=version_string\n",
    ")\n",
    "\n",
    "rai_scorecard_component = ml_client.components.get(\n",
    "    name=\"rai_score_card\", version=version_string\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af1dd155",
   "metadata": {},
   "source": [
    "## Score card generation config\n",
    "For score card generation, we need some additional configuration in a separate json file. Here we configure the following model performance metrics for reporting:\n",
    "- mean absolute error\n",
    "- mean squared error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "957ece1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "score_card_config_dict = {\n",
    "    \"Model\": {\n",
    "        \"ModelName\": \"Housing decision\",\n",
    "        \"ModelType\": \"Regression\",\n",
    "        \"ModelSummary\": \"<model summary>\"\n",
    "    },\n",
    "    \"Metrics\": {\"mean_squared_error\": {}, \"mean_absolute_error\": {}},\n",
    "}\n",
    "\n",
    "score_card_config_filename = \"rai_housing_decision_score_card_config.json\"\n",
    "\n",
    "with open(score_card_config_filename, 'w') as f:\n",
    "    json.dump(score_card_config_dict, f)\n",
    "\n",
    "score_card_config_path = Input(\n",
    "    type=\"uri_file\",\n",
    "    path=score_card_config_filename,\n",
    "    mode=\"download\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c9da61d",
   "metadata": {},
   "source": [
    "Now the pipeline itself. This creates an empty `RAIInsights` object, adds the analyses, and then gathers everything into the final `RAIInsights` output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9a0133a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from azure.ai.ml import Input\n",
    "from azure.ai.ml.constants import AssetTypes\n",
    "\n",
    "treatment_feature_names = json.dumps([\"OverallCond\", \"OverallQual\", \"Fireplaces\", \"GarageCars\", \"ScreenPorch\"])\n",
    "\n",
    "@dsl.pipeline(\n",
    "        compute=compute_name,\n",
    "        description=\"Example RAI computation on housing improvement data\",\n",
    "        experiment_name=f\"RAI_Housing_Improvements_Example_RAIInsights_Computation_{model_name_suffix}\",\n",
    "    )\n",
    "def rai_housing_improvement_pipeline(\n",
    "        target_column_name,\n",
    "        train_data,\n",
    "        test_data,\n",
    "        score_card_config_path\n",
    "    ):\n",
    "        # Initiate the RAIInsights\n",
    "        create_rai_job = rai_constructor_component(\n",
    "            title=\"RAI Dashboard Example\",\n",
    "            task_type=\"regression\",\n",
    "            model_info=expected_model_id,\n",
    "            model_input=Input(type=AssetTypes.MLFLOW_MODEL, path=azureml_model_id),\n",
    "            train_dataset=train_data,\n",
    "            test_dataset=test_data,\n",
    "            target_column_name=target_column_name,\n",
    "            categorical_column_names=json.dumps(categorical_features),\n",
    "            use_model_dependency=True,\n",
    "        )\n",
    "        create_rai_job.set_limits(timeout=7200)\n",
    "        \n",
    "        # Add causal analysis\n",
    "        causal_job = rai_causal_component(\n",
    "            rai_insights_dashboard=create_rai_job.outputs.rai_insights_dashboard,\n",
    "            treatment_features=treatment_feature_names,\n",
    "        )\n",
    "        causal_job.set_limits(timeout=7200)\n",
    "        \n",
    "        # Combine everything\n",
    "        rai_gather_job = rai_gather_component(\n",
    "            constructor=create_rai_job.outputs.rai_insights_dashboard,\n",
    "            insight_1=causal_job.outputs.causal,\n",
    "        )\n",
    "        rai_gather_job.set_limits(timeout=7200)\n",
    "\n",
    "        rai_gather_job.outputs.dashboard.mode = \"upload\"\n",
    "        rai_gather_job.outputs.ux_json.mode = \"upload\"\n",
    "\n",
    "        # Generate score card in pdf format for a summary report on model performance,\n",
    "        # and observe distrbution of error between prediction vs ground truth.\n",
    "        rai_scorecard_job = rai_scorecard_component(\n",
    "            dashboard=rai_gather_job.outputs.dashboard,\n",
    "            pdf_generation_config=score_card_config_path\n",
    "        )\n",
    "\n",
    "        return {\n",
    "            \"dashboard\": rai_gather_job.outputs.dashboard,\n",
    "            \"ux_json\": rai_gather_job.outputs.ux_json,\n",
    "            \"scorecard\": rai_scorecard_job.outputs.scorecard\n",
    "        }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24f7c7d2",
   "metadata": {},
   "source": [
    "With all of our jobs defined, we can assemble them into the pipeline itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7a6cfd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "from azure.ai.ml import Output\n",
    "\n",
    "# Pipeline to construct the RAI Insights\n",
    "insights_pipeline_job = rai_housing_improvement_pipeline(\n",
    "    target_column_name=target_feature,\n",
    "    train_data=housing_improvement_train_pq,\n",
    "    test_data=housing_improvement_test_pq,\n",
    "    score_card_config_path=score_card_config_path,\n",
    ")\n",
    "\n",
    "# Workaround to enable the download\n",
    "rand_path = str(uuid.uuid4())\n",
    "insights_pipeline_job.outputs.dashboard = Output(\n",
    "    path=f\"azureml://datastores/workspaceblobstore/paths/{rand_path}/dashboard/\",\n",
    "    mode=\"upload\",\n",
    "    type=\"uri_folder\",\n",
    ")\n",
    "insights_pipeline_job.outputs.ux_json = Output(\n",
    "    path=f\"azureml://datastores/workspaceblobstore/paths/{rand_path}/ux_json/\",\n",
    "    mode=\"upload\",\n",
    "    type=\"uri_folder\",\n",
    ")\n",
    "insights_pipeline_job.outputs.scorecard = Output(\n",
    "    path=f\"azureml://datastores/workspaceblobstore/paths/{rand_path}/scorecard/\",\n",
    "    mode=\"upload\",\n",
    "    type=\"uri_folder\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03b719c9",
   "metadata": {},
   "source": [
    "Now, submit the pipeline job and wait for it to complete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfd6c293",
   "metadata": {},
   "outputs": [],
   "source": [
    "insights_job = submit_and_wait(ml_client, insights_pipeline_job)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a38d11",
   "metadata": {},
   "source": [
    "The dashboard should appear on the Model Details page of the AzureML portal. The following cell computes the appropriate link:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74336c67",
   "metadata": {},
   "outputs": [],
   "source": [
    "sub_id = ml_client._operation_scope.subscription_id\n",
    "rg_name = ml_client._operation_scope.resource_group_name\n",
    "ws_name = ml_client.workspace_name\n",
    "\n",
    "expected_uri = f\"https://ml.azure.com/model/{expected_model_id}/model_analysis?wsid=/subscriptions/{sub_id}/resourcegroups/{rg_name}/workspaces/{ws_name}\"\n",
    "\n",
    "print(f\"Please visit {expected_uri} to see your analysis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "579a4340",
   "metadata": {},
   "source": [
    "## Downloading the Scorecard PDF\n",
    "\n",
    "We can download the scorecard PDF from our pipeline as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e23b669f",
   "metadata": {},
   "outputs": [],
   "source": [
    "target_directory = \".\"\n",
    "\n",
    "ml_client.jobs.download(\n",
    "    insights_job.name, download_path=target_directory, output_name=\"scorecard\"\n",
    ")"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "e3361645",
   "metadata": {},
   "source": [
    "Following the link should bring you to a page which looks similar to:\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bce6bf4",
   "metadata": {},
   "source": [
    "See this [developer blog](http://aka.ms/raidashboardblog) (Decision Making Flow section) to learn more about this use case and how to use the dashboard to identify value-adding home improvements."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.3 64-bit ('anaconda3')",
   "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.7.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "d7b9bea780a7c9857b8563ae025d5b613e23d6656044dfada28bd5ab49fcd8e3"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}