example-preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ignite ML Preprocessing!\n",
    "\n",
    "This document contains example of Ignite ML Preprocessing Python API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_regression\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.datasets import make_blobs\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets prepare a classification dataset using scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x, y = make_classification()\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Normalization preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ignite_ml.preprocessing import NormalizationTrainer\n",
    "normalizer = NormalizationTrainer().fit(x_train)\n",
    "\n",
    "# Just to test.\n",
    "x_test_normalized = normalizer.transform(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without normalization: 0.880000\n",
      "With normalization: 0.880000\n"
     ]
    }
   ],
   "source": [
    "from ignite_ml.classification import DecisionTreeClassificationTrainer\n",
    "trainer = DecisionTreeClassificationTrainer()\n",
    "model_without_normalization = trainer.fit(x_train, y_train)\n",
    "model_with_normalization = trainer.fit(x_train, y_train, normalizer)\n",
    "\n",
    "print(\"Without normalization: %f\" % accuracy_score(\n",
    "    y_test, \n",
    "    model_without_normalization.predict(x_test)\n",
    "))\n",
    "print(\"With normalization: %f\" % accuracy_score(\n",
    "    y_test, \n",
    "    model_with_normalization.predict(x_test_normalized)\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Binarization preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 0., 1., 0., 1., 0., 0., 1., 1.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ignite_ml.preprocessing import BinarizationTrainer\n",
    "binarizer = BinarizationTrainer(threshold=0.5).fit([[]])\n",
    "\n",
    "binarizer.transform(np.random.rand(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Imputing preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.5, 4. , 5. ],\n",
       "       [4. , 1.5, 5. ],\n",
       "       [4. , 5. , 1.5]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ignite_ml.preprocessing import ImputerTrainer\n",
    "imputer = ImputerTrainer().fit([[1, 1, 1], [2, 2, 2]])\n",
    "imputer.transform([\n",
    "    [None, 4, 5],\n",
    "    [4, None, 5],\n",
    "    [4, 5, None]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 One hot encoding preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 1.],\n",
       "       [0., 1., 0.],\n",
       "       [1., 0., 1.],\n",
       "       [0., 1., 0.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ignite_ml.preprocessing import EncoderTrainer\n",
    "encoder = EncoderTrainer(encoded_features=[0]).fit([\n",
    "    [42],\n",
    "    [43],\n",
    "    [42],\n",
    "    [43]\n",
    "])\n",
    "encoder.transform([\n",
    "    [42],\n",
    "    [43],\n",
    "    [42],\n",
    "    [43]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 String encoding preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6 MinMax scaling preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0. , 0. ],\n",
       "       [0.5, 0.5, 0.5],\n",
       "       [1. , 1. , 1. ]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ignite_ml.preprocessing import MinMaxScalerTrainer\n",
    "scaler = MinMaxScalerTrainer().fit([[1, 1, 1], [2, 2, 2]])\n",
    "scaler.transform([\n",
    "    [1, 1, 1],\n",
    "    [1.5, 1.5, 1.5],\n",
    "    [2, 2, 2]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.7 MaxAbs scaling preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5 , 0.5 , 0.5 ],\n",
       "       [0.75, 0.75, 0.75],\n",
       "       [1.  , 1.  , 1.  ]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ignite_ml.preprocessing import MaxAbsScalerTrainer\n",
    "scaler = MaxAbsScalerTrainer().fit([[1, 1, 1], [2, 2, 2]])\n",
    "scaler.transform([\n",
    "    [1, 1, 1],\n",
    "    [1.5, 1.5, 1.5],\n",
    "    [2, 2, 2]\n",
    "])"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}