cpd5.1/notebooks/python_sdk/experiments/deep_learning/Use PyTorch to recognize hand-written digits.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Use PyTorch to recognize hand-written digits with `ibm-watsonx-ai`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This notebook contains steps and code to demonstrate support of Deep Learning model training and scoring in Watson Machine Learning service. It introduces commands for getting data, training_definition persistance to Watson Machine Learning repository, model training, model persistance, model deployment and scoring.\n",
        "\n",
        "Some familiarity with Python is helpful. This notebook uses Python 3.11.\n",
        "\n",
        "\n",
        "## Learning goals\n",
        "\n",
        "The learning goals of this notebook are:\n",
        "\n",
        "-  Working with Watson Machine Learning service.\n",
        "-  Training Deep Learning models (TensorFlow).\n",
        "-  Saving trained models in Watson Machine Learning repository.\n",
        "-  Online deployment and scoring of trained model.\n",
        "\n",
        "\n",
        "## Contents\n",
        "\n",
        "This notebook contains the following parts:\n",
        "\n",
        "1. [Setup](#setup)\n",
        "2. [Create model definition](#model_def)\n",
        "3. [Train model](#training)\n",
        "4. [Persist trained model](#persist)\n",
        "5. [Deploy and Score](#deploy)\n",
        "6. [Clean up](#clean)\n",
        "7. [Summary and next steps](#summary)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"setup\"></a>\n",
        "## 1. Set up the environment\n",
        "\n",
        "Before you use the sample code in this notebook, you must perform the following setup tasks:\n",
        "\n",
        "-  Contact with your Cloud Pack for Data administrator and ask him for your account credentials"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Install and import the `ibm-watsonx-ai` and dependecies\n",
        "**Note:** `ibm-watsonx-ai` documentation can be found <a href=\"https://ibm.github.io/watsonx-ai-python-sdk/index.html\" target=\"_blank\" rel=\"noopener no referrer\">here</a>."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "!pip install wget | tail -n 1\n",
        "!pip install -U ibm-watsonx-ai | tail -n 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Connection to WML\n",
        "\n",
        "Authenticate the Watson Machine Learning service on IBM Cloud Pack for Data. You need to provide platform `url`, your `username` and `api_key`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "username = 'PASTE YOUR USERNAME HERE'\n",
        "api_key = 'PASTE YOUR API_KEY HERE'\n",
        "url = 'PASTE THE PLATFORM URL HERE'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from ibm_watsonx_ai import Credentials\n",
        "\n",
        "credentials = Credentials(\n",
        "    username=username,\n",
        "    api_key=api_key,\n",
        "    url=url,\n",
        "    instance_id=\"openshift\",\n",
        "    version=\"5.1\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Alternatively you can use `username` and `password` to authenticate WML services.\n",
        "\n",
        "```python\n",
        "credentials = Credentials(\n",
        "    username=***,\n",
        "    password=***,\n",
        "    url=***,\n",
        "    instance_id=\"openshift\",\n",
        "    version=\"5.1\"\n",
        ")\n",
        "\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "from ibm_watsonx_ai import APIClient\n",
        "\n",
        "client = APIClient(credentials)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Working with spaces\n",
        "\n",
        "First of all, you need to create a space that will be used for your work. If you do not have space already created, you can use `{PLATFORM_URL}/ml-runtime/spaces?context=icp4data` to create one.\n",
        "\n",
        "- Click New Deployment Space\n",
        "- Create an empty space\n",
        "- Go to space `Settings` tab\n",
        "- Copy `space_id` and paste it below\n",
        "\n",
        "**Tip**: You can also use SDK to prepare the space for your work. More information can be found [here](https://github.com/IBM/watson-machine-learning-samples/blob/master/cpd5.1/notebooks/python_sdk/instance-management/Space%20management.ipynb).\n",
        "\n",
        "**Action**: Assign space ID below"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "space_id = 'PASTE YOUR SPACE ID HERE'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can use `list` method to print all existing spaces."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "client.spaces.list(limit=10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To be able to interact with all resources available in Watson Machine Learning, you need to set **space** which you will be using."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'SUCCESS'"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "client.set.default_space(space_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"model_def\"></a>\n",
        "# 2. Create model definition"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.1 Prepare model definition metadata"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "model_definition_metadata = {\n",
        "    client.model_definitions.ConfigurationMetaNames.NAME: \"PyTorch Hand-written Digit Recognition\",\n",
        "    client.model_definitions.ConfigurationMetaNames.DESCRIPTION: \"PyTorch Hand-written Digit Recognition\",\n",
        "    client.model_definitions.ConfigurationMetaNames.COMMAND:  \"torch_mnist.py --epochs 1\",\n",
        "    client.model_definitions.ConfigurationMetaNames.PLATFORM: {\"name\": \"python\", \"versions\": [\"3.11\"]},\n",
        "    client.model_definitions.ConfigurationMetaNames.VERSION: \"2.0\",\n",
        "    client.model_definitions.ConfigurationMetaNames.SPACE_UID: space_id\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.2  Get sample model definition content file from git"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import wget, os\n",
        "\n",
        "filename='pytorch-model.zip'\n",
        "\n",
        "if not os.path.isfile(filename):\n",
        "    filename = wget.download('https://github.com/IBM/watson-machine-learning-samples/raw/master/cpd5.1/definitions/pytorch/mnist/pytorch-model.zip')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Tip**: Convert below cell to code and run it to see model deinition's code."
      ]
    },
    {
      "cell_type": "raw",
      "metadata": {},
      "source": [
        "!unzip -oqd . pytorch-model.zip && cat torch_mnist.py"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.3  Publish model definition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "definition_details = client.model_definitions.store(filename, model_definition_metadata)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "e3ec6abc-eadb-44b0-8251-86f2c0929b4f\n"
          ]
        }
      ],
      "source": [
        "model_definition_id = client.model_definitions.get_id(definition_details)\n",
        "print(model_definition_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### List models definitions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "client.model_definitions.list(limit=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"training\"></a>\n",
        "# 3. Train model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### **Warning**: Before executing deep learning experiment make sure that [training data](https://github.com/IBM/watson-machine-learning-samples/tree/master/cpd5.1/data/mnist/raw) is saved in a folder where Watson Machine Learning Accelerator is installed."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.1 Prepare training metadata"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [],
      "source": [
        "training_metadata = training_metadata = {\n",
        "   client.training.ConfigurationMetaNames.NAME: \"PyTorch hand-written Digit Recognition\",\n",
        "   client.training.ConfigurationMetaNames.DESCRIPTION: \"PyTorch hand-written Digit Recognition\",\n",
        "   client.training.ConfigurationMetaNames.TRAINING_RESULTS_REFERENCE:  {\n",
        "      \"name\":\"MNIST results\",\n",
        "      \"connection\":{\n",
        "         \n",
        "      },\n",
        "      \"location\":{\n",
        "         \"path\":f\"spaces/{space_id}/assets/experiment\"\n",
        "      },\n",
        "      \"type\":\"fs\"\n",
        "   },\n",
        "  client.training.ConfigurationMetaNames.MODEL_DEFINITION:{\n",
        "        \"id\": model_definition_id,\n",
        "        \"hardware_spec\": {\n",
        "          \"name\": \"K80\",\n",
        "          \"nodes\": 1\n",
        "        },\n",
        "        \"software_spec\": {\n",
        "          \"name\": \"pytorch-onnx_rt24.1-py3.11\"\n",
        "        }\n",
        "  },\n",
        "  client.training.ConfigurationMetaNames.TRAINING_DATA_REFERENCES: [\n",
        "      {\n",
        "         \"name\":\"training_input_data\",\n",
        "         \"type\":\"fs\",\n",
        "         \"connection\":{\n",
        "            \n",
        "         },\n",
        "         \"location\":{\n",
        "            \"path\": \"pytorch-mnist\"\n",
        "         },\n",
        "         \"schema\":{\n",
        "            \"id\":\"idmlp_schema\",\n",
        "            \"fields\":[\n",
        "               {\n",
        "                  \"name\":\"text\",\n",
        "                  \"type\":\"string\"\n",
        "               }\n",
        "            ]\n",
        "         }\n",
        "      }\n",
        "   ]\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.2 Train the model in the background"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [],
      "source": [
        "training = client.training.run(training_metadata)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.3 Get training id and status"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "037d3be7-439e-4c10-98f4-45dcfa3a4943\n"
          ]
        }
      ],
      "source": [
        "training_id = client.training.get_id(training)\n",
        "print(training_id)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "client.training.get_status(training_id)['state']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.4 Get training details"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import json\n",
        "\n",
        "training_details = client.training.get_details(training_id)\n",
        "print(json.dumps(training_details, indent=2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### List trainings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "client.training.list(limit=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Cancel training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can cancel the training run by calling the method below.  \n",
        "**Tip**: If you want to  delete train runs and results add `hard_delete=True` as a parameter."
      ]
    },
    {
      "cell_type": "raw",
      "metadata": {},
      "source": [
        "client.training.cancel(training_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"persist\"></a>\n",
        "# 4. Persist trained model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4.1 Publish model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [],
      "source": [
        "software_spec_id = client.software_specifications.get_id_by_name('pytorch-onnx_rt24.1-py3.11')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {},
      "outputs": [],
      "source": [
        "model_meta_props = {client.repository.ModelMetaNames.NAME: \"PyTorch Mnist Model\",\n",
        "                    client.repository.ModelMetaNames.TYPE: \"pytorch-onnx_2.1\",\n",
        "                    client.repository.ModelMetaNames.SOFTWARE_SPEC_ID: software_spec_id\n",
        "                    }\n",
        "\n",
        "published_model_details = client.repository.store_model(training_id, meta_props=model_meta_props)\n",
        "model_id = client.repository.get_model_id(published_model_details)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4.2 Get model details"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "model_details = client.repository.get_details(model_id)\n",
        "print(json.dumps(model_details, indent=2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### List stored models"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "client.repository.list_models(limit=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"deploy\"></a>\n",
        "# 5. Deploy and score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.1 Crate online deployment for published model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can deploy the stored model as a web service (online) by running code in the following cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "#######################################################################################\n",
            "\n",
            "Synchronous deployment creation for uid: '11ac2c0e-34b1-4c34-a60b-1c0c638f9832' started\n",
            "\n",
            "#######################################################################################\n",
            "\n",
            "\n",
            "initializingNote: online_url is deprecated and will be removed in a future release. Use serving_urls instead.\n",
            "\n",
            "Note: online_url is deprecated and will be removed in a future release. Use serving_urls instead.\n",
            "\n",
            "ready\n",
            "\n",
            "\n",
            "------------------------------------------------------------------------------------------------\n",
            "Successfully finished deployment creation, deployment_uid='4f09e2de-6330-486d-b774-b2fe78ea9432'\n",
            "------------------------------------------------------------------------------------------------\n",
            "\n",
            "\n"
          ]
        }
      ],
      "source": [
        "deployment = client.deployments.create(\n",
        "    model_id, meta_props={\n",
        "        client.deployments.ConfigurationMetaNames.NAME:\"PyCharm Mnist deployment\",\n",
        "        client.deployments.ConfigurationMetaNames.ONLINE:{}\n",
        "        }\n",
        "    )\n",
        "\n",
        "scoring_url = client.deployments.get_scoring_href(deployment)\n",
        "deployment_id = client.deployments.get_id(deployment)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.2 Get deployments details"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "deployments_details = client.deployments.get_details(deployment_id)\n",
        "print(json.dumps(deployments_details, indent=2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.3 Score deployed model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Prepare sample scoring data to score deployed model.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import wget\n",
        "\n",
        "dataset_filename='mnist.npz'\n",
        "\n",
        "if not os.path.isfile(dataset_filename):\n",
        "    dataset_filename = wget.download('https://github.com/IBM/watson-machine-learning-samples/raw/master/cpd5.1/data/mnist/mnist.npz')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {},
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "dataset_filename='mnist.npz'\n",
        "mnist_dataset = np.load(dataset_filename)\n",
        "x_test = mnist_dataset['x_test']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {},
      "outputs": [],
      "source": [
        "image_1 = [x_test[0].tolist()]\n",
        "image_2 = [x_test[1].tolist()]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {},
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAScAAABxCAYAAACX+mUfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAHF0lEQVR4nO3dzUsWXxTA8bF+kZRlSWEGJZFgSZkLIYzA3hYWFZX0AhEtXNWiRYsW0qYXejVaVKv6A4SKSqQXSAiSiAyiAgUXlUFEkUm0kKzot/jB4Z75NY+PjzPjuc/z/azO4Q4zdzEc7ty5c6foz58/AQBYM2miOwAAf0NxAmASxQmASRQnACZRnACYRHECYNI/o7SzzsCOoonuQJ7h3rbjr/c2IycAJlGcAJhEcQJgEsUJgEkUJwAmUZwAmERxAmASxQmASRQnACZRnACYNNrnKwAS1tbWpvLh4WGJX716pdpu3LgReZ4DBw6ovKGhQeJ9+/aNp4sTgpETAJMoTgBMKhrlBwd8uW0HuxLEa0Lv7d27d0t8/fr1RK5RVVUl8cOHD1XbwoULE7lmjtiVAIA/KE4ATKI4ATCJOSd/MOcUr1TvbXeOKQiyn2dasmSJypuamiR+8+aNauvo6Ig8z8mTJ1Xe2tqa1fVTwpwTAH9QnACYxApxICHPnz+X+NatW5HHLVu2TOXu49mcOXNUW0lJicQjIyOqbeXKlSp/+fKlxIODg1n02BZGTgBMojgBMIniBMCk1Oecwl9VX716VeL58+ertuLiYon37t2r2ubNmyexu0wfsOLjx48Sh5fsuPNMDx48UG0VFRVZnT+8m0FfX1/ksZs3b87qnJYwcgJgEsUJgEmprxBftGiRyt+9e5fTeWbOnClxTU3NeLqUkwULFkh85MgR1VZfX5/EJVkhHq9UV4gPDAyofMaMGRKXlZXldM4VK1ao/PXr15HHdnV1qXzt2rU5XTMhrBAH4A+KEwCTKE4ATEp9KcG1a9dU7i6xD88d9fb2SvzixQvV9ujRI4mfPn2q2txd/t6/f59136ZMmaJy99MB97Vw+Jru/FMQJDbnBI9VVlbGcp7z589L3N/fn/FY93OW8KctPmDkBMAkihMAk7zdbG5oaEji8COf+1jV09OT9TmnTp2q8urqaonDm359/fpV4itXrqi2gwcPZn3NMWApQbzM3tuuzs5Ole/cuVPiHz9+qLby8nKVt7e3S9zY2JhA72LDUgIA/qA4ATCJ4gTAJG93wpw9e7bE69atizxu/fr1OV/j5s2bErtzXEEQBLW1tRLv2bMn52sAmbi7aQbB/+eZXOGfKBifZxoVIycAJlGcAJjk7VKCJHz+/Fnly5cvj2xzN81rbm5OtmP/YSlBvMze29u2bZM4vBGd+1i3f/9+1Xbp0iWVuz9DMI6lBAD8QXECYBLFCYBJ3i4lSEL4MxR3nmnWrFmqzf20BRiP8I4XT548kTi8dGDu3LkSHz16VLV5NMeUFUZOAEyiOAEwqeAf67q7uyU+c+ZM5HF37txRefj/9kCuduzYofIvX75EHuv+v3Hx4sWJ9ckCRk4ATKI4ATCJ4gTApIKfc7p7967EIyMjqm3Dhg0SNzQ0pNYn5L+Ojg6Jwzu5utasWaPy48ePJ9Ulcxg5ATCJ4gTAJIoTAJMKbs5peHhY5ffv35c4/PeVY8eOSRz+4SYwFoODgyo/deqUxOG5TlddXZ3K8+0TlUwYOQEwieIEwKSCe6xz/zUfBPo17saNG1XbqlWrUukT8t+FCxdU/uzZs8hj3Z0wC2npQBgjJwAmUZwAmERxAmBS3v99pbOzU+Xbt29X+fTp0yW+d++eajP2yQp/X4lXqvd2cXGxyjMtH/jw4YPEFRUVifXJEP6+AsAfFCcAJuXlUgJ3Ne6hQ4dU269fv1S+adMmiY09xqFAuffveL5MKC0tjTzPz58/Jf727VvkOYaGhlR+8eLFrK49efJklZ89e1biadOmZXUORk4ATKI4ATCJ4gTApLyYc/r9+7fKm5qaJH779q1qq6qqUvmJEyeS6xiQg9ra2ljOs2vXLonDSxI+ffokcXt7eyzXy6S8vFzi8M9AozByAmASxQmASXmxQry/v1/l1dXVkce6G8sHQRBs2bIlkT4lgBXi8Ur13g7/OPP27dtpXn5M3GUHkyZFj1+2bt2q8vr6+shjV69eLfFfluywQhyAPyhOAEyiOAEwyds5p4GBAYkbGxsj29ra2lTb4cOHVV5U5M1Ujjcd9cSE3tvnzp2TONMOBWG9vb0Sj2UJQEtLi8orKysjj21ubpZ46dKlWV9jHJhzAuAPihMAk7x9rGttbZX49OnTkcf19PSoPNPrTuN4rIuX2Xu7APFYB8AfFCcAJlGcAJjkza4Ejx8/Vvnly5cnqCcA0sDICYBJFCcAJnnzWNfd3a3y79+/Rx7rbihXUlKSWJ8AJIeREwCTKE4ATKI4ATDJmzmnTOrq6lTe1dUlcVlZWcq9ARAHRk4ATKI4ATDJ210JChC7EsSLe9sOdiUA4A+KEwCTKE4ATBptKQHzHMhX3NvGMXICYBLFCYBJFCcAJlGcAJhEcQJgEsUJgEn/ArNniifI0zmXAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "for i, image in enumerate([x_test[0], x_test[1]]):\n",
        "    plt.subplot(2, 2, i + 1)\n",
        "    plt.axis('off')\n",
        "    plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Build scoring dictionary consisting of two digits and send it to deployed model to get predictions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Scoring result:\n",
            "{\n",
            "  \"predictions\": [\n",
            "    {\n",
            "      \"values\": [\n",
            "        [\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          1.0,\n",
            "          0.0,\n",
            "          0.0\n",
            "        ],\n",
            "        [\n",
            "          0.0,\n",
            "          0.0,\n",
            "          1.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0,\n",
            "          0.0\n",
            "        ]\n",
            "      ]\n",
            "    }\n",
            "  ]\n",
            "}\n"
          ]
        }
      ],
      "source": [
        "scoring_payload = {\n",
        "    client.deployments.ScoringMetaNames.INPUT_DATA : [\n",
        "        {'values': [image_1, image_2]}\n",
        "    ]\n",
        "}\n",
        "scores = client.deployments.score(deployment_id, meta_props=scoring_payload)\n",
        "print(\"Scoring result:\\n\" + json.dumps(scores, indent=2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### List deployments"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "client.deployments.list(limit=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"clean\"></a>\n",
        "# 6. Clean up"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you want to clean up all created assets:\n",
        "- experiments\n",
        "- trainings\n",
        "- pipelines\n",
        "- model definitions\n",
        "- models\n",
        "- functions\n",
        "- deployments\n",
        "\n",
        "please follow up this sample [notebook](https://github.com/IBM/watson-machine-learning-samples/blob/master/cpd5.1/notebooks/python_sdk/instance-management/Machine%20Learning%20artifacts%20management.ipynb)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<a id=\"summary\"></a>\n",
        "# 7. Summary and next steps     "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You successfully completed this notebook! You learned how to use `ibm-watsonx-ai` to train and score PyTorch models. \n",
        "\n",
        "Check out our _<a href=\"https://ibm.github.io/watsonx-ai-python-sdk/samples.html\" target=\"_blank\" rel=\"noopener no referrer\">Online Documentation</a>_ for more samples, tutorials, documentation, how-tos, and blog posts. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Author\n",
        "\n",
        "**Jan Sołtysik**, Intern in Watson Machine Learning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Copyright © 2020-2025 IBM. This notebook and its source code are released under the terms of the MIT License."
      ]
    }
  ],
  "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": 4
}