.colab/create_a_simple_pipeline/create_a_simple_pipeline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://bit.ly/3SJewuO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Pipeline with LineaPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of Contents**\n",
    "\n",
    "- [Intro](#Intro)\n",
    "- [Demo](#Demo)\n",
    "    - [Exploration and Pre-processing](#Exploration-and-Pre-processing)\n",
    "    - [Modeling](#Modeling)\n",
    "    - [Pipeline Building](#Pipeline-Building)\n",
    "- [Orchestration Frameworks Supported](#Orchestration-Frameworks-Supported)\n",
    "    - [Airflow](#Airflow)\n",
    "    - [Argo](#Argo)\n",
    "    - [Kubeflow](#Kubeflow)\n",
    "    - [Ray](#Ray)\n",
    "    - [DVC](#DVC)\n",
    "- [Recap](#Recap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scenario\n",
    "\n",
    "As notebooks become more mature, they may get used like pipelines. For instance, notebooks that do the following things:\n",
    "\n",
    "* Process latest data and update dashboards/graphs/charts/reports\n",
    "* Preprocess new data and dump it to the filesystem or database for downstream model development\n",
    "* Create updated versions of models using latest data\n",
    "* Run inference on new data using standard model\n",
    "\n",
    "may be expected to be re-executed as a pipeline on a regular or ad-hoc basis.\n",
    "\n",
    "However, you may not have the proper engineering support to set up these pipelines for production."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What might happen next?\n",
    "\n",
    "If this is the case, any of the following may happen:\n",
    "\n",
    "* You spend a lot of time copying and pasting and cleaning your code to make your pipeline work in orchestration systems or job schedulers (cron, Apache Airflow, Argo, Kubeflow, DVC, Ray, etc).\n",
    "* It takes forever to make your pipeline work and you end up running your pipelines manually whenever you need to or get asked to.\n",
    "* Your runtime environment is changed due to other experiments you are running and your pipeline is no longer working.\n",
    "* You make some changes to your pipeline and now you find out you need to restart the above processes again.\n",
    "\n",
    "As more notebooks and pipelines need to be maintained, data scientists will need to spend more time on the operation side to make sure every notebook is running at the right time successfully. \n",
    "This operational burden will consume a lot of time from the data scientist, which decreases productivity and innovation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How can LineaPy help here?\n",
    "\n",
    "LineaPy can help to set up and maintain pipelines with minimal effort.\n",
    "\n",
    "```\n",
    "import lineapy\n",
    "\n",
    "........................\n",
    ".\n",
    ". your original notebook\n",
    ". \n",
    "........................\n",
    "\n",
    "lineapy.save(object, 'artifact name')\n",
    "lineapy.to_pipeline(['artifact name', 'other artifact name', ... ], framework, pipeline_name, output_dir)\n",
    "```\n",
    " \n",
    "With just these three lines of code, LineaPy enables data scientists to produce runnable pipelines.\n",
    "For some orchestration systems, like Apache Airflow, LineaPy is even able to upload the runnable pipeline without any manual interaction.\n",
    "\n",
    "The rest of this notebook will use a concrete example to walk you through how this can be done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition info\" style=\"background:#F0FAFA\">\n",
    "    <p class=\"admonition-title\"><b>Info</b></p>\n",
    "    <p>\n",
    "        If you encounter issues you cannot resolve, simply ask in our <a href=\"https://join.slack.com/t/lineacommunity/shared_invite/zt-18kizfn3b-1Qu_HDT3ahGudnAwoFAw9Q\">Slack community</a>'s <code>#support</code> channel. We are always happy and ready to help you!\n",
    "    </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition note\" style=\"background:#F0F4FA\">\n",
    "    <p class=\"admonition-title\"><b>Note</b></p>\n",
    "    <p>\n",
    "        You can ignore <code># NBVAL_*</code> comments in certain cell blocks. They are for passing unit tests only, which we do to make sure the examples are always functional as we update the codebase.\n",
    "    </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "%%capture\n",
    "! pip -q install lineapy~=0.2 scikit-learn pandas matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lineapy extension is already loaded. To reload it, use:\n",
      "  %reload_ext lineapy\n"
     ]
    }
   ],
   "source": [
    "\n",
    "%load_ext lineapy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import os\n",
    "import lineapy\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "lineapy.tag(\"Pipeline End-to-End Demo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploration and Pre-processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are a botanist working in an ecology lab, and we recently obtained a data set to explore. Let's see what it contains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data\n",
    "url = \"https://raw.githubusercontent.com/LineaLabs/lineapy/main/examples/tutorials/data/iris.csv\"\n",
    "df = pd.read_csv(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal.length</th>\n",
       "      <th>sepal.width</th>\n",
       "      <th>petal.length</th>\n",
       "      <th>petal.width</th>\n",
       "      <th>variety</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal.length  sepal.width  petal.length  petal.width    variety\n",
       "0             5.1          3.5           1.4          0.2     Setosa\n",
       "1             4.9          3.0           1.4          0.2     Setosa\n",
       "2             4.7          3.2           1.3          0.2     Setosa\n",
       "3             4.6          3.1           1.5          0.2     Setosa\n",
       "4             5.0          3.6           1.4          0.2     Setosa\n",
       "..            ...          ...           ...          ...        ...\n",
       "145           6.7          3.0           5.2          2.3  Virginica\n",
       "146           6.3          2.5           5.0          1.9  Virginica\n",
       "147           6.5          3.0           5.2          2.0  Virginica\n",
       "148           6.2          3.4           5.4          2.3  Virginica\n",
       "149           5.9          3.0           5.1          1.8  Virginica\n",
       "\n",
       "[150 rows x 5 columns]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# View data\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is simple data that contains different iris species and their physical measurements. Our common sense dictates that petal length and width may have an association. Let's quickly check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Plot petal vs. sepal width\n",
    "df.plot.scatter(\"petal.length\", \"petal.width\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We visually confirm that there is a strong positive relationship between petal length and width.\n",
    "\n",
    "More interestingly, we see a distinct cluster of observations at the lower left side fof the plot, which suggests that these observations may correspond to a specific species. Let's plot observations by species."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Setosa        50\n",
       "Versicolor    50\n",
       "Virginica     50\n",
       "Name: variety, dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check species and their counts\n",
    "df[\"variety\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Map each species to a color\n",
    "color_map = {\"Setosa\": \"green\", \"Versicolor\": \"blue\", \"Virginica\": \"red\"}\n",
    "df[\"variety_color\"] = df[\"variety\"].map(color_map)\n",
    "\n",
    "# Plot petal length vs. width by species\n",
    "df.plot.scatter(\"petal.length\", \"petal.width\", c=\"variety_color\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We indeed confirm that each species forms a quite distinct cluster based on petal traits.\n",
    "\n",
    "To make our analysis more interesting, let's try some formal modeling, where we will try to identify the species of a given iris based on its petal traits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For modeling, map each species to a number\n",
    "num_map = {\"Setosa\": 0, \"Versicolor\": 1, \"Virginica\": 2}\n",
    "df[\"variety_num\"] = df[\"variety\"].map(num_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal.length</th>\n",
       "      <th>sepal.width</th>\n",
       "      <th>petal.length</th>\n",
       "      <th>petal.width</th>\n",
       "      <th>variety</th>\n",
       "      <th>variety_color</th>\n",
       "      <th>variety_num</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "      <td>green</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "      <td>green</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "      <td>green</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "      <td>green</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "      <td>green</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>Virginica</td>\n",
       "      <td>red</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>Virginica</td>\n",
       "      <td>red</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>Virginica</td>\n",
       "      <td>red</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "      <td>Virginica</td>\n",
       "      <td>red</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "      <td>Virginica</td>\n",
       "      <td>red</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal.length  sepal.width  petal.length  petal.width    variety  \\\n",
       "0             5.1          3.5           1.4          0.2     Setosa   \n",
       "1             4.9          3.0           1.4          0.2     Setosa   \n",
       "2             4.7          3.2           1.3          0.2     Setosa   \n",
       "3             4.6          3.1           1.5          0.2     Setosa   \n",
       "4             5.0          3.6           1.4          0.2     Setosa   \n",
       "..            ...          ...           ...          ...        ...   \n",
       "145           6.7          3.0           5.2          2.3  Virginica   \n",
       "146           6.3          2.5           5.0          1.9  Virginica   \n",
       "147           6.5          3.0           5.2          2.0  Virginica   \n",
       "148           6.2          3.4           5.4          2.3  Virginica   \n",
       "149           5.9          3.0           5.1          1.8  Virginica   \n",
       "\n",
       "    variety_color  variety_num  \n",
       "0           green            0  \n",
       "1           green            0  \n",
       "2           green            0  \n",
       "3           green            0  \n",
       "4           green            0  \n",
       "..            ...          ...  \n",
       "145           red            2  \n",
       "146           red            2  \n",
       "147           red            2  \n",
       "148           red            2  \n",
       "149           red            2  \n",
       "\n",
       "[150 rows x 7 columns]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# View data\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's store the pre-processed data as an artifact since we may want to reuse/recompute it later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LineaArtifact(name='iris_preprocessed', _version=3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Save side effects as an artifact\n",
    "lineapy.save(df, \"iris_preprocessed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition info\" style=\"background:#F0FAFA\">\n",
    "    <p class=\"admonition-title\"><b>Info</b></p>\n",
    "    <p>\n",
    "        In LineaPy, an artifact is both code and value. That is, when storing an artifact, LineaPy not only records the state (i.e., value) of the variable but also traces and saves all relevant operations leading to this state &mdash; as code. Such a complete development history or *lineage* then allows LineaPy to fully reproduce the given artifact. Learn more about LineaPy artifacts <a href=\"https://docs.lineapy.org/latest/tutorials/01_using_artifacts/\">here</a>.\n",
    "    </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modeling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For model building and evaluation, we need to split the data into training and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Identify predictor and outcome variables\n",
    "X = df[[\"petal.length\", \"petal.width\"]]\n",
    "y = df[\"variety_num\"]\n",
    "\n",
    "# Specify parameters of data split\n",
    "test_size = 0.33\n",
    "random_state = 42\n",
    "\n",
    "# Split the data\n",
    "split_samples = train_test_split(X, y, test_size=test_size, random_state=random_state)\n",
    "X_train = split_samples[0]\n",
    "X_test = split_samples[1]\n",
    "y_train = split_samples[2]\n",
    "y_test = split_samples[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the data split, we can now proceed to model training. Ours is a classification problem, so we can use multinomial logistic regression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(multi_class='multinomial')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Initiate the model\n",
    "mod = LogisticRegression(multi_class=\"multinomial\")\n",
    "\n",
    "# Fit the model\n",
    "mod.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's examine the model's accuracy, first on the training data and then on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      1.000     1.000     1.000        31\n",
      "           1      0.941     0.914     0.928        35\n",
      "           2      0.914     0.941     0.928        34\n",
      "\n",
      "    accuracy                          0.950       100\n",
      "   macro avg      0.952     0.952     0.952       100\n",
      "weighted avg      0.950     0.950     0.950       100\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Examine model accuracy on training data\n",
    "y_train_pred = mod.predict(X_train)\n",
    "mod_eval_train = classification_report(y_train, y_train_pred, digits=3)\n",
    "print(mod_eval_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      1.000     1.000     1.000        19\n",
      "           1      1.000     1.000     1.000        15\n",
      "           2      1.000     1.000     1.000        16\n",
      "\n",
      "    accuracy                          1.000        50\n",
      "   macro avg      1.000     1.000     1.000        50\n",
      "weighted avg      1.000     1.000     1.000        50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Examine model accuracy on test data\n",
    "y_test_pred = mod.predict(X_test)\n",
    "mod_eval_test = classification_report(y_test, y_test_pred, digits=3)\n",
    "print(mod_eval_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overall, results indicate our model is very accurate with all correct predictions on the test data!\n",
    "\n",
    "We are quite content with the model, so let's save it as an artifact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LineaArtifact(name='iris_model', _version=3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Save the fitted model as an artifact\n",
    "lineapy.save(mod, \"iris_model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also save the model evaluation result so we can reference it later as needed. For instance, this information may help model comparison and selection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LineaArtifact(name='iris_model_evaluation', _version=3)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Save the model evaluation result as an artifact\n",
    "lineapy.save(mod_eval_test, \"iris_model_evaluation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pipeline Building"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say we expect rerunning the above processes again in the future. For instance, our source data (`iris.csv`) may get new observations added. Or, we may want to train the model with a different source data. Or, we may want to train the model with a different randomization setup (i.e., different `random_state`). For these, we can simply update and rerun our original development scripts/notebooks, of course. However, this is a brittle process that's prone to errors, so we may want to instead set up a proper pipeline.\n",
    "\n",
    "Normally, this would involve finding our old code, cleaning it up, and transforming it into a deployable pipeline &mdash; all manually. Thankfully, we had already captured the relevant development history across LineaPy artifacts, so, for us, building a pipeline reduces to “stitching” these artifacts, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_script/iris_pipeline_module.py                                                                                                            \n",
      "Generated requirements file: pipeline_example_script/iris_pipeline_requirements.txt                                                                                               \n",
      "Generated Docker file: pipeline_example_script/iris_pipeline_Dockerfile                                                                                                           \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "PosixPath('pipeline_example_script')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build an pipeline using artifacts\n",
    "lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_script/\",\n",
    "    framework=\"SCRIPT\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where\n",
    "\n",
    "- `artifacts` is the list of artifact names to be used for the pipeline\n",
    "- `pipeline_name` is the name of the pipeline\n",
    "- `dependencies` is the dependency graph among artifacts\n",
    "    - If artifact A depends on artifacts B and C, then the graph is specified as `{ A: { B, C } }`\n",
    "    - If A depends on B and B depends on C, then the graph is specified as `{ A: { B }, B: { C } }`\n",
    "- `input_parameters` is the list of variable names (in the code) to be turned into tunable parameters of the pipeline\n",
    "- `output_dir` is the location to put the files for running the pipeline\n",
    "- `framework` is the name of orchestration framework to use\n",
    "    - LineaPy currently supports `\"AIRFLOW\"`, `\"ARGO\"`, `\"DVC\"`, `\"KUBEFLOW\"`, `\"RAY\"`, and `\"SCRIPT\"`\n",
    "    - If `\"SCRIPT\"`, it will generate files that can run the pipeline as a Python script\n",
    "    - For all other options, it will generate files that are used to run the pipeline in the  orchestration framework specified. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, our chosen framework is `\"SCRIPT\"`, so the API call above generates several files including:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['iris_pipeline_Dockerfile',\n",
       " 'iris_pipeline_module.py',\n",
       " 'iris_pipeline_requirements.txt']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Check the generated files for running the pipeline\n",
    "os.listdir(\"./pipeline_example_script/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where\n",
    "\n",
    "- `[pipeline_name]_module.py` contains the artifact code packaged as a function module\n",
    "- `[pipeline_name]_requirements.txt` lists any package dependencies for running the pipeline\n",
    "- `[pipeline_name]_Dockerfile` contains commands to set up the environment to run the pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Module File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The module file contains the bulk of the user code original user code, but broken down into modularized functions. Taking a closer look at the module file, `iris_pipeline_module.py`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment and run next line to view full file content\n",
    "# %cat ./pipeline_example_script/iris_pipeline_module.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select output from `./pipeline_example_script/iris_pipeline_module.py`\n",
    "```python\n",
    "[...]\n",
    "\n",
    "def get_iris_preprocessed(url):\n",
    "    df = pd.read_csv(url)\n",
    "    color_map = {\"Setosa\": \"green\", \"Versicolor\": \"blue\", \"Virginica\": \"red\"}\n",
    "    df[\"variety_color\"] = df[\"variety\"].map(color_map)\n",
    "    num_map = {\"Setosa\": 0, \"Versicolor\": 1, \"Virginica\": 2}\n",
    "    df[\"variety_num\"] = df[\"variety\"].map(num_map)\n",
    "    return df\n",
    "\n",
    "\n",
    "def get_split_samples_for_artifact_iris_model_and_downstream(\n",
    "    df, random_state, test_size\n",
    "):\n",
    "    X = df[[\"petal.length\", \"petal.width\"]]\n",
    "    y = df[\"variety_num\"]\n",
    "    split_samples = train_test_split(\n",
    "        X, y, test_size=test_size, random_state=random_state\n",
    "    )\n",
    "    return split_samples\n",
    "\n",
    "\n",
    "def get_iris_model(split_samples):\n",
    "    X_train = split_samples[0]\n",
    "    y_train = split_samples[2]\n",
    "    mod = LogisticRegression(multi_class=\"multinomial\")\n",
    "    mod.fit(X_train, y_train)\n",
    "    return mod\n",
    "\n",
    "\n",
    "def get_iris_model_evaluation(mod, split_samples):\n",
    "    X_test = split_samples[1]\n",
    "    y_test = split_samples[3]\n",
    "    y_test_pred = mod.predict(X_test)\n",
    "    mod_eval_test = classification_report(y_test, y_test_pred, digits=3)\n",
    "    return mod_eval_test\n",
    "\n",
    "[...]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that LineaPy used artifacts to automatically 1) clean up their code to retain only essential operations and 2) package the cleaned-up code into importable functions. For instance, we see that `get_iris_preprocessed()` can re-calculate the `iris_preprocessed` artifact, but in a more succinct way (e.g., irrelevant plotting code is now gone).\n",
    "\n",
    "Note that some function signatures have parameters (e.g., `def get_iris_preprocessed(url)`), and this is to support the pipeline parametrization we requested during our pipeline API call earlier.\n",
    "\n",
    "Note also that LineaPy has smartly identified the \"common\" computation between `iris_model` and `iris_model_evaluation` artifacts, which has been automatically factored out into its own function, i.e., `get_split_samples_for_artifact_iris_model_and_downstream()`; if this were a step involving a heavy computation, the current modularization would have saved much time and resource. This way, LineaPy minimizes duplicate processes in a pipeline, making it more efficient to run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition info\" style=\"background:#F0FAFA\">\n",
    "    <p class=\"admonition-title\"><b>Info</b></p>\n",
    "    <p>\n",
    "        In case you are wondering how LineaPy does this \"magic\": LineaPy represents user's code as a graph, where each node is a certain execution (e.g., variable assignment). Thanks to this graph representation, LineaPy can traverse user's code to identify dependency relations between parts of the code, which is the basis for code cleanup as well as \"smart\" refactoring (i.e., factoring out common code blocks between artifacts into a separate function). For illustration, the following shows an example of how user's code may map onto LineaPy's graph representation:\n",
    "    </p>\n",
    "    <img src=\"https://linea-docs-assets.s3.us-west-1.amazonaws.com/code_visavis_graph_example.png\" alt=\"code_visavis_graph\" style=\"padding:10px\">\n",
    "    <p>\n",
    "        As shown, <code>agg_df</code> (red) and <code>summary_df</code> (blue) share a common set of operations (green), so LineaPy will detect this overlap and factor it out into a separate function during code refactor.\n",
    "    </p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Requirements File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To ensure that the code runs as it did during development, `iris_pipeline_requirements.txt` has captured the relevant package dependencies, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pandas==1.3.5\n",
      "scikit-learn==1.0.2"
     ]
    }
   ],
   "source": [
    "\n",
    "%cat ./pipeline_example_script/iris_pipeline_requirements.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this list is much shorter than all imports that we did during development (e.g., it does not include `matplotlib`). This is because LineaPy has identified and kept necessary package dependencies only, hence making the setup as lean and efficient as possible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following sections, we will be going through more details for each of the other orchestration frameworks Lineapy supports. We'll take a deep dive into the framework specific differences, and some tips on how to quickly setup and run the pipelines generated in this demo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Orchestration Frameworks Supported"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Airflow\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pipelines that can be submitted to [Airflow](https://airflow.apache.org/) can be generated by changing the `FRAMEWORK` option in `to_pipeline` to `\"AIRFLOW\"`. For Airflow, this will generate the module file and requirements file as before. However, the dag file and Dockerfile have major changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_airflow/iris_pipeline_module.py                                                                                                           \n",
      "Generated requirements file: pipeline_example_airflow/iris_pipeline_requirements.txt                                                                                              \n",
      "Generated DAG file: pipeline_example_airflow/iris_pipeline_dag.py                                                                                                                 \n",
      "Generated Docker file: pipeline_example_airflow/iris_pipeline_Dockerfile                                                                                                          \n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build an pipeline using artifacts\n",
    "airflow_dir = lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_airflow/\",\n",
    "    framework=\"AIRFLOW\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Airflow Dag file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions in the module file are not directly runnable in airflow as is, so Lineapy creates a DAG file `iris_pipeline_dag.py` that Airflow understands and then imports and uses the functions in the module file to compose an Airflow DAG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment and run next line to view full file content\n",
    "# %cat ./pipeline_example_airflow/iris_pipeline_dag.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select output from `./pipeline_example_airflow/iris_pipeline_dag.py`\n",
    "```python\n",
    "[...]\n",
    "\n",
    "import iris_pipeline_module\n",
    "\n",
    "[...]\n",
    "\n",
    "def task_iris_preprocessed(url):\n",
    "\n",
    "    url = str(url)\n",
    "\n",
    "    df = iris_pipeline_module.get_iris_preprocessed(url)\n",
    "\n",
    "    pickle.dump(df, open(\"/tmp/iris_pipeline/variable_df.pickle\", \"wb\"))\n",
    "\n",
    "\n",
    "def task_split_samples_for_artifact_iris_model_and_downstream(random_state, test_size):\n",
    "\n",
    "    random_state = int(random_state)\n",
    "\n",
    "    test_size = float(test_size)\n",
    "\n",
    "    df = pickle.load(open(\"/tmp/iris_pipeline/variable_df.pickle\", \"rb\"))\n",
    "\n",
    "    split_samples = (\n",
    "        iris_pipeline_module.get_split_samples_for_artifact_iris_model_and_downstream(\n",
    "            df, random_state, test_size\n",
    "        )\n",
    "    )\n",
    "\n",
    "    pickle.dump(\n",
    "        split_samples, open(\"/tmp/iris_pipeline/variable_split_samples.pickle\", \"wb\")\n",
    "    )\n",
    "\n",
    "[...]\n",
    "\n",
    "default_dag_args = {\n",
    "    \"owner\": \"airflow\",\n",
    "    \"retries\": 2,\n",
    "    \"start_date\": days_ago(1),\n",
    "    \"params\": {\n",
    "        \"url\": \"https://raw.githubusercontent.com/LineaLabs/lineapy/main/examples/tutorials/data/iris.csv\",\n",
    "        \"test_size\": 0.33,\n",
    "        \"random_state\": 42,\n",
    "    },\n",
    "}\n",
    "\n",
    "with DAG(\n",
    "    dag_id=\"iris_pipeline_dag\",\n",
    "    schedule_interval=\"*/15 * * * *\",\n",
    "    max_active_runs=1,\n",
    "    catchup=False,\n",
    "    default_args=default_dag_args,\n",
    ") as dag:\n",
    "\n",
    "    [...]\n",
    "\n",
    "    iris_preprocessed = PythonOperator(\n",
    "        task_id=\"iris_preprocessed_task\",\n",
    "        python_callable=task_iris_preprocessed,\n",
    "        op_kwargs={\"url\": \"{{ params.url }}\"},\n",
    "    )\n",
    "\n",
    "    split_samples_for_artifact_iris_model_and_downstream = PythonOperator(\n",
    "        task_id=\"split_samples_for_artifact_iris_model_and_downstream_task\",\n",
    "        python_callable=task_split_samples_for_artifact_iris_model_and_downstream,\n",
    "        op_kwargs={\n",
    "            \"random_state\": \"{{ params.random_state }}\",\n",
    "            \"test_size\": \"{{ params.test_size }}\",\n",
    "        },\n",
    "    )\n",
    "\n",
    "    [...]\n",
    "\n",
    "    iris_preprocessed >> split_samples_for_artifact_iris_model_and_downstream\n",
    "\n",
    "    [...]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown, the DAG file defines \"tasks\" (e.g., `iris_preprocessed_task`) using functions from the module file, and then puts them together into an executable graph (dependency relationships are expressed through `>>`).\n",
    "\n",
    "Note that these tasks in the DAG file also reflect our requested pipeline parameters (e.g., `url`), which will eventually allow us to run the pipeline with different values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Airflow Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Dockerfile `iris_pipeline_Dockerfile` further facilitates pipeline execution by containerizing/automating environment setup and launch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FROM apache/airflow:latest-python3.9\n",
      "\n",
      "RUN mkdir /tmp/installers\n",
      "WORKDIR /tmp/installers\n",
      "\n",
      "# copy all the requirements to run the current dag\n",
      "COPY ./iris_pipeline_requirements.txt ./\n",
      "# install the required libs\n",
      "RUN pip install -r ./iris_pipeline_requirements.txt\n",
      "\n",
      "WORKDIR /opt/airflow/dags\n",
      "COPY ./iris_pipeline_module.py ./\n",
      "COPY ./iris_pipeline_dag.py ./\n",
      "\n",
      "WORKDIR /opt/airflow\n",
      "\n",
      "CMD [ \"standalone\" ]"
     ]
    }
   ],
   "source": [
    "\n",
    "%cat ./pipeline_example_airflow/iris_pipeline_Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Running Airflow Dags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these automatically generated files, we can quickly test running the pipeline locally. First, we run the following command to build a Docker image:\n",
    "\n",
    "```bash\n",
    "docker build -t [image_name] . -f iris_pipeline_Dockerfile\n",
    "```\n",
    "\n",
    "where `[image_name]` is the image name of our choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then stand up a container instance with the following command:\n",
    "\n",
    "```bash\n",
    "docker run -it -p 8080:8080 [image_name]\n",
    "```\n",
    "\n",
    "In the current example where we set `framework=\"AIRFLOW\"`, this will result in an Airflow instance with an executable DAG in it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Argo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pipelines that can be submitted to [Argo Workflows](https://argoproj.github.io/argo-workflows/) can be generated by changing the `FRAMEWORK` option in `to_pipeline` to `\"ARGO\"`. For Argo, this will generate the module file and requirements file as before. However, the dag file and Dockerfile have major changes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_argo/iris_pipeline_module.py                                                                                                              \n",
      "Generated requirements file: pipeline_example_argo/iris_pipeline_requirements.txt                                                                                                 \n",
      "Generated DAG file: pipeline_example_argo/iris_pipeline_dag.py                                                                                                                    \n",
      "Generated Docker file: pipeline_example_argo/iris_pipeline_Dockerfile                                                                                                             \n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build an ARGO pipeline using artifacts\n",
    "argo_dir = lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_argo/\",\n",
    "    framework=\"ARGO\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Argo Dag file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dag file generated in Argo is a python file that uses [Hera](https://github.com/argoproj-labs/hera-workflows), a Python SDK for constructing and submitting Argo Workflows. \n",
    "\n",
    "The dag creates a Hera Workflow and associated WorkflowService so the DAG can be submitted. Tasks are also generated that call their respective functions in the module file. Notice that the task outputs are defined as [Artifacts](https://argoproj.github.io/argo-workflows/walk-through/artifacts/) (not the same as Linea Artifacts), which will end up being stored in the Argo Artifact Repository. \n",
    "\n",
    "Since Argo is a Kubernetes based orchestration engine, the generated tasks are meant to be run in pods. The DAG file also specifies that the image that should be used to build the containers running in the pod is `iris_pipeline:lineapy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Uncomment and run next line to view full file content\n",
    "# %cat ./pipeline_example_argo/iris_pipeline_dag.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select output from `./pipeline_example_argo/iris_pipeline_dag.py`\n",
    "```python\n",
    "[...]\n",
    "\n",
    "from hera import Artifact, ImagePullPolicy, set_global_task_image\n",
    "from hera.task import Task\n",
    "from hera.workflow import Workflow\n",
    "from hera.workflow_service import WorkflowService\n",
    "\n",
    "[...]\n",
    "\n",
    "def task_run_session_including_iris_preprocessed(url, test_size, random_state):\n",
    "\n",
    "    [...]\n",
    "    artifacts = iris_pipeline_module.run_session_including_iris_preprocessed(\n",
    "        url, test_size, random_state\n",
    "    )\n",
    "    [...]\n",
    "\n",
    "    \n",
    "ws = WorkflowService(\n",
    "    host=\"https://localhost:2746\",\n",
    "    verify_ssl=False,\n",
    "    token=get_sa_token(\"argo\", \"argo\", os.path.expanduser(\"~/.kube/config\")),\n",
    "    namespace=\"argo\",\n",
    ")\n",
    "\n",
    "with Workflow(\"iris-pipeline\", service=ws) as w:\n",
    "\n",
    "    set_global_task_image(\"iris_pipeline:lineapy\")\n",
    "\n",
    "    run_session_including_iris_preprocessed = Task(\n",
    "        \"run-session-including-iris-preprocessed\",\n",
    "        task_run_session_including_iris_preprocessed,\n",
    "        [\n",
    "            {\n",
    "                \"url\": \"https://raw.githubusercontent.com/LineaLabs/lineapy/main/examples/tutorials/data/iris.csv\",\n",
    "                \"test_size\": \"0.33\",\n",
    "                \"random_state\": \"42\",\n",
    "            }\n",
    "        ],\n",
    "        image_pull_policy=ImagePullPolicy.Never,\n",
    "        outputs=[\n",
    "            Artifact(\n",
    "                \"iris_preprocessed\",\n",
    "                \"/tmp/iris_pipeline/variable_iris_preprocessed.pickle\",\n",
    "            ),\n",
    "            Artifact(\n",
    "                \"iris_model\",\n",
    "                \"/tmp/iris_pipeline/variable_iris_model.pickle\",\n",
    "            ),\n",
    "            Artifact(\n",
    "                \"iris_model_evaluation\",\n",
    "                \"/tmp/iris_pipeline/variable_iris_model_evaluation.pickle\",\n",
    "            ),\n",
    "        ],\n",
    "    )\n",
    "\n",
    "    [...]\n",
    "\n",
    "w.create()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Argo Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Argo, the Dockerfile is used to build the image `iris_pipeline:lineapy` and does not run Argo itself. Note the comments on how to build the Dockerfile at the top of the file. This will make sure that the pods running each Task have the right dependencies and toolchain. \n",
    "\n",
    "Make sure that after building the Dockerfile it is pushed to an image repository that can be accessed by the Argo cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Be sure to build this docker file with the following command\n",
      "# docker build -t iris_pipeline:lineapy -f iris_pipeline_Dockerfile .\n",
      "\n",
      "FROM python:3.9\n",
      "\n",
      "RUN mkdir /tmp/installers\n",
      "WORKDIR /tmp/installers\n",
      "\n",
      "# Copy all the requirements to run current DAG\n",
      "COPY ./iris_pipeline_requirements.txt ./\n",
      "\n",
      "# Install required libs\n",
      "RUN pip install -r ./iris_pipeline_requirements.txt\n",
      "\n",
      "WORKDIR /opt/argo/dags\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "!head -n 15 ./pipeline_example_argo/iris_pipeline_DOCKERFILE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Running Argo Pipelines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The argo examples generated can also be tested locally. To spin up a standalone instance of Argo, make sure to have a kubernetes instance, then run the following commands adapted from the [Argo Quickstart Guide](https://argoproj.github.io/argo-workflows/quick-start/).\n",
    "\n",
    "Create the namespace and deploy argo from their quickstart yaml.\n",
    "```bash\n",
    "kubectl create ns argo\n",
    "kubectl apply -n argo -f https://raw.githubusercontent.com/argoproj/argo-workflows/master/manifests/quick-start-postgres.yaml\n",
    "```\n",
    "Patch the authentication mode to be server side\n",
    "```bash\n",
    "kubectl patch deployment \\\n",
    "  argo-server \\\n",
    "  --namespace argo \\\n",
    "  --type='json' \\\n",
    "  -p='[{\"op\": \"replace\", \"path\": \"/spec/template/spec/containers/0/args\", \"value\": [\n",
    "  \"server\",\n",
    "  \"--auth-mode=server\"\n",
    "]}]'\n",
    "```\n",
    "Port forward the argo deployment\n",
    "```bash\n",
    "kubectl -n argo port-forward deployment/argo-server 2746:2746\n",
    "```\n",
    "\n",
    "After following these steps, the argo UI should be visible on `localhost:2746`. \n",
    "\n",
    "To submit the pipeline, make sure to build the dockerfile first. Then simply run the dag file using \n",
    "\n",
    "```bash\n",
    "python ./pipeline_example_argo/iris_pipeline_dag.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kubeflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pipelines that can be submitted to [Kubeflow Pipelines](https://www.kubeflow.org/docs/components/pipelines/v1/introduction/) can be generated by changing the `FRAMEWORK` option in `to_pipeline` to `\"KUBEFLOW\"`. For Kubeflow, this will generate the module file and requirements file as before. However, the dag file and Dockerfile have major changes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_kubeflow/iris_pipeline_module.py                                                                                                          \n",
      "Generated requirements file: pipeline_example_kubeflow/iris_pipeline_requirements.txt                                                                                             \n",
      "Generated DAG file: pipeline_example_kubeflow/iris_pipeline_dag.py                                                                                                                \n",
      "Generated Docker file: pipeline_example_kubeflow/iris_pipeline_Dockerfile                                                                                                         \n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build a KUBEFLOW pipeline using artifacts\n",
    "kubeflow_dir = lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_kubeflow/\",\n",
    "    framework=\"KUBEFLOW\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Kubeflow Dag file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dag file generated in Kubeflow is a python file using Kubeflow Pipelines SDK `kfp`. \n",
    "\n",
    "In Kubeflow, a function is created for each task that refers back to the generated module file. However, for Kubeflow, this function must first be turned into a component through `create_component_from_func`, which itself can then be turned into a task by calling the component with the desired inputs and outputs specified in the pipeline definition.\n",
    "\n",
    "Since Kubeflow is a Kubernetes based orchestration engine, the generated tasks are meant to be run in pods. Each component also specifies that the image that should be used to build the container running in the pod is `iris_pipeline:lineapy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Uncomment and run next line to view full file content\n",
    "# %cat ./pipeline_example_kubeflow/iris_pipeline_dag.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select output from `./pipeline_example_kubeflow/iris_pipeline_dag.py`\n",
    "```python\n",
    "import kfp\n",
    "from kfp.components import create_component_from_func\n",
    "\n",
    "\n",
    "def task_iris_preprocessed(url, variable_df_path: kfp.components.OutputPath(str)):\n",
    "    [...]\n",
    "\n",
    "def task_split_samples_for_artifact_iris_model_and_downstream(\n",
    "    random_state,\n",
    "    test_size,\n",
    "    variable_df_path: kfp.components.InputPath(str),\n",
    "    variable_split_samples_path: kfp.components.OutputPath(str),\n",
    "):\n",
    "    [...]\n",
    "\n",
    "\n",
    "def task_iris_model(\n",
    "    variable_split_samples_path: kfp.components.InputPath(str),\n",
    "    variable_mod_path: kfp.components.OutputPath(str),\n",
    "):\n",
    "    import pathlib\n",
    "    import pickle\n",
    "\n",
    "    import iris_pipeline_module\n",
    "\n",
    "    split_samples = pickle.load(open(variable_split_samples_path, \"rb\"))\n",
    "\n",
    "    mod = iris_pipeline_module.get_iris_model(split_samples)\n",
    "\n",
    "    pickle.dump(mod, open(variable_mod_path, \"wb\"))\n",
    "\n",
    "\n",
    "def task_iris_model_evaluation(\n",
    "    variable_mod_path: kfp.components.InputPath(str),\n",
    "    variable_split_samples_path: kfp.components.InputPath(str),\n",
    "    variable_mod_eval_test_path: kfp.components.OutputPath(str),\n",
    "):\n",
    "    [...]\n",
    "\n",
    "[...]\n",
    "\n",
    "iris_preprocessed_component = create_component_from_func(\n",
    "    task_iris_preprocessed, base_image=\"iris_pipeline:lineapy\"\n",
    ")\n",
    "\n",
    "split_samples_for_artifact_iris_model_and_downstream_component = (\n",
    "    create_component_from_func(\n",
    "        task_split_samples_for_artifact_iris_model_and_downstream,\n",
    "        base_image=\"iris_pipeline:lineapy\",\n",
    "    )\n",
    ")\n",
    "\n",
    "iris_model_component = create_component_from_func(\n",
    "    task_iris_model, base_image=\"iris_pipeline:lineapy\"\n",
    ")\n",
    "\n",
    "iris_model_evaluation_component = create_component_from_func(\n",
    "    task_iris_model_evaluation, base_image=\"iris_pipeline:lineapy\"\n",
    ")\n",
    "\n",
    "[...]\n",
    "\n",
    "client = kfp.Client(host=\"http://localhost:3000\")\n",
    "\n",
    "\n",
    "@kfp.dsl.pipeline(\n",
    "    name=\"iris_pipeline_dag\",\n",
    ")\n",
    "def iris_pipeline(url, test_size, random_state):\n",
    "\n",
    "    task_iris_preprocessed = iris_preprocessed_component(url)\n",
    "    task_split_samples_for_artifact_iris_model_and_downstream = (\n",
    "        split_samples_for_artifact_iris_model_and_downstream_component(\n",
    "            random_state, test_size, task_iris_preprocessed.outputs[\"variable_df\"]\n",
    "        )\n",
    "    )\n",
    "    task_iris_model = iris_model_component(\n",
    "        task_split_samples_for_artifact_iris_model_and_downstream.outputs[\n",
    "            \"variable_split_samples\"\n",
    "        ]\n",
    "    )\n",
    "    task_iris_model_evaluation = iris_model_evaluation_component(\n",
    "        task_iris_model.outputs[\"variable_mod\"],\n",
    "        task_split_samples_for_artifact_iris_model_and_downstream.outputs[\n",
    "            \"variable_split_samples\"\n",
    "        ],\n",
    "    )\n",
    "\n",
    "    task_iris_model.after(task_split_samples_for_artifact_iris_model_and_downstream)\n",
    "\n",
    "    task_iris_model_evaluation.after(task_iris_model)\n",
    "\n",
    "    task_iris_model_evaluation.after(\n",
    "        task_split_samples_for_artifact_iris_model_and_downstream\n",
    "    )\n",
    "\n",
    "    task_iris_preprocessed.after(task_setup)\n",
    "\n",
    "    task_split_samples_for_artifact_iris_model_and_downstream.after(\n",
    "        task_iris_preprocessed\n",
    "    )\n",
    "\n",
    "    task_teardown.after(task_iris_model_evaluation)\n",
    "\n",
    "\n",
    "pipeline_arguments = {\n",
    "    \"url\": \"https://raw.githubusercontent.com/LineaLabs/lineapy/main/examples/tutorials/data/iris.csv\",\n",
    "    \"test_size\": 0.33,\n",
    "    \"random_state\": 42,\n",
    "}\n",
    "\n",
    "client.create_run_from_pipeline_func(iris_pipeline, arguments=pipeline_arguments)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Kubeflow Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Kubeflow, the Dockerfile is used to build the image `iris_pipeline:lineapy` and does not run Kubeflow itself. Note the comments on how to build the Dockerfile at the top of the file. This will make sure that the pods running each Task have the right dependencies and toolchain. \n",
    "\n",
    "Make sure that after building the Dockerfile it is uploaded to an image repository that can be accessed by the Kubeflow cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Be sure to build this docker file with the following command\n",
      "# docker build -t iris_pipeline:lineapy -f iris_pipeline_Dockerfile .\n",
      "\n",
      "FROM python:3.9\n",
      "\n",
      "RUN mkdir /tmp/installers\n",
      "WORKDIR /tmp/installers\n",
      "\n",
      "# Copy all the requirements to run current DAG\n",
      "COPY ./iris_pipeline_requirements.txt ./\n",
      "\n",
      "# Install kubeflow python sdk\n",
      "RUN apt update\n",
      "RUN pip install kfp\n",
      "\n",
      "# Install required libs\n",
      "RUN pip install -r ./iris_pipeline_requirements.txt\n",
      "\n",
      "WORKDIR /home\n",
      "COPY ./iris_pipeline_module.py ./\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "!head -n 20 ./pipeline_example_kubeflow/iris_pipeline_DOCKERFILE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Running Kubeflow Pipelines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The kubeflow examples generated can also be tested locally. To spin up a standalone instance of Kubeflow make sure to have a kubernetes instance, then run the following commands adapted from the [Standalone Deployment Setup Guide](https://www.kubeflow.org/docs/components/pipelines/v1/installation/standalone-deployment/).\n",
    "\n",
    "Create the namespace and deploy kubeflow from their manifests.\n",
    "```bash\n",
    "kubectl create ns kubeflow\n",
    "\n",
    "kubectl apply -n kubeflow -k \"github.com/kubeflow/pipelines/manifests/kustomize/cluster-scoped-resources?ref=1.8.5\"\n",
    "kubectl wait --for condition=established --timeout=60s crd/applications.app.k8s.io\n",
    "kubectl apply -n kubeflow -k \"github.com/kubeflow/pipelines/manifests/kustomize/env/platform-agnostic-pns?ref=1.8.5\"\n",
    "```\n",
    "\n",
    "Port forward the kubeflow deployment\n",
    "```bash\n",
    "kubectl port-forward -n kubeflow svc/ml-pipeline-ui 3000:80\n",
    "```\n",
    "\n",
    "After following these steps, the kubeflow UI should be visible on `localhost:3000`. \n",
    "\n",
    "To submit the pipeline, make sure to build the dockerfile first. Then simply run the dag file using \n",
    "\n",
    "```bash\n",
    "python ./pipeline_example_kubeflow/iris_pipeline_dag.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pipelines that can be submitted to [Ray Workflows](https://docs.ray.io/en/latest/workflows/index.html) can be generated by changing the `FRAMEWORK` option in `to_pipeline` to `\"RAY\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_ray/iris_pipeline_module.py                                                                                                               \n",
      "Generated requirements file: pipeline_example_ray/iris_pipeline_requirements.txt                                                                                                  \n",
      "Generated DAG file: pipeline_example_ray/iris_pipeline_dag.py                                                                                                                     \n",
      "Generated Docker file: pipeline_example_ray/iris_pipeline_Dockerfile                                                                                                              \n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build an RAY workflow using artifacts\n",
    "ray_dir = lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_ray/\",\n",
    "    framework=\"RAY\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ray Dag file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dag file generated in Ray is a python file. \n",
    "\n",
    "As with other frameworks, function are created that refers back to the generated module file. These are decorated with `ray.remote` so that they are recognized as Ray tasks.\n",
    "\n",
    "The functions are then connected together using `.bind()` and the \"sink\" or last task is used to define the whole workflow which can be run through `ray.workflow.run`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "import pathlib\n",
      "import pickle\n",
      "\n",
      "import iris_pipeline_module\n",
      "import ray\n",
      "from packaging import version\n",
      "\n",
      "ray.init(runtime_env={\"working_dir\": \".\"}, storage=\"/tmp\")\n",
      "\n",
      "\n",
      "@ray.remote\n",
      "def task_iris_preprocessed(url):\n",
      "\n",
      "    url = str(url)\n",
      "\n",
      "    df = iris_pipeline_module.get_iris_preprocessed(url)\n",
      "\n",
      "    return df\n",
      "\n",
      "\n",
      "@ray.remote\n",
      "def task_split_samples_for_artifact_iris_model_and_downstream(\n",
      "    random_state, test_size, df\n",
      "):\n",
      "\n",
      "    random_state = int(random_state)\n",
      "\n",
      "    test_size = float(test_size)\n",
      "\n",
      "    split_samples = (\n",
      "        iris_pipeline_module.get_split_samples_for_artifact_iris_model_and_downstream(\n",
      "            df, random_state, test_size\n",
      "        )\n",
      "    )\n",
      "\n",
      "    return split_samples\n",
      "\n",
      "\n",
      "@ray.remote\n",
      "def task_iris_model(split_samples):\n",
      "\n",
      "    mod = iris_pipeline_module.get_iris_model(split_samples)\n",
      "\n",
      "    return mod\n",
      "\n",
      "\n",
      "@ray.remote\n",
      "def task_iris_model_evaluation(mod, split_samples):\n",
      "\n",
      "    mod_eval_test = iris_pipeline_module.get_iris_model_evaluation(mod, split_samples)\n",
      "\n",
      "    return mod_eval_test\n",
      "\n",
      "\n",
      "# Specify argument values for your pipeline run.\n",
      "pipeline_arguments = {\n",
      "    \"url\": \"https://raw.githubusercontent.com/LineaLabs/lineapy/main/examples/tutorials/data/iris.csv\",\n",
      "    \"test_size\": 0.33,\n",
      "    \"random_state\": 42,\n",
      "}\n",
      "\n",
      "df = task_iris_preprocessed.bind(pipeline_arguments[\"url\"])\n",
      "split_samples = task_split_samples_for_artifact_iris_model_and_downstream.bind(\n",
      "    pipeline_arguments[\"random_state\"], pipeline_arguments[\"test_size\"], df\n",
      ")\n",
      "mod = task_iris_model.bind(split_samples)\n",
      "mod_eval_test = task_iris_model_evaluation.bind(mod, split_samples)\n",
      "\n",
      "if version.parse(ray.__version__) < version.parse(\"2.0\"):\n",
      "    raise RuntimeError(\n",
      "        f\"Ray Workflows requires version >2.0 but {ray.__version__} was found\"\n",
      "    )\n",
      "ray.workflow.run(mod_eval_test)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "%cat ./pipeline_example_ray/iris_pipeline_dag.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ray Dockerfile & Running Ray Workflows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Dockerfile for Ray installs ray and the dependencies needed to run the workflow. No additional setup is needed, simply running the dag file using `python iris_pipeline_dag.py` will run the DAG. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FROM python:3.9\n",
      "\n",
      "RUN mkdir /tmp/installers\n",
      "WORKDIR /tmp/installers\n",
      "\n",
      "# Copy all the requirements to run current DAG\n",
      "COPY ./iris_pipeline_requirements.txt ./\n",
      "\n",
      "# Install ray\n",
      "RUN apt update\n",
      "RUN pip install ray\n",
      "\n",
      "# Install required libs\n",
      "RUN pip install -r ./iris_pipeline_requirements.txt\n",
      "\n",
      "WORKDIR /home\n",
      "COPY ./iris_pipeline_module.py ./\n",
      "COPY ./iris_pipeline_dag.py ./\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "%cat ./pipeline_example_ray/iris_pipeline_DOCKERFILE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using Ray Remote API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Lineapy Ray integration also supports generating Ray tasks using the usual remote API. To switch to this older Ray API, simply specify `\"use_workflows\": False` in the `pipeline_dag_config`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_ray/iris_pipeline_module.py                                                                                                               \n",
      "Generated requirements file: pipeline_example_ray/iris_pipeline_requirements.txt                                                                                                  \n",
      "Generated DAG file: pipeline_example_ray/iris_pipeline_dag.py                                                                                                                     \n",
      "Generated Docker file: pipeline_example_ray/iris_pipeline_Dockerfile                                                                                                              \n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build an RAY workflow using artifacts\n",
    "ray_dir = lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    pipeline_dag_config={\"use_workflows\": False},\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_ray/\",\n",
    "    framework=\"RAY\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DVC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pipelines that can be run using [DVC Pipelines](https://dvc.org/doc/start/data-management/data-pipelines/) can be generated by changing the `FRAMEWORK` option in `to_pipeline` to `\"DVC\"`. For DVC, this will generate the module file and requirements file as before. However, the dag files will see major changes as DVC is a yaml based orchestration framework.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generated module file: pipeline_example_dvc/iris_pipeline_module.py                                                                                                               \n",
      "Generated requirements file: pipeline_example_dvc/iris_pipeline_requirements.txt                                                                                                  \n",
      "Generated DAG file: pipeline_example_dvc/params.yaml                                                                                                                              \n",
      "Generated DAG file: pipeline_example_dvc/task_iris_preprocessed.py                                                                                                                \n",
      "Generated DAG file: pipeline_example_dvc/task_split_samples_for_artifact_iris_model_and_downstream.py                                                                             \n",
      "Generated DAG file: pipeline_example_dvc/task_iris_model.py                                                                                                                       \n",
      "Generated DAG file: pipeline_example_dvc/task_iris_model_evaluation.py                                                                                                            \n",
      "Generated DAG file: pipeline_example_dvc/dvc.yaml                                                                                                                                 \n",
      "Generated Docker file: pipeline_example_dvc/iris_pipeline_Dockerfile                                                                                                              \n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Build an DVC pipeline using artifacts\n",
    "dvc_dir = lineapy.to_pipeline(\n",
    "    pipeline_name=\"iris_pipeline\",\n",
    "    artifacts=[\"iris_preprocessed\", \"iris_model\", \"iris_model_evaluation\"],\n",
    "    dependencies={\n",
    "        \"iris_model_evaluation\": {\"iris_model\"},\n",
    "        \"iris_model\": {\"iris_preprocessed\"}\n",
    "    },\n",
    "    input_parameters=[\"url\", \"test_size\", \"random_state\"],\n",
    "    output_dir=\"./pipeline_example_dvc/\",\n",
    "    framework=\"DVC\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### DVC Dag file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dag file generated in DVC is a yaml file that must be named `dvc.yaml`.  \n",
    "\n",
    "Unlike other frameworks, DVC works best when each stage is defined seperately in its own file. The main `dvc.yaml` file defines the stages and which file should be run for each stage along with input and output dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stages:\n",
      "\n",
      "    iris_preprocessed:\n",
      "        cmd: python task_iris_preprocessed.py\n",
      "        deps:\n",
      "            - iris_pipeline_module.py\n",
      "            - task_iris_preprocessed.py\n",
      "        outs:\n",
      "            - df.pickle\n",
      "\n",
      "    split_samples_for_artifact_iris_model_and_downstream:\n",
      "        cmd: python task_split_samples_for_artifact_iris_model_and_downstream.py\n",
      "        deps:\n",
      "            - iris_pipeline_module.py\n",
      "            - task_split_samples_for_artifact_iris_model_and_downstream.py\n",
      "            - df.pickle\n",
      "        outs:\n",
      "            - split_samples.pickle\n",
      "\n",
      "    iris_model:\n",
      "        cmd: python task_iris_model.py\n",
      "        deps:\n",
      "            - iris_pipeline_module.py\n",
      "            - task_iris_model.py\n",
      "            - split_samples.pickle\n",
      "        outs:\n",
      "            - mod.pickle\n",
      "\n",
      "    iris_model_evaluation:\n",
      "        cmd: python task_iris_model_evaluation.py\n",
      "        deps:\n",
      "            - iris_pipeline_module.py\n",
      "            - task_iris_model_evaluation.py\n",
      "            - mod.pickle\n",
      "            - split_samples.pickle\n",
      "        outs:\n",
      "            - mod_eval_test.pickle\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "%cat ./pipeline_example_dvc/dvc.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### DVC task files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking a look at an individual task file reveals that each is defined in a similar manner to the tasks in other frameworks, but each file now only contains the function for one task along with a main block so that the file can be run. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "import pickle\n",
      "\n",
      "import dvc.api\n",
      "import iris_pipeline_module\n",
      "\n",
      "\n",
      "def task_iris_preprocessed(url):\n",
      "\n",
      "    url = str(url)\n",
      "\n",
      "    df = iris_pipeline_module.get_iris_preprocessed(url)\n",
      "\n",
      "    pickle.dump(df, open(\"df.pickle\", \"wb\"))\n",
      "\n",
      "\n",
      "if __name__ == \"__main__\":\n",
      "    url = dvc.api.params_show()[\"url\"]\n",
      "    task_iris_preprocessed(url)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "%cat ./pipeline_example_dvc/task_iris_preprocessed.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### DVC parameters file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DVC also requires that parameters be defined in their own `params.yaml` file, which is also generated by Lineapy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "url: https://raw.githubusercontent.com/LineaLabs/lineapy/main/examples/tutorials/data/iris.csv\n",
      "test_size: 0.33\n",
      "random_state: 42\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "%cat ./pipeline_example_dvc/params.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### DVC Dockerfile & Running DVC pipelines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the Dockerfile for DVC installs dvc, all the task dependencies, and sets up the working directory as a dvc repository. This allows the DAG to be run using a `dvc repro` command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FROM python:3.9\n",
      "\n",
      "RUN mkdir /tmp/installers\n",
      "WORKDIR /tmp/installers\n",
      "\n",
      "# Copy all the requirements to run current DAG\n",
      "COPY ./iris_pipeline_requirements.txt ./\n",
      "\n",
      "# Install git and dvc\n",
      "RUN apt update\n",
      "RUN apt install -y git\n",
      "RUN pip install dvc\n",
      "\n",
      "# Install required libs\n",
      "RUN pip install -r ./iris_pipeline_requirements.txt\n",
      "\n",
      "WORKDIR /home\n",
      "COPY . .\n",
      "\n",
      "# Initialize workdir as a dvc repo\n",
      "RUN git init\n",
      "RUN dvc init\n",
      "\n",
      "ENTRYPOINT [ \"dvc\", \"repro\", \"run_all_sessions\"]"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "%cat ./pipeline_example_dvc/iris_pipeline_Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data science workflows revolve around building and refining pipelines, i.e. series of processes that transform data into useful information/product. Traditionally, this is often manual and time-consuming work as data scientists (or other engineers) need to clean up messy development code and transform it into deployable scripts for the target system (e.g., Airflow). This tutorial demonstrated that LineaPy, having the complete development process stored in artifacts, can automate such code transformation, accelerating transition from development to production."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"admonition info\" style=\"background:#F0FAFA\">\n",
    "    <p class=\"admonition-title\"><b>Info</b></p>\n",
    "    <p>\n",
    "        If you want to learn more about LineaPy's pipeline support, check out the project <a href=\"https://docs.lineapy.org/latest/guides/usage/pipeline-building/\">documentation</a>.\n",
    "    </p>\n",
    "</div>"
   ]
  }
 ],
 "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.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "7b13a91c030603db07ad54ba4f9266c0e4bd5a63bc20907813ff665f2d224783"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}