Custom_MLFlow_Models/use_custom_model.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# What happens when not using an MLflow format model with MLflow"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_input = {\"inputs\": \n",
        "[[0.0126481372762872, 0.0506801187398187, 0.00241654245523897, 0.0563010619323185, 0.0273260502020124, \n",
        "0.0171618818193638, 0.0412768238419757, -0.0394933828740919, 0.00371173823343597, 0.0734802269665584], \n",
        "[-0.107225631607358, -0.044641636506989, -0.0773415510119477, -0.0263278347173518, -0.0896299427450836, \n",
        "-0.0961978613484469, 0.0265502726256275, -0.076394503750001, -0.0425721049227942, -0.0052198044153011], \n",
        "[0.0271782910803654, 0.0506801187398187, -0.0353068801305926, 0.0322009670761646, -0.0112006298276192, \n",
        "0.00150445872988718, -0.0102661054152432, -0.00259226199818282, -0.0149564750249113, -0.0507829804784829], \n",
        "[-0.00551455497881059, 0.0506801187398187, 0.00133873038135806, -0.0848566365108683, -0.0112006298276192, \n",
        "-0.0166581520539057, 0.0486400994501499, -0.0394933828740919, -0.0411803851880079, -0.0880619427119953], \n",
        "[0.0671362140415805, 0.0506801187398187, 0.0207393477112143, -0.00567061055493425, 0.0204462859110067, \n",
        "0.0262431872112602, -0.0029028298070691, -0.00259226199818282, 0.00864028293306308, 0.00306440941436832]]\n",
        "}\n",
        "\n",
        "import mlflow\n",
        "model = mlflow.pyfunc.load_model(\"model.pkl\")\n",
        "model.predict(model_input)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1648762513916
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### OOoo, this is not working, it is not an MLFlow model... Let me make it one."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Utilizing MLflow and AML for any model"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "AzureML now support only 3 types of models [Custom, MLflow and Trition]\r\n",
        "\r\n",
        "In the situtaion you want to utilize the benefits of an MLflow model such as:\r\n",
        "-  No code deployment\r\n",
        "- ??\r\n",
        "- ??\r\n",
        "\r\n",
        "However, you didn't train your model with the MLflow APIs or you are using a ML framework not support by MLFlow, you you will need to convert your custom model to MLFLow conform to the MLFlow format."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Changing a model to MLFLow flow"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "MLflow provides convenient functions for creating models with the pyfunc flavor in a variety of machine learning frameworks (scikit-learn, Keras, Pytorch, and more); however, they do not cover every use case. For example, you may want to create an MLflow model with the pyfunc flavor using a framework that MLflow does not natively support or you may want to change a pre-trained model trainined out of MLFlow into an MLFlow formated model\r\n",
        "\r\n",
        "MLflow recommeneds the following [process](https://mlflow.org/docs/latest/python_api/mlflow.pyfunc.html#creating-custom-pyfunc-models) to change your model:\r\n",
        "\r\n",
        "1) Create a Python Wrapper for your model.\r\n",
        "\r\n",
        "2) Specify the Conda environment for your model.\r\n",
        "\r\n",
        "3) Use the save_model() and log_model() methods for creating custom pyfunc models that incorporate custom inference logic and artifacts that the logic may require."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Registering a supported custom machine learning model in MLFlow Format\r\n",
        "If you didn't train your model with MLFlow and will want to use our MLFlow NCD offering you will need to convert you custom model to MLFLow,\r\n",
        "Even more info??: https://mlflow.org/docs/latest/models.html#custom-python-models"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Create a Python Wrapper"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load training and test datasets\n",
        "from sys import version_info\n",
        "import sklearn\n",
        "from sklearn import datasets\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "PYTHON_VERSION = \"{major}.{minor}.{micro}\".format(major=version_info.major,\n",
        "                                                  minor=version_info.minor,\n",
        "                                                  micro=version_info.micro)\n",
        "\n",
        "# Train and save an SKLearn model\n",
        "sklearn_model_path = \"model.pkl\"\n",
        "\n",
        "# Create an `artifacts` dictionary that assigns a unique name to the saved XGBoost model file.\n",
        "# This dictionary will be passed to `mlflow.pyfunc.save_model`, which will copy the model file\n",
        "# into the new MLflow Model's directory.\n",
        "artifacts = {\n",
        "    \"sklearn_model\": sklearn_model_path\n",
        "}\n",
        "\n",
        "import mlflow.pyfunc\n",
        "from sklearn.metrics import mean_squared_error\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "class SKLearnWrapper(mlflow.pyfunc.PythonModel):\n",
        "\n",
        "    def load_context(self, context):\n",
        "        import pickle\n",
        "        self.sklearn_model = pickle.load(open(context.artifacts[\"sklearn_model\"], 'rb'))\n",
        "    \n",
        "    def predict(self, model, data):\n",
        "        return self.sklearn_model.predict(data)"
      ],
      "outputs": [],
      "execution_count": 26,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1648771010573
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Create a Conda environment for the new MLflow Model that contains all necessary dependencies."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cloudpickle\n",
        "conda_env = {\n",
        "    'channels': ['defaults'],\n",
        "    'dependencies': [\n",
        "      'python={}'.format(PYTHON_VERSION),\n",
        "      'pip',\n",
        "      {\n",
        "        'pip': [\n",
        "          'mlflow',\n",
        "          'scikit-learn=={}'.format(sklearn.__version__),\n",
        "          'cloudpickle=={}'.format(cloudpickle.__version__),\n",
        "        ],\n",
        "      },\n",
        "    ],\n",
        "    'name': 'sklearn_env'\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Save the MLflow Model to disk"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mlflow_pyfunc_model_path = \"sklearn_mlflow_pyfunc7\"\n",
        "mlflow.pyfunc.save_model(path=mlflow_pyfunc_model_path, python_model=SKLearnWrapper(), conda_env=conda_env, artifacts=artifacts)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load the MLFlow formated model and test predictions"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model = mlflow.pyfunc.load_model(mlflow_pyfunc_model_path)\n",
        "\n",
        "# Evaluate the model\n",
        "import pandas as pd\n",
        "test_predictions = loaded_model.predict(model_input)\n",
        "print(test_predictions)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Compare to your non MLFlow formated model\r\n",
        "It should be the same prediction"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# load the model from disk\r\n",
        "import pickle\r\n",
        "loaded_model = pickle.load(open(sklearn_model_path, 'rb'))\r\n",
        "result = loaded_model.predict(model_input)\r\n",
        "print(result)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "[4634.10508517]\n"
        }
      ],
      "execution_count": 28,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "gather": {
          "logged": 1648771031230
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Register the model\r\n",
        "Start dummy run, model to run and save to registry"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# mlflow.pyfunc.log_model(artifact_path=mlflow_pyfunc_model_path, loader_module=None, data_path=None, code_path=None,\n",
        "#                              python_model=SKLearnWrapper(),\n",
        "#                              registered_model_name=\"Custom_mlflow_model\", conda_env=conda_env, artifacts=artifacts)\n",
        "# mlflow.end_run()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Registering an unsupported machine learning model in MLFlow Format\r\n",
        "\r\n",
        "In some cases, you might use a machine learning framework without its built-in MLflow Model flavor support (Support frameworks). For instance, the vaderSentiment library is a standard Natural Language Processing (NLP) library used for sentiment analysis. Since it lacks a built-in MLflow Model flavor, you cannot log or register the model using MLflow Model fluent APIs.\r\n",
        "\r\n",
        "More info on code: https://mlflow.org/docs/latest/model-registry.html#registering-an-unsupported-machine-learning-model\r\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3-azureml",
      "language": "python",
      "display_name": "Python 3.6 - AzureML"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.9",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernel_info": {
      "name": "python3-azureml"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}