IBM Cloud/Azure/notebooks/ML service/Credit model with Azure Service and scikit-learn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Credit model with Azure Service and scikit-learn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contents\n",
    "\n",
    " 1. Setup\n",
    " 1. Test the sample model locally\n",
    " 1. Register the model to your Azure workspace\n",
    " 1. Deploy the model as Webservice\n",
    " 1. Test the deployed model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** 1. This notebook works correctly with kernel **`IBM Runtime 22.1 on Python 3.9 XS`** if using IBM Watson Studio or else use standard Python 3.9 runtime..\n",
    "          2. Sample model was created using scikit-learn version: `1.2.2`. Model predicts if there is a risk for credit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install required packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install these packages if you are not using IBM Watson Studio\n",
    "#!pip install --upgrade scikit-learn==1.2.2 | tail -n 1\n",
    "#!pip install pandas\n",
    "#!pip install --upgrade azureml-sdk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: PIP_DISABLE_PIP_VERSION_CHECK=1\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%env PIP_DISABLE_PIP_VERSION_CHECK=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install --upgrade azureml-core  | tail -n 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Action: Restart the kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get sample model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2024-07-24 12:03:23--  https://raw.githubusercontent.com/IBM/watson-openscale-samples/main/IBM%20Cloud/Azure/assets/models/credit_risk/german_credit_risk_122.joblib\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 2606:50c0:8003::154, 2606:50c0:8000::154, 2606:50c0:8001::154, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|2606:50c0:8003::154|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 186444 (182K) [application/octet-stream]\n",
      "Saving to: ‘german_credit_risk_122.joblib’\n",
      "\n",
      "german_credit_risk_ 100%[===================>] 182.07K  --.-KB/s    in 0.06s   \n",
      "\n",
      "2024-07-24 12:03:23 (2.86 MB/s) - ‘german_credit_risk_122.joblib’ saved [186444/186444]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!rm -rf german_credit_risk_122.joblib\n",
    "!wget https://raw.githubusercontent.com/IBM/watson-openscale-samples/main/IBM%20Cloud/Azure/assets/models/credit_risk/german_credit_risk_122.joblib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load model from local file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = \"safetodelgerman_credit_risk\"\n",
    "model_path = \"german_credit_risk_122.joblib\" #\"german_credit_risk.joblib\"\n",
    "\n",
    "clf = joblib.load(os.path.join(os.getcwd(), model_path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Test the sample model locally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2024-07-24 12:03:34--  https://raw.githubusercontent.com/IBM/watson-openscale-samples/main/IBM%20Cloud/WML/assets/data/credit_risk/credit_risk_training.csv\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 2606:50c0:8000::154, 2606:50c0:8001::154, 2606:50c0:8002::154, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|2606:50c0:8000::154|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 694222 (678K) [text/plain]\n",
      "Saving to: ‘credit_risk_training.csv’\n",
      "\n",
      "credit_risk_trainin 100%[===================>] 677.95K  --.-KB/s    in 0.1s    \n",
      "\n",
      "2024-07-24 12:03:35 (5.47 MB/s) - ‘credit_risk_training.csv’ saved [694222/694222]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!rm -rf credit_risk_training.csv\n",
    "!wget https://raw.githubusercontent.com/IBM/watson-openscale-samples/main/IBM%20Cloud/WML/assets/data/credit_risk/credit_risk_training.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_df = pd.read_csv(\"credit_risk_training.csv\",dtype={'LoanDuration': int, 'LoanAmount': int, 'InstallmentPercent': int, 'CurrentResidenceDuration': int, \n",
    "                              'Age': int, 'ExistingCreditsCount': int, 'Dependents': int})\n",
    "test_data = data_df\n",
    "test_data = test_data.drop('Risk', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict on test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model accuracy: 0.812\n"
     ]
    }
   ],
   "source": [
    "predictions = clf.predict(test_data)\n",
    "\n",
    "print(\"Model accuracy: {:.3f}\".format(accuracy_score(data_df.Risk, predictions)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Register the model to your Azure workspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from azureml.core import Workspace\n",
    "from azureml.core.model import Model\n",
    "from azureml.core.authentication import InteractiveLoginAuthentication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please provide your Azure ML Service credentials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "az_ml_service_credentials = {'tenant_id': '***',\n",
    "                             'subscription_id': '***', \n",
    "                             'resource_group': '***',\n",
    "                             'workspace_name': '***'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "interactive_auth = InteractiveLoginAuthentication(tenant_id=az_ml_service_credentials['tenant_id'])\n",
    "\n",
    "ws = Workspace(subscription_id=az_ml_service_credentials['subscription_id'], \n",
    "               resource_group=az_ml_service_credentials['resource_group'], \n",
    "               workspace_name=az_ml_service_credentials['workspace_name'], \n",
    "               auth=interactive_auth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "ws.write_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workspace name: bias_dev\n",
      "Azure region: southcentralus\n",
      "Subscription id: 744bca72-2299-451c-b682-ed6fb75fb671\n",
      "Resource group: bias_explainability\n"
     ]
    }
   ],
   "source": [
    "ws = Workspace.from_config()\n",
    "print('Workspace name: ' + ws.name, \n",
    "      'Azure region: ' + ws.location, \n",
    "      'Subscription id: ' + ws.subscription_id, \n",
    "      'Resource group: ' + ws.resource_group, sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scoring endpoint safetodeletegcr\n",
      "scoring endpoint regression-boston\n",
      "scoring endpoint binary-gcr-endpoint\n",
      "scoring endpoint gcr-binary-endpoint\n",
      "scoring endpoint gosales-multiclass-endpoint\n",
      "scoring endpoint insurancefraud-binary\n",
      "scoring endpoint adult-census-copy\n",
      "scoring endpoint walking-activity-multiclass\n",
      "scoring endpoint gcrnewfeb2127-1-gcr-without-scoring\n",
      "scoring endpoint bostonregressio50-1-boston-regression\n",
      "scoring endpoint gosales-final-custom-gosales-multiclass\n",
      "scoring endpoint div-new-1-custom-gcr-final\n"
     ]
    }
   ],
   "source": [
    "from azureml.core.webservice import AciWebservice\n",
    "\n",
    "credit_risk_deployment_name = '***' # use your model deployment name\n",
    "credit_risk_scoring_endpoint = None\n",
    "\n",
    "webservices = AciWebservice.list(ws)\n",
    "for service in webservices:\n",
    "    print('scoring endpoint', service.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering model safetodelgerman_credit_risk\n",
      "Name: safetodelgerman_credit_risk\n",
      "Version: 2\n"
     ]
    }
   ],
   "source": [
    "from azureml.core import Model\n",
    "from azureml.core.resource_configuration import ResourceConfiguration\n",
    "\n",
    "\n",
    "model = Model.register(workspace=ws,\n",
    "                       model_name=model_name,                # Name of the registered model in your workspace.\n",
    "                       model_path=model_path,                # Local file to upload and register as a model.\n",
    "                       model_framework=Model.Framework.SCIKITLEARN,  # Framework used to create the model.\n",
    "                       model_framework_version='1.2.2',             # Version of scikit-learn used to create the model.\n",
    "                       resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5),\n",
    "                       description='credit risk sample scikit model from Watson Studio',\n",
    "                       tags={'area': 'german_credit_risk', 'type': 'classification'})\n",
    "\n",
    "print('Name:', model.name)\n",
    "print('Version:', model.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Deploy the model as Webservice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model deploymen consist of following steps:\n",
    "\n",
    " - Create scoring script\n",
    " - Create environment file\n",
    " - Create configuration file\n",
    " - Deploy model in ACI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create scoring script\n",
    "\n",
    "Scoring script must include two required functions:\n",
    "\n",
    " - The `init()` function, which typically loads the model into a global object. This function is run only once.\n",
    " - The `run(input_data)` function uses the model to predict a value based on the input data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting score_azure.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile score_azure.py\n",
    "import os\n",
    "import json\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import joblib\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from azureml.core.model import Model\n",
    "\n",
    "def init():\n",
    "    global model\n",
    "    model_path = Model.get_model_path('***') # use the model name here\n",
    "    model = joblib.load(model_path)\n",
    "\n",
    "def run(input_data):\n",
    "    try:\n",
    "        if type(input_data) is str:\n",
    "            dict_data = json.loads(input_data)\n",
    "        else:\n",
    "            dict_data = input_data\n",
    "            \n",
    "        data = pd.DataFrame.from_dict(dict_data['input'])   \n",
    "        predictions = model.predict(data)\n",
    "        scores = model.predict_proba(data).tolist()\n",
    "        records = []\n",
    "        \n",
    "        for pred, prob in zip(predictions, scores):\n",
    "            records.append({\"Scored Labels\": pred, \"Scored Probabilities\": prob})\n",
    " \n",
    "        result = {'output': records}\n",
    "        \n",
    "        return json.dumps(result)\n",
    "    except Exception as e:\n",
    "        result = str(e)\n",
    "        # return error message back to the client\n",
    "        return json.dumps({\"error\": result})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create environment file\n",
    "\n",
    "Create an environment file that specifies all of the script's package dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": [
     "set conda dependencies"
    ]
   },
   "outputs": [],
   "source": [
    "from azureml.core.conda_dependencies import CondaDependencies \n",
    "from azureml.core import Environment\n",
    "\n",
    "environment = Environment('my-sklearn-environment')\n",
    "\n",
    "environment.python.conda_dependencies = CondaDependencies.create(pip_packages=[\n",
    "    'azureml-defaults',\n",
    "    'joblib',\n",
    "    'numpy',\n",
    "    'pandas',\n",
    "    'scikit-learn==1.2.2'\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create configuration file\n",
    "\n",
    "Create a deployment configuration file and specify the number of CPUs and gigabyte of RAM needed for your ACI container."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "configure web service",
     "aci"
    ]
   },
   "outputs": [],
   "source": [
    "from azureml.core.webservice import AciWebservice\n",
    "\n",
    "\n",
    "aci_config = AciWebservice.deploy_configuration(cpu_cores=0.5, memory_gb=0.5\n",
    "                                                ,tags={\"data\": \"german_credit_risk\",  \"method\" : \"sklearn\"}, \n",
    "                                               description='Predict Credit Risk with sklearn from Watson Studio')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deploy in ACI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configure the image and deploy it with following steps:\n",
    "\n",
    " - Build an image\n",
    " - Register that image under the workspace\n",
    " - Send the image to the ACI container\n",
    " - Start up a container in ACI using the image\n",
    " - Get the web service HTTP endpoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Estimated time to complete: **about 7-8 minutes**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running\n",
      "2024-07-24 06:31:53+00:00 Check and wait for operation (6ba436c0-6d81-48f6-b493-7d17242eb2c0) to finish.\n",
      "2024-07-24 06:31:56+00:00 Deleting service entity.\n",
      "Succeeded\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from azureml.core.webservice import Webservice\n",
    "from azureml.exceptions import WebserviceException\n",
    "from azureml.core.model import InferenceConfig\n",
    "from azureml.core.image import ContainerImage\n",
    "\n",
    "\n",
    "service_name = '***' # deployment service name\n",
    "\n",
    "# Remove any existing service under the same name.\n",
    "try:\n",
    "    Webservice(ws, service_name).delete()\n",
    "except WebserviceException:\n",
    "    pass\n",
    "\n",
    "inference_config = InferenceConfig(entry_script='score_azure.py', environment=environment)\n",
    "\n",
    "service = Model.deploy(workspace=ws,\n",
    "                       name=service_name,\n",
    "                       models=[model],\n",
    "                       inference_config=inference_config,\n",
    "                       deployment_config=aci_config,\n",
    "                       overwrite=True)\n",
    "service.wait_for_deployment(show_output=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scoring endpoint http://48bbe5ba-fad3-4ea9-a044-1ab2d382234f.southcentralus.azurecontainer.io/score\n"
     ]
    }
   ],
   "source": [
    "from azureml.core.webservice import AciWebservice\n",
    "\n",
    "credit_risk_deployment_name = service_name\n",
    "credit_risk_scoring_endpoint = None\n",
    "\n",
    "webservices = AciWebservice.list(ws)\n",
    "for service in webservices:\n",
    "    if service.name == credit_risk_deployment_name:\n",
    "        credit_risk_scoring_endpoint = service.scoring_uri\n",
    "        \n",
    "print('scoring endpoint', credit_risk_scoring_endpoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Test deployed model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare scoring payload"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_data = {\"input\":[\n",
    "                {\n",
    "                \"CheckingStatus\": \"0_to_200\", \"LoanDuration\": 31, \"CreditHistory\": \"credits_paid_to_date\", \"LoanPurpose\": \"other\",\n",
    "                \"LoanAmount\": 1889, \"ExistingSavings\": \"100_to_500\", \"EmploymentDuration\": \"less_1\", \"InstallmentPercent\": 3, \"Sex\": \"female\",\n",
    "                \"OthersOnLoan\": \"none\", \"CurrentResidenceDuration\": 3, \"OwnsProperty\": \"savings_insurance\", \"Age\": 32, \"InstallmentPlans\": \"none\",\n",
    "                \"Housing\": \"own\", \"ExistingCreditsCount\": 1, \"Job\": \"skilled\", \"Dependents\": 1, \"Telephone\": \"none\", \"ForeignWorker\": \"yes\",\n",
    "                },\n",
    "                {\n",
    "                \"CheckingStatus\": \"no_checking\", \"LoanDuration\": 13, \"CreditHistory\": \"credits_paid_to_date\", \"LoanPurpose\": \"car_new\",\n",
    "                \"LoanAmount\": 1389, \"ExistingSavings\": \"100_to_500\", \"EmploymentDuration\": \"1_to_4\", \"InstallmentPercent\": 2, \"Sex\": \"male\",\n",
    "                \"OthersOnLoan\": \"none\", \"CurrentResidenceDuration\": 3, \"OwnsProperty\": \"savings_insurance\", \"Age\": 25, \"InstallmentPlans\": \"none\",\n",
    "                \"Housing\": \"own\", \"ExistingCreditsCount\": 2, \"Job\": \"skilled\", \"Dependents\": 2, \"Telephone\": \"none\", \"ForeignWorker\": \"yes\",\n",
    "                }]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Send scoring request using an HTTP request"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'output': [{'Scored Labels': 'No Risk', 'Scored Probabilities': [0.8922524675865824, 0.10774753241341757]}, {'Scored Labels': 'No Risk', 'Scored Probabilities': [0.8335192848546905, 0.1664807151453095]}]}"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "headers = {\"Content-Type\": \"application/json\"}\n",
    "resp = requests.post(credit_risk_scoring_endpoint, json=scoring_data, headers=headers)\n",
    "resp.json()"
   ]
  }
 ],
 "metadata": {
  "authors": [
   {
    "name": "roastala"
   }
  ],
  "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.10.14"
  },
  "msauthor": "sgilley",
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}