5 Image Augmentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install imgaug"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import imageio\n",
    "import numpy as np\n",
    "import imgaug as ia\n",
    "import imgaug.augmenters as iaa\n",
    "from PIL import Image\n",
    "from datetime import datetime\n",
    "from imgaug.augmentables.batches import UnnormalizedBatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_files_in_folder(folder):\n",
    "    files_count = len([name for name in os.listdir(folder) if os.path.isfile(os.path.join(folder, name))])\n",
    "    return(files_count)\n",
    "\n",
    "\n",
    "def save_image(image, folder):\n",
    "    \"\"\"Save an image with unique name\n",
    "\n",
    "    Arguments:\n",
    "        image {Pillow} -- image object to be saved\n",
    "        folder {string} -- output folder\n",
    "    \"\"\"\n",
    "\n",
    "    # check whether the folder exists and create one if not\n",
    "    if not os.path.exists(folder):\n",
    "        os.makedirs(folder)\n",
    "\n",
    "    # to not erase previously saved photos counter (image name) = number of photos in a folder + 1\n",
    "    image_counter = count_files_in_folder(folder)+1\n",
    "\n",
    "    # save image to the dedicated folder (folder name = label)\n",
    "    image_name = folder + '/' + str(image_counter) + '.png'\n",
    "    image.save(image_name)\n",
    "    \n",
    "    \n",
    "def get_files_in_folder(folder):\n",
    "    return [os.path.join(folder, name) for name in os.listdir(folder) if os.path.isfile(os.path.join(folder, name))]\n",
    "\n",
    "\n",
    "def list_oversample(initial_list, max_size):\n",
    "    \"\"\"duplicate a list n times or take a part of a list\n",
    "\n",
    "    Arguments:\n",
    "        initial_list {list} -- array to be resized\n",
    "        max_size {int} -- majority class size\n",
    "    \"\"\"\n",
    "    \n",
    "    resized_array = []\n",
    "    initial_length = len(initial_list)\n",
    "    new_size = max_size - initial_length\n",
    "    if new_size >= initial_length:\n",
    "        augment_rate = int(new_size/initial_length)\n",
    "        resized_array = initial_list*augment_rate\n",
    "    else:\n",
    "        resized_array = initial_list[:new_size]\n",
    "    return resized_array\n",
    "\n",
    "def save_image_array(image_array, folder):\n",
    "    for image in image_array:\n",
    "        save_image(Image.fromarray(image), folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input image\n",
    "IMAGE_FOLDER = 'data_aug'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all subfolders in the initial directory\n",
    "image_subfolders = [os.path.join(IMAGE_FOLDER, subfolder) for subfolder in os.listdir(IMAGE_FOLDER)]\n",
    "# number of instances in the majority class\n",
    "max_image_count = max([count_files_in_folder(subfolder) for subfolder in image_subfolders])\n",
    "# if we don't have any data, set this value manually\n",
    "max_image_count=50\n",
    "image_target_subfolders = [subfolder for subfolder in image_subfolders if count_files_in_folder(subfolder) < max_image_count]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "metadata": {},
     "execution_count": 20
    }
   ],
   "source": [
    "max_image_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set augmenters\n",
    "ia.seed(1)\n",
    "\n",
    "seq = iaa.Sequential([\n",
    "    iaa.Fliplr(0.5), # horizontal flips\n",
    "    iaa.Crop(percent=(0, 0.1)), # random crops\n",
    "    # Small gaussian blur with random sigma between 0 and 0.5.\n",
    "    # But we only blur about 50% of all images.\n",
    "    iaa.Sometimes(\n",
    "        0.5,\n",
    "        iaa.GaussianBlur(sigma=(0, 0.5))\n",
    "    ),\n",
    "    # Strengthen or weaken the contrast in each image.\n",
    "    iaa.LinearContrast((0.75, 1.5)),\n",
    "    # Add gaussian noise.\n",
    "    # For 50% of all images, we sample the noise once per pixel.\n",
    "    # For the other 50% of all images, we sample the noise per pixel AND\n",
    "    # channel. This can change the color (not only brightness) of the\n",
    "    # pixels.\n",
    "    iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),\n",
    "    # Make some images brighter and some darker.\n",
    "    # In 20% of all cases, we sample the multiplier once per channel,\n",
    "    # which can end up changing the color of the images.\n",
    "    iaa.Multiply((0.8, 1.2), per_channel=0.2),\n",
    "    # Apply affine transformations to each image.\n",
    "    # Scale/zoom them, translate/move them, rotate them and shear them.\n",
    "    iaa.Affine(\n",
    "        scale={\"x\": (0.8, 1.2), \"y\": (0.8, 1.2)},\n",
    "        translate_percent={\"x\": (-0.2, 0.2), \"y\": (-0.2, 0.2)},\n",
    "        rotate=(-25, 25),\n",
    "        shear=(-8, 8)\n",
    "    )\n",
    "], random_order=True) # apply augmenters in random order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "data_aug\\activia\n",
      "0 min 6 sec\n",
      "data_aug\\veloute\n",
      "1 min 6 sec\n"
     ]
    }
   ],
   "source": [
    "for subfolder in image_target_subfolders:\n",
    "    print (subfolder)\n",
    "    \n",
    "    # =============Time calculation===============\n",
    "    start_time = datetime.now()\n",
    "    # =============Time calculation===============\n",
    "    # create images array per folder\n",
    "    \n",
    "    image_files = get_files_in_folder(subfolder)\n",
    "    synthetic_image_files = list_oversample(image_files, max_image_count)\n",
    "    images = [imageio.imread(image_file) for image_file in synthetic_image_files]\n",
    "    \n",
    "    # apply imge augmentation on a subfolder\n",
    "    augmented_images = seq(images=images)    \n",
    "    \n",
    "    save_image_array(augmented_images, subfolder)\n",
    "    \n",
    "    \n",
    "    # =============Time calculation===============\n",
    "    # check the endtime\n",
    "    end_time = datetime.now()\n",
    "    # get the total time spent\n",
    "    time_spent = end_time - start_time\n",
    "    spent_minutes, spent_seconds = divmod(\n",
    "        time_spent.days * 86400 + time_spent.seconds, 60)\n",
    "    print(\"{} min {} sec\".format(spent_minutes, spent_seconds))\n",
    "    # =============Time calculation==============="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.6.5 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "14a3dea41308786c6250116f63170ee1ce4906f9726caa7e8b5b84d6f314e26b"
    }
   }
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}