dvrl/main_dvrl_image_transfer_learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright 2019 The Google Research Authors.\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "you may not use this file except in compliance with the License.\n",
    "You may obtain a copy of the License at\n",
    "\n",
    "     http://www.apache.org/licenses/LICENSE-2.0\n",
    "\n",
    "Unless required by applicable law or agreed to in writing, software\n",
    "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "See the License for the specific language governing permissions and\n",
    "limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DVRL for Corrupted Sample Discovery and Robust Learning with Transfer Learning on Image Data\n",
    "\n",
    " * Jinsung Yoon, Sercan O Arik, Tomas Pfister, \"Data Valuation using Reinforcement Learning\", arXiv preprint arXiv:1909.11671 (2019) - https://arxiv.org/abs/1909.11671\n",
    "\n",
    "This notebook describes the user-guide of corrupted sample discovery and robust learning **with transfer learning on image data** applications using \"Data Valuation using Reinforcement Learning (DVRL)\". We use Inception-v3 model (pre-trained on Imagenet dataset (http://www.image-net.org/)) as the encoder model to encode image data.\n",
    "\n",
    "There are some scenarios where training samples may contain corrupted samples, e.g. due to cheap label collection methods. An automated corrupted sample discovery method would be highly beneficial for distinguishing samples with clean vs. noisy labels. Data valuation can be used in this setting by having a small clean validation set to assign low data values to the potential samples with noisy labels. With an optimal data value estimator, all noisy labels would get the lowest data values. \n",
    "\n",
    "DVRL can also reliably learn with noisy data in an end-to-end way. Ideally, noisy samples should get low data values as DVRL converges and a high performance model can be returned.\n",
    "\n",
    "You need:\n",
    "\n",
    "**Training set** (low-quality data (e.g. noisy data)) / **Validation set** (high-quality data (e.g. clean data)) / **Testing set** (high-quality data (e.g. clean data)) \n",
    " * If there is no explicit validation set, you can split a small portion of testing set as the validation set. \n",
    " * Note that training set does not have to be low quality for DVRL; however, in this notebook, we use a low quality training set for a clearer demonstration as the samples are easier to distinguish in terms of their values.\n",
    " * If you have your own training / validation / testing datasets, you can put them under './repo/data_files/' directory with 'train.npz', 'valid.npz', 'test.npz' names.\n",
    " * In this notebook, we use CIFAR10 and CIFAR100 datasets (https://www.cs.toronto.edu/~kriz/cifar.html) as examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisite\n",
    "\n",
    "Clone https://github.com/google-research/google-research.git to the current directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from git import Repo\n",
    "\n",
    "# Current working directory\n",
    "repo_dir = os.getcwd() + '/repo'\n",
    "\n",
    "if not os.path.exists(repo_dir):\n",
    "    os.makedirs(repo_dir)\n",
    "\n",
    "# Clones github repository\n",
    "if not os.listdir(repo_dir):\n",
    "    git_url = \"https://github.com/google-research/google-research.git\"\n",
    "    Repo.clone_from(git_url, repo_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Necessary packages and functions call\n",
    "\n",
    " * data_loading: Data loader for image datasets (cifar10 or cifar100 datasets)\n",
    " * keras: Basic packages for defining encoder model and predictor model\n",
    " * dvrl: Data valuation model\n",
    " * dvrl_metrics: Metrics to evaluate the quality of data valuation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from dvrl import data_loading, dvrl, dvrl_metrics\n",
    "\n",
    "import keras\n",
    "from keras import applications, layers, models\n",
    "\n",
    "# Sets current directory\n",
    "os.chdir(repo_dir)\n",
    "\n",
    "import numpy as np\n",
    "from sklearn import linear_model\n",
    "import tensorflow as tf\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data loading & Sample corruption\n",
    "\n",
    " * Create training, validation and testing sets from the image datasets and save them as train.npz, valid.npz, test.npz under './repo/data_files/ directory.\n",
    " * If you have your own train.npz, valid.npz, test.npz, just save them '.repo/data_files/' directory and you can skip this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished data loading.\n"
     ]
    }
   ],
   "source": [
    "# Data name: 'cifar10' or 'cifar100' in this notebook\n",
    "data_name = 'cifar10'\n",
    "\n",
    "# The number of training, validation and testing samples\n",
    "dict_no = dict()\n",
    "dict_no['train'] = 4000\n",
    "dict_no['valid'] = 1000\n",
    "dict_no['test'] = 2000\n",
    "\n",
    "# Label noise ratio\n",
    "noise_rate = 0.2\n",
    "\n",
    "# Loads data and corrupts labels\n",
    "noise_idx = data_loading.load_image_data(data_name, dict_no, noise_rate)\n",
    "# noise_idx: ground truth noisy label indices\n",
    "\n",
    "print('Finished data loading.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data preprocessing\n",
    "\n",
    " * Extract features and labels from train.npz, valid.npz, test.npz in './repo/data_files/' directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished data preprocess.\n"
     ]
    }
   ],
   "source": [
    "# Extracts features and labels. \n",
    "x_train, y_train, x_valid, y_valid, x_test, y_test = \\\n",
    "data_loading.load_image_data_from_file('train.npz', 'valid.npz', 'test.npz')\n",
    "\n",
    "print('Finished data preprocess.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encode images\n",
    "\n",
    " * Use encoder model (in this notebook, Inception-v3 pre-trained on Imagenet dataset), we encodes the training, validation, and testing images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "250/250 [==============================] - 328s 1s/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception ignored in: <function BaseSession._Callable.__del__ at 0x7fa61201cf28>\n",
      "Traceback (most recent call last):\n",
      "  File \"/usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/client/session.py\", line 1455, in __del__\n",
      "    self._session._session, self._handle, status)\n",
      "  File \"/usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/framework/errors_impl.py\", line 528, in __exit__\n",
      "    c_api.TF_GetCode(self.status.status))\n",
      "tensorflow.python.framework.errors_impl.CancelledError: Session has been closed.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63/62 [==============================] - 85s 1s/step\n",
      "125/125 [==============================] - 86s 691ms/step\n",
      "Finished data encoding\n"
     ]
    }
   ],
   "source": [
    "# Encodes samples\n",
    "# The preprocessing function used on the pre-training dataset is also applied while encoding the inputs.\n",
    "preprocess_function = applications.inception_v3.preprocess_input\n",
    "input_shape = (299, 299)\n",
    "\n",
    "# Defines the encoder model to learn the representations for image dataset. In this example, we are considering the InceptionV3 model trained on\n",
    "# ImageNet dataset, followed by simple average pooling-based downsampling.\n",
    "\n",
    "def encoder_model(architecture='inception_v3', pre_trained_dataset='imagenet', downsample_factor=8):\n",
    "    \"\"\"Returns encoder model.\n",
    "\n",
    "    Args:\n",
    "      architecture: Base architecture of encoder model (e.g. 'inception_v3')\n",
    "      pre_trained_dataset: The dataset used to pre-train the encoder model\n",
    "      downsample_factor: Downsample factor for the outputs\n",
    "    \"\"\"\n",
    "    tf_input = layers.Input(shape=(input_shape[0], input_shape[1], 3))\n",
    "    if architecture == 'inception_v3':\n",
    "        model = applications.inception_v3.InceptionV3(\n",
    "            input_tensor=tf_input, weights=pre_trained_dataset, include_top=False)\n",
    "        output_pooled = layers.AveragePooling2D((downsample_factor, downsample_factor),\n",
    "                                                strides=(downsample_factor, downsample_factor))(model.output)\n",
    "    return models.Model(model.input, output_pooled)\n",
    "\n",
    "# Encodes training samples\n",
    "enc_x_train = data_loading.encode_image(x_train, encoder_model, input_shape, preprocess_function)\n",
    "# Encodes validation samples\n",
    "enc_x_valid = data_loading.encode_image(x_valid, encoder_model, input_shape, preprocess_function)\n",
    "# Encodes testing samples\n",
    "enc_x_test = data_loading.encode_image(x_test, encoder_model, input_shape, preprocess_function)\n",
    "\n",
    "print('Finished data encoding')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run DVRL\n",
    "\n",
    "1. **Input**: \n",
    "\n",
    " * data valuator network parameters: Set network parameters of data valuator.\n",
    " * pred_model: The predictor model that maps output from the input. Any machine learning model (e.g. a neural network or ensemble decision tree) can be used as the predictor model, as long as it has fit, and predict (for regression)/predict_proba (for classification) as its subfunctions. Fit can be implemented using multiple backpropagation iterations.\n",
    " \n",
    " \n",
    "2. **Output**:\n",
    " * data_valuator: Function that uses training set as inputs to estimate data values\n",
    " * dvrl_predictor: Function that predicts labels of the testing samples\n",
    " * dve_out: Estimated data values for all training samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception ignored in: <function BaseSession._Callable.__del__ at 0x7fa61201cf28>\n",
      "Traceback (most recent call last):\n",
      "  File \"/usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/client/session.py\", line 1455, in __del__\n",
      "    self._session._session, self._handle, status)\n",
      "  File \"/usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/framework/errors_impl.py\", line 528, in __exit__\n",
      "    c_api.TF_GetCode(self.status.status))\n",
      "tensorflow.python.framework.errors_impl.CancelledError: Session has been closed.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [29:39<00:00,  1.73s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished dvrl training.\n",
      "WARNING:tensorflow:From /usr/local/google/home/jinsungyoon/anaconda3/lib/python3.7/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./tmp/model.ckpt\n",
      "Finished data valuation.\n"
     ]
    }
   ],
   "source": [
    "# Resets the graph\n",
    "tf.reset_default_graph()\n",
    "keras.backend.clear_session()\n",
    "\n",
    "# Network parameters\n",
    "parameters = dict()\n",
    "parameters['hidden_dim'] = 100\n",
    "parameters['comb_dim'] = 10\n",
    "parameters['iterations'] = 1000\n",
    "parameters['activation'] = tf.nn.relu\n",
    "parameters['layer_number'] = 5\n",
    "parameters['batch_size'] = 2000\n",
    "parameters['learning_rate'] = 0.01\n",
    "parameters['inner_iterations'] = 100\n",
    "parameters['batch_size_predictor'] = 256\n",
    "\n",
    "# Sets checkpoint file name\n",
    "checkpoint_file_name = './tmp/model.ckpt'\n",
    "\n",
    "# Defines predictive model\n",
    "problem = 'classification'\n",
    "\n",
    "pred_model = keras.models.Sequential()\n",
    "pred_model.add(keras.layers.Dense(len(set(y_train)), activation='softmax'))\n",
    "pred_model.compile(optimizer='adam', loss='categorical_crossentropy',\n",
    "                   metrics=['accuracy'])\n",
    "\n",
    "# Flags for using stochastic gradient descent / pre-trained model\n",
    "flags = {'sgd': True, 'pretrain': False}\n",
    "\n",
    "# Initalizes DVRL\n",
    "dvrl_class = dvrl.Dvrl(enc_x_train, y_train, enc_x_valid, y_valid, \n",
    "                       problem, pred_model, parameters, checkpoint_file_name, flags)\n",
    "\n",
    "# Trains DVRL\n",
    "dvrl_class.train_dvrl('accuracy')\n",
    "\n",
    "print('Finished DVRL training.')\n",
    "\n",
    "# Estimates data values\n",
    "dve_out = dvrl_class.data_valuator(enc_x_train, y_train)\n",
    "\n",
    "# Predicts with DVRL\n",
    "y_test_hat = dvrl_class.dvrl_predictor(enc_x_test)\n",
    "\n",
    "print('Finished data valuation.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluations\n",
    "\n",
    " * In this notebook, we use Logistic Regression (on top of Inception-v3) as the predictive model in DVRL (but we can also replace it with another method for evaluation purposes.\n",
    " * Here, we use average accuracy as the performance metric (we can also replace with other metrics, see metrics.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Robust learning\n",
    "\n",
    "DVRL learns robustly although the training data contains low quality/noisy samples, using the guidance from the high quality/clean validation data via reinforcement learning.\n",
    " * Train predictive model with weighted optimization using estimated data values by DVRL as the weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DVRL-weighted learning performance: 0.8325\n"
     ]
    }
   ],
   "source": [
    "# Defines evaluation model\n",
    "eval_model = linear_model.LogisticRegression(solver='lbfgs', multi_class='auto', max_iter=200)\n",
    "\n",
    "# Robust learning (DVRL-weighted learning)\n",
    "robust_perf = dvrl_metrics.learn_with_dvrl(dve_out, eval_model, enc_x_train, y_train, \n",
    "                                           enc_x_valid, y_valid, enc_x_test, y_test, 'accuracy')\n",
    "\n",
    "print('DVRL-weighted learning performance: ' + str(np.round(robust_perf, 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Removing high/low valued samples\n",
    "\n",
    "Removing low value samples from the training dataset can improve the predictor model performance, especially in the cases where the training dataset contains corrupted samples. On the other\n",
    "hand, removing high value samples, especially if the dataset is small, would decrease the performance significantly. Overall, the performance after removing high/low value samples is a strong\n",
    "indicator for the quality of data valuation.\n",
    "\n",
    "DVRL can rank the training data samples according to their estimated data value, and **by removing the low value samples we can improve performance, whereas removing the high value samples degrades the performance**.\n",
    "\n",
    " * Train predictive models after removing certain portions of high/low valued training samples\n",
    " * Visualize the results using line graphs (set plot = True).\n",
    " * x-axis: Portions of removed samples\n",
    " * y-axis: Prediction performance (accuracy)\n",
    " * Blue line: Removing low value data, Orange line: Removing high value data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Evaluates performance after removing high/low values\n",
    "remove_high_low_performance = \\\n",
    "dvrl_metrics.remove_high_low(dve_out, eval_model, enc_x_train, y_train, \n",
    "                             enc_x_valid, y_valid, enc_x_test, y_test, 'accuracy', plot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Corrupted sample discovery\n",
    "\n",
    "For our synthetically-generated noisy training dataset, we can assess the performance of our method in finding the noisy samples by using the known noise indices. Note that unlike the first two evaluations, this cell is only for academic purposes because you need the ground truth noisy sample indices so if users come with their own .csv files, they cannot use this cell.\n",
    "\n",
    " * Report True Positive Rates (TPR) of corrupted sample discovery.\n",
    " * Visualize the results using line graphs (set plot = True).\n",
    " * x-axis: Portions of inspected samples.\n",
    " * y-axis: True positive rates (TPR) of corrupted sample discovery.\n",
    " * Blue line: DVRL, Orange line: Optimal, Green line: Random."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x540 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# If noise_rate is positive value.\n",
    "if noise_rate > 0:\n",
    "    \n",
    "    # Evaluates true positive rates (TPR) of corrupted sample discovery and plot TPRs\n",
    "    noise_discovery_performance = \\\n",
    "    dvrl_metrics.discover_corrupted_sample(dve_out, noise_idx, noise_rate, plot = True)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}