docs/tutorials/clean.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial\n",
    "\n",
    "```self.clean(self, inputs, data=None, **kwargs)```\n",
    "\n",
    "This is a tutorial for the 'clean' method, a necessary step for ensuring FoKL may process almost any dataset. In the\n",
    "following script, it will be shown how 'clean' may be used to automatically format and normalize a raw dataset, only format, or normalize to a wider range of values which is most useful for applications in the 'update' method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from FoKL import FoKLRoutines\n",
    "import os\n",
    "dir = os.path.abspath('')  # directory of notebook\n",
    "# # -----------------------------------------------------------------------\n",
    "# # UNCOMMENT IF USING LOCAL FOKL PACKAGE:\n",
    "# import sys\n",
    "# sys.path.append(os.path.join(dir, '..', '..'))  # package directory\n",
    "# from src.FoKL import FoKLRoutines\n",
    "# # -----------------------------------------------------------------------\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# Example dataset:\n",
    "inputs = [np.linspace(0, 10, 100), 10 * np.random.rand(100)]\n",
    "data = inputs[0] ** 2 + inputs[1]\n",
    "\n",
    "# Initialize FoKL class object:\n",
    "model = FoKLRoutines.FoKL(UserWarnings=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standard Use\n",
    "\n",
    "(ignore ```_setattr=True```; this may be left out when using ```clean```)\n",
    "\n",
    "If the raw dataset is thought to be complete, without new data expected, but most importantly without new input variable mininma or maxima expected, 'clean' only needs to be called once.\n",
    "\n",
    "To train on the entire dataset,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.0, 10.0], [0.3855351957555764, 9.98206834074695]]\n",
      "[[0.0, 1.0], [0.0, 1.0]]\n"
     ]
    }
   ],
   "source": [
    "model.clean(inputs, data, _setattr=True)\n",
    "\n",
    "print(model.minmax)\n",
    "print([[np.min(model.inputs[:, 0]), np.max(model.inputs[:, 0])], [np.min(model.inputs[:, 1]), np.max(model.inputs[:, 1])]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "To train on a percentage (i.e., (0, 1) fraction) of the dataset selected randomly,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = model.clean(inputs, data, train=0.8, _setattr=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anticipating New Data\n",
    "\n",
    "If it is expected that future evaluations of the model will be done at inputs beyond what the training set contains, the normalization [min, max] bounds may be expanded in a couple ways.\n",
    "\n",
    "Most simply, [min, max] may be specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1, 12], [0, 10]]\n",
      "[[0.07692307692307693, 0.8461538461538461], [0.03855351957555764, 0.998206834074695]]\n"
     ]
    }
   ],
   "source": [
    "model.clean(inputs, data, minmax=[[-1, 12], [0, 10]], _setattr=True)  # expand bounds of first input variable\n",
    "\n",
    "print(model.minmax)\n",
    "print([[np.min(model.inputs[:, 0]), np.max(model.inputs[:, 0])], [np.min(model.inputs[:, 1]), np.max(model.inputs[:, 1])]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A pillow buffer may also be specified. The pillow may either be as a percent of the max-min span (default),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2.3, 14.6], [0, 10]]\n",
      "[[0.13609467455621302, 0.727810650887574], [0.03855351957555764, 0.998206834074695]]\n"
     ]
    }
   ],
   "source": [
    "model.clean(inputs, data, pillow=[[0.1, 0.2], [0, 0]], _setattr=True)  # 10% of span added below min; 20% of span added above max\n",
    "\n",
    "print(model.minmax)\n",
    "print([[np.min(model.inputs[:, 0]), np.max(model.inputs[:, 0])], [np.min(model.inputs[:, 1]), np.max(model.inputs[:, 1])]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, the pillow may be the values to which [min, max] will map when placed on a 0-1 scale by setting ```pillow_type='absolute'```, with the upper value being the distance less than 1,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4.7142857142857135, 19.428571428571423], [0, 10]]\n",
      "[[0.1952662721893491, 0.6094674556213019], [0.03855351957555764, 0.998206834074695]]\n"
     ]
    }
   ],
   "source": [
    "model.clean(inputs, data, pillow=[[0.1, 0.2], [0, 0]], pillow_type='absolute', _setattr=True)  # inputs map to [0.1, 0.8] \n",
    "\n",
    "print(model.minmax)\n",
    "print([[np.min(model.inputs[:, 0]), np.max(model.inputs[:, 0])], [np.min(model.inputs[:, 1]), np.max(model.inputs[:, 1])]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## New Data\n",
    "\n",
    "Often it is the case that new data must be formatted and normalized according to the previous [min, max] bounds. To achieve this,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.21183432 0.42      ]\n",
      " [0.5556213  0.6       ]\n",
      " [0.37337278 0.85      ]]\n"
     ]
    }
   ],
   "source": [
    "model.clean([[0.4, 8.7, 4.3], [4.2, 6, 8.5]], _setattr=True)\n",
    "\n",
    "print(model.inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, if normalization has already been applied to the new data somehow and all that is desired is the automatic formatting,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.4 4.2]\n",
      " [8.7 6. ]\n",
      " [4.3 8.5]]\n"
     ]
    }
   ],
   "source": [
    "model.clean([[0.4, 8.7, 4.3], [4.2, 6, 8.5]], normalize=False, _setattr=True)\n",
    "\n",
    "print(model.inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, if simply wishing to format any dataset (e.g., Pandas) into an $[n \\times m]$ ndarray of $n$ datapoints and $m$ input variables, where $n \\gt m$,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original dataset:\n",
      "      A    B    C\n",
      "x0  0.4  8.7  4.3\n",
      "x1  4.2  6.0  8.5\n",
      "\n",
      "Dataset automatically formatted:\n",
      "[[0.4 4.2]\n",
      " [8.7 6. ]\n",
      " [4.3 8.5]]\n",
      "\n",
      "Formatted dataset automatically normalized:\n",
      "[[0.         0.        ]\n",
      " [1.         0.41860465]\n",
      " [0.46987952 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "\n",
    "pd_data = np.array([[0.4, 8.7, 4.3], [4.2, 6, 8.5]])    # example data\n",
    "pd_rows = ['x0', 'x1']                                  # example input variables\n",
    "pd_cols = ['A', 'B', 'C']                               # example instances\n",
    "pd_dataset = pd.DataFrame(pd_data, pd_rows, pd_cols)    # example Pandas dataset\n",
    "\n",
    "print(\"Original dataset:\")\n",
    "print(pd_dataset)\n",
    "\n",
    "# ------------------------\n",
    "\n",
    "formatted_dataset = model.clean(pd_dataset, normalize=False)\n",
    "\n",
    "print(\"\\nDataset automatically formatted:\")\n",
    "print(formatted_dataset)\n",
    "\n",
    "# ------------------------\n",
    "\n",
    "del model.minmax  # delete 'model.minmax' since previously defined and 'model.clean(..., minmax=None)' in next line, because will normalize to these bounds instead of this dataset's [min, max]\n",
    "normalized_dataset = model.clean(formatted_dataset)  # use 'copy.copy(formatted_dataset)' if not wanting to overwrite 'formatted_dataset'\n",
    "\n",
    "print(\"\\nFormatted dataset automatically normalized:\")\n",
    "print(normalized_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if $m \\gt n$ (i.e., more input variables than instances), then be careful that ndarray is aligned accordingly. In this case, use ```AutoTranspose=False``` to preserve shape of original dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original dataset:\n",
      "    x0   x1   x2\n",
      "A  0.4  8.7  4.3\n",
      "B  4.2  6.0  8.5\n",
      "\n",
      "Dataset automatically formatted (with 'AutoTranspose=False'):\n",
      "[[0.4 8.7 4.3]\n",
      " [4.2 6.  8.5]]\n"
     ]
    }
   ],
   "source": [
    "pd_rows = ['A', 'B']                                    # example instances\n",
    "pd_cols = ['x0', 'x1', 'x2']                            # example input variables\n",
    "pd_dataset = pd.DataFrame(pd_data, pd_rows, pd_cols)    # example Pandas dataset\n",
    "\n",
    "print(\"Original dataset:\")\n",
    "print(pd_dataset)\n",
    "\n",
    "# ------------------------\n",
    "\n",
    "print(\"\\nDataset automatically formatted (with 'AutoTranspose=False'):\")\n",
    "print(model.clean(pd_dataset, normalize=False, AutoTranspose=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use in fit and evaluate\n",
    "\n",
    "To use ```clean``` in ```fit``` and ```evaluate```, simply pass keywords into the function arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 516.4569658211133]\n",
      "[2, 520.159812063613]\n",
      "[2, -290.6191339183991]\n",
      "[3, -290.6191339183991]\n",
      "[3, -294.49749627594406]\n",
      "[4, -294.49749627594406]\n",
      "[4, -294.49749627594406]\n",
      "[4, -627.0731883323994]\n",
      "[5, -629.6514332306951]\n",
      "[5, -629.6514332306951]\n",
      "[5, -674.9013524524032]\n",
      "[6, -674.9013524524032]\n",
      "[6, -674.9013524524032]\n",
      "[6, -674.9013524524032]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.0782948  80.90772144 27.62729274]\n"
     ]
    }
   ],
   "source": [
    "del model.minmax  # delete 'model.minmax' since previously defined and 'model.clean(..., minmax=None)' in next line, because will normalize to these bounds instead of this dataset's [min, max]\n",
    "\n",
    "model.fit(inputs, data, clean=True, pillow=[[0.1, 0.2], [0, 0]], pillow_type='absolute')\n",
    "model.coverage3(plot=True, xaxis=0)  # validation plot\n",
    "\n",
    "print(model.evaluate([[0.4, 8.7, 4.3], [4.2, 6, 8.5]], clean=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note in typical use, ```del model.minmax``` should not be needed. It is expected that the normalization 'minmax' bounds will only need to be defined once when first calling ```clean```. The only reason ```del model.minmax``` was used in this tutorial was to showcase the flexible ways ```clean``` behaves when first being called (i.e., before ```model.minmax``` is defined). For thoroughness, if ```minmax``` is defined in the ```clean``` function argument, ```model.minmax``` gets overrided; though, there is likely not a typical use case for this."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}