generate_moving_mnist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/python3\n",
    "import math\n",
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from skimage.draw import random_shapes\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import h5py\n",
    "import cmath\n",
    "\n",
    "###########################################################################################\n",
    "# script to generate moving mnist video dataset (frame by frame) as described in\n",
    "# [1] arXiv:1502.04681 - Unsupervised Learning of Video Representations Using LSTMs\n",
    "#     Srivastava et al\n",
    "# by Tencia Lee\n",
    "# saves in hdf5, npz, or jpg (individual frames) format\n",
    "###########################################################################################\n",
    "\n",
    "# modification: saves labels frame-wise\n",
    "# run as generate_moving_mnist.py --dest ./data --num_frames 20 --num_videos 10000\n",
    "\n",
    "# helper functions\n",
    "\n",
    "def arr_to_pilarr(img, mean=0, std=1):\n",
    "    '''\n",
    "    Args:\n",
    "        img: image array of shape C x W x H\n",
    "        mean: Mean to add\n",
    "        std: Standard Deviation to add\n",
    "    Returns:\n",
    "        Image with dimensions H x W x C or H x W if it's a single channel image\n",
    "    '''\n",
    "    img_std = (((img + mean)*255.)*std).astype(np.uint8)\n",
    "    img_std = img_std.clip(0, 255).transpose(2,1,0).squeeze()\n",
    "    return img_std\n",
    "\n",
    "\n",
    "# loads mnist from web on demand\n",
    "def load_dataset():\n",
    "    if sys.version_info[0] == 2:\n",
    "        from urllib import urlretrieve\n",
    "    else:\n",
    "        from urllib.request import urlretrieve\n",
    "\n",
    "    def download(filename, source='http://yann.lecun.com/exdb/mnist/'):\n",
    "        print(\"Downloading %s\" % filename)\n",
    "        urlretrieve(source + filename, filename)\n",
    "\n",
    "    import gzip\n",
    "\n",
    "    def load_mnist_images(filename):\n",
    "        if not os.path.exists(filename):\n",
    "            download(filename)\n",
    "        with gzip.open(filename, 'rb') as f:\n",
    "            data = np.frombuffer(f.read(), np.uint8, offset=16)\n",
    "        data = data.reshape(-1, 1, 28, 28)\n",
    "        return data / np.float32(256)\n",
    "\n",
    "    def load_mnist_labels(filename):\n",
    "        if not os.path.exists(filename):\n",
    "            download(filename)\n",
    "        with gzip.open(filename, 'rb') as f:\n",
    "            data = np.frombuffer(f.read(), np.uint8, offset=8)\n",
    "        return data\n",
    "\n",
    "    # We can now download and read the training and test set images and labels.\n",
    "    X_train = load_mnist_images('train-images-idx3-ubyte.gz')\n",
    "    y_train = load_mnist_labels('train-labels-idx1-ubyte.gz')\n",
    "    X_test = load_mnist_images('t10k-images-idx3-ubyte.gz')\n",
    "    y_test = load_mnist_labels('t10k-labels-idx1-ubyte.gz')\n",
    "    \n",
    "    # We reserve the last 10000 training examples for validation.\n",
    "    X_train, X_val = X_train[:-10000], X_train[-10000:]\n",
    "    y_train, y_val = y_train[:-10000], y_train[-10000:]\n",
    "\n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test\n",
    "\n",
    "\n",
    "def generate_moving_mnist(\n",
    "    split=\"train\",\n",
    "    shape=(64, 64), \n",
    "    num_frames=30, \n",
    "    num_videos=100, \n",
    "    ignore_label=255,\n",
    "#     mnist_size_randomize=False, # TODO \n",
    "# if mnist_size_randomize : .resize((original_size, original_size),Image.ANTIALIAS)\n",
    "    min_nums_per_image=2, max_nums_per_image=2,\n",
    "    rotatehint=False):\n",
    "    '''\n",
    "    Args:\n",
    "        training: Boolean, used to decide if downloading/generating train set or test set\n",
    "        shape: Shape we want for our moving images (new_width and new_height)\n",
    "        num_frames: Number of frames in a particular movement/animation/gif\n",
    "        num_videos: Number of movement/animations/gif to generate\n",
    "        original_size: Real size of the images (eg: MNIST is 28x28)\n",
    "        nums_per_image: Digits per movement/animation/gif. \n",
    "        If a list of possible nums_per_image is provided, the number is sampled randomly from the list per video\n",
    "    Returns:\n",
    "        Dataset of np.uint8 type with dimensions num_videos x num_frames x 1 x new_width x new_height\n",
    "    '''\n",
    "    X_train, y_train, X_val, y_val, X_test, y_test = load_dataset() \n",
    "    \n",
    "    if \"train\" in split:\n",
    "        mnist = X_train\n",
    "        mnist_lab = y_train\n",
    "    elif \"val\" in split:\n",
    "        mnist = X_val\n",
    "        mnist_lab = y_val\n",
    "    elif \"test\" in split:\n",
    "        mnist = X_test\n",
    "        mnist_lab = y_test\n",
    "    else:\n",
    "        raise ValueError(\"allowed values for 'split' are ['train','test','val'] but given {}\".format(split))\n",
    "    \n",
    "    height, width = shape\n",
    "    n, _, mnist_height, mnist_width = X_test.shape\n",
    "    assert min_nums_per_image<=max_nums_per_image\n",
    "    # Get how many pixels can we move around a single image\n",
    "    lims = (x_lim, y_lim) = width - mnist_width, height - mnist_height\n",
    "    \n",
    "    # Create a dataset of shape of num_videos X num_frames x 1 x new_width x new_height Eg : 20000 x 20 x 1 x 64 x 64\n",
    "    dataset = np.empty((num_videos, num_frames, 1, height, width), dtype=np.uint8)\n",
    "    dataset_masks = np.empty((num_videos, num_frames, 1, height, width), dtype=np.uint8)\n",
    "    dataset_labels = np.empty((num_videos, num_frames,  max_nums_per_image, 3), dtype=np.float)\n",
    "\n",
    "    for vid_idx in tqdm(range(num_videos)):\n",
    "        # randomly select the number of nums per image\n",
    "        nums_per_image = np.random.randint(min_nums_per_image, max_nums_per_image+1)\n",
    "        if nums_per_image:\n",
    "            # Randomly generate velocity (direction + speed), \n",
    "            max_speed = 5\n",
    "            speeds = np.random.randint(1, max_speed+1, size=nums_per_image)\n",
    "            # choose one of the 8 directions to move\n",
    "            total_dirs = 8 \n",
    "            dir_vals = np.random.choice(np.arange(0,1,step=1/total_dirs), size=nums_per_image)\n",
    "            # change direction values to range [-pi,+pi]\n",
    "            direcs = np.pi*((dir_vals)*2 - 1)\n",
    "\n",
    "#             print(\"Speed={}, Direc={}\".format(speeds, dir_vals*total_dirs))\n",
    "            veloc = np.asarray(\n",
    "                [(speed*math.cos(direc), speed*math.sin(direc)) for direc, speed in zip(direcs, speeds)]\n",
    "            )\n",
    "            # Randomly generate brightness for all images\n",
    "    #         rand_brightness = []\n",
    "    #         for i in range(nums_per_image):\n",
    "    #             start = np.random.uniform(0.1, 1.5)\n",
    "    #             stop = np.random.uniform(0.1, 1.5) \n",
    "    #             step = (stop-start)/num_frames\n",
    "    #             rand_brightness.append(np.arange(start, stop, step))\n",
    "\n",
    "            # Get a list of MNIST images randomly sampled from the dataset\n",
    "            rand_idx = np.random.randint(0, mnist.shape[0], nums_per_image)\n",
    "            mnist_images = [Image.fromarray(arr_to_pilarr(mnist[s])) for s in rand_idx]\n",
    "            mnist_labels = [mnist_lab[s] for s in rand_idx]\n",
    "        \n",
    "        # prepare a canvas with random shapes for each video\n",
    "#         canvas_x_lims, canvas_y_lims = 20,20 \n",
    "        canvas_x_lims, canvas_y_lims = 0,0 # dont move bg\n",
    "        static_canvas_distractors,_ = random_shapes((height+canvas_x_lims, width+canvas_y_lims), \n",
    "                                                    min_shapes=15, max_shapes=25, \n",
    "                                                    multichannel=False, allow_overlap=True) \n",
    "#         canvas_position = np.random.randint(0, high=canvas_x_lims//2, size=(2,))\n",
    "        \n",
    "        if nums_per_image:\n",
    "            # Generate initial positions for nums_per_image as tuples (x,y)\n",
    "            positions = np.asarray(\n",
    "                [(np.random.rand() * x_lim, np.random.rand() * y_lim) for _ in range(nums_per_image)]\n",
    "            )\n",
    "            # Generate initial rotation angle for nums_per_image\n",
    "            rotates = np.random.randint(0, 360, size=nums_per_image)\n",
    "            if rotatehint:\n",
    "                rotate_increments = np.array(mnist_labels, dtype=int)*2\n",
    "            else:\n",
    "                rotate_increments = np.random.randint(0, 10, size=nums_per_image)\n",
    "        \n",
    "        # Generate new frames for the entire num_frames\n",
    "        for frame_idx in range(num_frames): \n",
    "            labels_and_pos = []\n",
    "            canvas = static_canvas_distractors.copy() #np.zeros((width, height), dtype=np.float32)#\n",
    "            # move the bg canvas a little, if possible\n",
    "#             if canvas_position[0]+2 < canvas_x_lims:\n",
    "#                 canvas_position[0] = canvas_position[0] + np.random.randint(0,3)\n",
    "#             if canvas_position[1]+2 < canvas_y_lims:\n",
    "#                 canvas_position[1] = canvas_position[1] + np.random.randint(0,3)                \n",
    "#             canvas = canvas[\n",
    "#                 canvas_position[0]:canvas_position[0]+height, canvas_position[1]:canvas_position[1]+width\n",
    "#             ]\n",
    "            canvas[canvas==255] = 0\n",
    "            canvas_mask = np.full((height, width), fill_value=ignore_label, dtype=np.float32)\n",
    "            \n",
    "            # Super impose images on the canvas\n",
    "            for i in range(nums_per_image):\n",
    "                # generate random noise for the canvas background\n",
    "#                 noise = (np.random.normal(loc=127, scale=127, size=(height, width))).astype(np.uint8)\n",
    "#                 canvas[canvas==0] = noise[canvas==0]\n",
    "                canvas = canvas.astype(np.float32)\n",
    "                # copy the MNIST image\n",
    "                mnist_rotated = mnist_images[i] #.rotate(rotates[i].astype(int))\n",
    "                mnist_copy = Image.new('L', (height, width))\n",
    "                mnist_copy.paste(mnist_rotated, tuple(positions[i].astype(int)))\n",
    "                mnist_copy = np.array(mnist_copy)#*rand_brightness[i][frame_idx]\n",
    "                canvas[mnist_copy>0]=mnist_copy[mnist_copy>0]\n",
    "                \n",
    "                # if there are regions of overlap in canvas_mask, override with the last label\n",
    "                canvas_mask[mnist_copy>0] = mnist_labels[i]\n",
    "                \n",
    "            # Get the next position by adding velocity\n",
    "            next_pos = positions + veloc\n",
    "            \n",
    "            rotates = (rotates + rotate_increments)%360\n",
    "            # Iterate over velocity and see if we hit the wall. If yes, change direction\n",
    "            for i, pos in enumerate(next_pos):\n",
    "                for j, coord in enumerate(pos):\n",
    "                    if coord < 0 or coord > lims[j] :\n",
    "                        veloc[i] = list(list(veloc[i][:j]) + [-1 * veloc[i][j]] + list(veloc[i][j + 1:]))\n",
    "            # Make the permanent change to position by adding updated velocity\n",
    "            positions = positions + veloc\n",
    "            \n",
    "            # labels calculations\n",
    "            lbl_n_pos = []\n",
    "            for i in range(nums_per_image):\n",
    "                mag, angle = cmath.polar(complex(*veloc[i]))\n",
    "                mag = round(mag/max_speed,2)\n",
    "                # make angle in the range [0,1]\n",
    "                angle = (angle/(math.pi) + 1)/2 \n",
    "                angle_class = round(total_dirs*angle)\n",
    "                if angle_class == total_dirs : angle_class=0\n",
    "                lbl_n_pos.append([mnist_labels[i], mag, angle_class])\n",
    "            \n",
    "            labels_and_pos.append(lbl_n_pos)\n",
    "            \n",
    "            # Add the canvas to the dataset array\n",
    "            dataset[vid_idx, frame_idx, 0] = canvas.clip(0, 255).astype(np.uint8) \n",
    "            dataset_masks[vid_idx, frame_idx, 0] = (canvas_mask).astype(np.uint8)  \n",
    "            # Add the label to the dataset labels array\n",
    "            dataset_labels[vid_idx, frame_idx, :nums_per_image] = np.array(labels_and_pos)\n",
    "            \n",
    "    return dataset, dataset_masks, dataset_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame_size= 64\n",
    "num_frames= 20  # length of each sequence\n",
    "mnist_size_randomize = False  # to randomize the size of mnist digit within frame\n",
    "min_nums_per_image = 1  # number of digits in each frame\n",
    "max_nums_per_image = 1  # number of digits in each frame\n",
    "ignore_label = 10\n",
    "rotatehint = False\n",
    "split, num_videos = ('train',10000)#('train',10000)#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:127: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5903126553d6406eaf969872b8c0ba0a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=10000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "dat, dat_masks, dat_labels = generate_moving_mnist(split, shape=(frame_size, frame_size),\n",
    "                                        ignore_label=ignore_label,\n",
    "                                        num_frames=num_frames, num_videos=num_videos,\n",
    "                                        min_nums_per_image=min_nums_per_image, max_nums_per_image=max_nums_per_image,\n",
    "                                        rotatehint=rotatehint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.unique(dat_labels[:,:,:,-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"./data\"\n",
    "suffix=\"1ss\"\n",
    "filetype = \"npy\"\n",
    "\n",
    "\n",
    "if not os.path.isdir(path):\n",
    "    print(\"creating folder \", path)\n",
    "    os.makedirs(path)\n",
    "    \n",
    "# save images and labels\n",
    "#np.save(path+split+\"_images\", dat)\n",
    "np.save(\"{}/data{}\".format(path, suffix), dat)\n",
    "np.save(\"{}/data{}_labels\".format(path, suffix), dat_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 20, 1, 64, 64) (10000, 20, 1, 3)\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "dat = np.load(\"{}/data{}.npy\".format(path, suffix))\n",
    "dat_labels = np.load(\"{}/data{}_labels.npy\".format(path, suffix))\n",
    "\n",
    "print(dat.shape, dat_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/matplotlib/text.py:1191: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
      "  if s != self._text:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2880x576 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_vid = np.random.randint(0, num_videos)\n",
    "num_frames = 20 if num_frames>20 else num_frames\n",
    "\n",
    "fig, axes = plt.subplots(nrows=2, ncols=num_frames//2, figsize=(2*num_frames,8))\n",
    "\n",
    "for i, ax in enumerate(axes.reshape(-1)):\n",
    "    ax.axis('off')\n",
    "    ax.imshow(dat[plot_vid,i,0])\n",
    "    ax.set_title(dat_labels[plot_vid,i,0], fontdict = {'fontsize' : 400//num_frames})\n",
    "#     plt.subplot(2, num_frames, num_frames+i+1).axis('off')\n",
    "#     plt.imshow((dat_masks[plot_vid,i][0,:,:]+1)*20)\n",
    "plt.subplots_adjust(wspace=0., hspace=0.15)\n",
    "plt.show()"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}