tutorials/Part 07 - Building a dataset for the distinguisher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional Encryption - Classification and information leakage\n",
    "\n",
    "Next part, we will set a distinguishabilty task. We will need **a dataset with a fixed digit for the distinguisher**. Therefore we use the same code than in part 1 but set digit to be 6, as it is a fairly representative one of average difficulty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Build the dataset\n",
    "\n",
    "But first, let's build the dataset!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from string import ascii_lowercase\n",
    "from scipy.ndimage.interpolation import map_coordinates\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "import torch.utils.data as utils\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Fonts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "digit = 5\n",
    "families = ['cursive', 'Georgia']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here what they look like!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,2))\n",
    "for i, family in enumerate(families):\n",
    "    ax = plt.subplot(1, 5, i+1)\n",
    "    ax.set_title(family)\n",
    "    ax.text(0.3, 0.4, '123', size=50, family=family)\n",
    "\n",
    "    # Rm axes, draw and get the rgba shape of the digits\n",
    "    plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Noising process\n",
    "Our dataset is artificial. Hence we need to add some noise to make it more interesting for a classification task.\n",
    "Currently the noise boils down to:\n",
    "\n",
    " - A random but moderate rotation\n",
    " - A random but moderation size variation\n",
    " - A deformation using a Gaussian filter\n",
    "\n",
    "When we are done, we recenter the data (as it is done for MNIST).\n",
    "\n",
    "Let's do it for one character to see how it looks like!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utils functions to handle rgb / rgba conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rgba_to_rgb(rgba):\n",
    "        if rgba[0] > 0:\n",
    "            return np.ones(3) * (256 - rgba[0])\n",
    "        return rgba[1:]\n",
    "    \n",
    "def convert_to_rgb(data):\n",
    "    return np.apply_along_axis(rgba_to_rgb, 2, data) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deformation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def elastic_transform(image, alpha, sigma, random_state=None):\n",
    "    \"\"\"Elastic deformation of images as described in [Simard2003]_.\n",
    "    .. [Simard2003] Simard, Steinkraus and Platt, \"Best Practices for\n",
    "       Convolutional Neural Networks applied to Visual Document Analysis\", in\n",
    "       Proc. of the International Conference on Document Analysis and\n",
    "       Recognition, 2003.\n",
    "    \"\"\"\n",
    "    if random_state is None:\n",
    "        random_state = np.random.RandomState(None)\n",
    "\n",
    "    shape = image.shape\n",
    "    dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=\"constant\", cval=0) * alpha\n",
    "    dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=\"constant\", cval=0) * alpha\n",
    "    dz = np.zeros_like(dx)\n",
    "\n",
    "    x, y, z = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), np.arange(shape[2]))\n",
    "    indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1)), np.reshape(z, (-1, 1))\n",
    "\n",
    "    distored_image = map_coordinates(image, indices, order=1, mode='reflect')\n",
    "    return distored_image.reshape(image.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recentering function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def center(data):\n",
    "    # Inverse black and white\n",
    "    wb_data = np.ones(data.shape) * 255 - data\n",
    "    \n",
    "    # normalize\n",
    "    prob_data = wb_data / np.sum(wb_data)\n",
    "    \n",
    "    # marginal distributions\n",
    "    dx = np.sum(prob_data, (1, 2))\n",
    "    dy = np.sum(prob_data, (0, 2))\n",
    "\n",
    "    # expected values\n",
    "    (X, Y, Z) = prob_data.shape\n",
    "    cx = np.sum(dx * np.arange(X))\n",
    "    cy = np.sum(dy * np.arange(Y))\n",
    "    \n",
    "    # Check bounds\n",
    "    assert cx > X/4 and cx < 3 * X/4, f\"ERROR: {cx} > {X/4} and {cx} < {3 * X/4}\"\n",
    "    assert cy > Y/4 and cy < 3 * Y/4, f\"ERROR: {cy} > {Y/4} and {cy} < {3 * Y/4}\"\n",
    "    \n",
    "    # print('Center', cx, cy)\n",
    "    \n",
    "    x_min = int(round(cx - X/4))\n",
    "    x_max = int(round(cx + X/4))\n",
    "    y_min = int(round(cy - Y/4))\n",
    "    y_max = int(round(cy + Y/4))\n",
    "    \n",
    "    return data[x_min:x_max, y_min:y_max, :]\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One first example!\n",
    "Ok let's how it looks like!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sample a rotation angle\n",
    "rotation = np.random.normal(0, 10) # 10 degrees (out of 180)\n",
    "# Sample a text size +/- 5% in std\n",
    "size = 100 + np.random.normal(0, 5) \n",
    "# Sample a family\n",
    "family_idx = np.random.randint(len(families))\n",
    "family = families[family_idx]\n",
    "\n",
    "letter = str(digit)\n",
    "\n",
    "# Show rotated letter\n",
    "fig = plt.figure(figsize=(2,2), dpi=100)\n",
    "fig.text(0.4, 0.4, letter, size=size, rotation=rotation, family=family)\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "plt.close(fig)\n",
    "\n",
    "# Load the letter in smaller size\n",
    "fig = plt.figure(figsize=(2,2), dpi=100)\n",
    "fig.text(0.4, 0.4, letter, size=50, rotation=rotation, family=family)\n",
    "\n",
    "# Rm axes, draw and get the rgba shape of the letter\n",
    "plt.axis('off')\n",
    "fig.canvas.draw()\n",
    "data = np.frombuffer(fig.canvas.tostring_argb(), dtype=np.uint8)\n",
    "data = data.reshape(fig.canvas.get_width_height()[::-1] + (4,))\n",
    "plt.close(fig)\n",
    "# Convert to rgb\n",
    "data = convert_to_rgb(data)\n",
    "\n",
    "# Re-center the data\n",
    "data = center(data)\n",
    "\n",
    "plt.show()\n",
    "plt.axis('off')\n",
    "plt.imshow(data)\n",
    "plt.show()\n",
    "\n",
    "# Apply an elastic deformation\n",
    "data = elastic_transform(data, alpha=1100, sigma=7) # 991; 9\n",
    "\n",
    "plt.axis('off')\n",
    "plt.imshow(data)\n",
    "plt.show()\n",
    "\n",
    "# Free memory space\n",
    "plt.close(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the images here are provided with high resolution, they will then be converted to 28x28 pixels and will becomes way harder to analyse.\n",
    "\n",
    "Feel free to change the rotation std, the text size std, and the `alpha` and `sigma` parameters in the deformation. You'll see that the task can be made incredibly harder!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building the dataset\n",
    "Ok now we are equipped to build a complete dataset!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We define a variance parameter for rotation and one for text size\n",
    "std_rotation = 10\n",
    "std_size = 2.5 # 5% of reference size, here 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test\n",
      "0 %\n",
      "1 %\n",
      "2 %\n",
      "3 %\n",
      "4 %\n",
      "5 %\n",
      "6 %\n",
      "7 %\n",
      "8 %\n",
      "9 %\n",
      "10 %\n",
      "11 %\n",
      "12 %\n",
      "13 %\n",
      "14 %\n",
      "15 %\n",
      "16 %\n",
      "17 %\n",
      "18 %\n",
      "19 %\n",
      "20 %\n",
      "21 %\n",
      "22 %\n",
      "23 %\n",
      "24 %\n",
      "25 %\n",
      "26 %\n",
      "27 %\n",
      "28 %\n",
      "29 %\n",
      "30 %\n",
      "31 %\n",
      "32 %\n",
      "33 %\n",
      "34 %\n",
      "35 %\n",
      "36 %\n",
      "37 %\n",
      "38 %\n",
      "39 %\n",
      "40 %\n",
      "41 %\n",
      "42 %\n",
      "43 %\n",
      "44 %\n",
      "45 %\n",
      "46 %\n",
      "47 %\n",
      "48 %\n",
      "49 %\n",
      "50 %\n",
      "51 %\n",
      "52 %\n",
      "53 %\n",
      "54 %\n",
      "55 %\n",
      "56 %\n",
      "57 %\n",
      "58 %\n",
      "59 %\n",
      "60 %\n",
      "61 %\n",
      "62 %\n",
      "63 %\n",
      "64 %\n",
      "65 %\n",
      "66 %\n",
      "67 %\n",
      "68 %\n",
      "69 %\n",
      "70 %\n",
      "71 %\n",
      "72 %\n",
      "73 %\n",
      "74 %\n",
      "75 %\n",
      "76 %\n",
      "77 %\n",
      "78 %\n",
      "79 %\n",
      "80 %\n",
      "81 %\n",
      "82 %\n",
      "83 %\n",
      "84 %\n",
      "85 %\n",
      "86 %\n",
      "87 %\n",
      "88 %\n",
      "89 %\n",
      "90 %\n",
      "91 %\n",
      "92 %\n",
      "93 %\n",
      "94 %\n",
      "95 %\n",
      "96 %\n",
      "97 %\n",
      "98 %\n",
      "99 %\n"
     ]
    }
   ],
   "source": [
    "#%%time\n",
    "def build_dataset(dataset_size, digit, verbose=False):\n",
    "    dataset_data = []\n",
    "    dataset_target_char = []\n",
    "    dataset_target_family = []\n",
    "    for i in range(dataset_size):\n",
    "        if i % int(dataset_size/100) == 0:\n",
    "            print(round(i / dataset_size * 100), '%')\n",
    "        rotation = np.random.normal(0, std_rotation)\n",
    "        size = 50 + np.random.normal(0, std_size) \n",
    "        family_idx = np.random.randint(len(families))\n",
    "        family = families[family_idx]\n",
    "        digit = digit #np.random.randint(10)\n",
    "        letter = str(digit)\n",
    "\n",
    "        fig = plt.figure(figsize=(2,2), dpi=28)\n",
    "        fig.text(0.4, 0.4, letter, size=size, rotation=rotation, family=family)\n",
    "\n",
    "        # Rm axes, draw and get the rgba shape of the letter\n",
    "        plt.axis('off')\n",
    "        fig.canvas.draw()\n",
    "        data = np.frombuffer(fig.canvas.tostring_argb(), dtype=np.uint8)\n",
    "        data = data.reshape(fig.canvas.get_width_height()[::-1] + (4,))\n",
    "\n",
    "        # Convert to rgb\n",
    "        data = convert_to_rgb(data)\n",
    "\n",
    "        # Center the data\n",
    "        data = center(data)[:28, :28, :]\n",
    "\n",
    "        if verbose:\n",
    "            plt.show()\n",
    "            plt.axis('off')\n",
    "            plt.imshow(data)\n",
    "            plt.show()\n",
    "            \n",
    "        # Apply an elastic deformation\n",
    "        data = elastic_transform(data, alpha=991, sigma=9)\n",
    "\n",
    "        if verbose:\n",
    "            plt.axis('off')\n",
    "            plt.imshow(data)\n",
    "            plt.show()\n",
    "\n",
    "        # Free memory space\n",
    "        plt.close(fig)\n",
    "\n",
    "        # Append data to the datasets\n",
    "        target_char = np.array([digit])\n",
    "        target_family = np.array([family_idx])\n",
    "        dataset_data.append(data[:,:,0])\n",
    "        dataset_target_char.append(target_char)\n",
    "        dataset_target_family.append(target_family)\n",
    "        \n",
    "    return dataset_data, dataset_target_char, dataset_target_family\n",
    "\n",
    "def save_dataset(info, data, target_char, target_family):\n",
    "    with open('dataset/character_dataset_{}_{}_{}.pkl'.format('_'.join(families), digit, info), 'wb') as output:\n",
    "        dataset = data, target_char, target_family\n",
    "        pickle.dump(dataset, output, pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "# We build 10000 per 10000 for memory purposes\n",
    "# WARNING: This step takes time, and you may need to restart you notebook for memory purposes.\n",
    "for i in range(0):\n",
    "    print(f\"Train{i}\")\n",
    "    train_data, train_target_char, train_target_family = build_dataset(10000, digit)\n",
    "    save_dataset(f\"train{i}\", train_data, train_target_char, train_target_family)\n",
    "    \n",
    "print(\"Test\")\n",
    "test_data, test_target_char, test_target_family = build_dataset(10000, digit)\n",
    "save_dataset(\"test\", test_data, test_target_char, test_target_family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok we now have our dataset! Let's use it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Appendix\n",
    "Here is an utility function to draw some samples of the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set 60000 items\n",
      "Testing set  10000 items\n"
     ]
    }
   ],
   "source": [
    "# Allow to load packages from parent\n",
    "import sys, os\n",
    "sys.path.insert(1, os.path.realpath(os.path.pardir))\n",
    "import random, math\n",
    "from learn import collateral\n",
    "data = collateral.data.load_collateral_data(\"cursive\", \"Georgia\", \"6\")\n",
    "train_data, train_target_char, train_target_family, test_data, test_target_char, test_target_family = data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x864 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def show_examples(data, target_char, target_family, n_examples=20):\n",
    "    n_rows = math.ceil(n_examples / 5)\n",
    "    plt.figure(figsize=(14, 3*n_rows))\n",
    "    for i in range(n_examples):\n",
    "        ax = plt.subplot(n_rows, 5, i+1)\n",
    "        idx = random.randint(0, len(data))\n",
    "        image = data[idx]\n",
    "        letter = str([target_char[idx][0]])\n",
    "        family = families[target_family[idx][0]]\n",
    "        ax.set_title(f\"{letter} ({family})\")\n",
    "        plt.axis('off')\n",
    "        ax.imshow(image, cmap='gist_gray')\n",
    "    plt.show()\n",
    "        \n",
    "        \n",
    "show_examples(test_data, test_target_char, test_target_family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It now much harder to distinguish the fonts, isn't it?!\n",
    "\n",
    "Ok let's use this dataset to start out work!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### If you like it, star it!\n",
    "\n",
    "The easiest way to show support is just by starring the Repos! This helps raise awareness on this topics and is a precious feedback for the repo maintainers!\n",
    "\n",
    "- [Star the Repo](https://github.com/LaRiffle/collateral-learning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}