TicketsAI.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/Qanpi/tickets-ai/blob/master/TicketsAI.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Z4cciHFliBzV",
    "outputId": "77f91a68-d9db-4eb9-e335-78e839f416c1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
     ]
    }
   ],
   "source": [
    "import zipfile\n",
    "from google.colab import drive\n",
    "\n",
    "drive.mount('/content/drive')\n",
    "blueberries = zipfile.ZipFile(\"/content/drive/MyDrive/blueberry.zip\")\n",
    "blueberries.extractall(\".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 246
    },
    "id": "fcUpwTLx92yc",
    "outputId": "63683497-da77-4815-f1cd-e06b5305129f"
   },
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'PIL'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/6l/wkw1zxws4s908njwzpr8pvwh0000gp/T/ipykernel_1599/3787398533.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mPIL\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mImageOps\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mio\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mROOT\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"blueberry\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'PIL'"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from PIL import Image, ImageOps\n",
    "import io\n",
    "\n",
    "ROOT = \"blueberry\"\n",
    "train_path = os.path.join(ROOT, \"train\")\n",
    "test_path = os.path.join(ROOT, \"test\")\n",
    "valid_path = os.path.join(ROOT, \"valid\")\n",
    "\n",
    "out_path = os.path.join(ROOT, \"img\")\n",
    "os.makedirs(out_path, exist_ok=True)\n",
    "\n",
    "IMAGE_SHAPE = (256, 256)\n",
    "out_zip = zipfile.ZipFile(os.path.join(ROOT, \"img.zip\"), \"w\")\n",
    "\n",
    "def process_images(run_i, path):\n",
    "  image_path = os.path.join(path, \"images\")\n",
    "  images = os.listdir(image_path)\n",
    "\n",
    "  for i, img_path in enumerate(images):\n",
    "    # os.rename(i)\n",
    "    img = Image.open(os.path.join(image_path, img_path))\n",
    "\n",
    "    label_name = os.path.splitext(img_path)[0]\n",
    "\n",
    "    with open(os.path.join(path, \"labels\", label_name + \".txt\"), \"r\") as label:\n",
    "      keypoints = Image.new(\"1\", IMAGE_SHAPE, (0))\n",
    "\n",
    "      for line in label:\n",
    "        bbox = line.split(\" \")[1:]\n",
    "        bbox = [float(x) for x in bbox]\n",
    "\n",
    "        x, y = bbox[:2]\n",
    "\n",
    "        aspect = min(IMAGE_SHAPE[0]/img.size[0], IMAGE_SHAPE[1]/img.size[1])\n",
    "        aw = int(aspect * img.size[0])\n",
    "        ah = int(aspect * img.size[1])\n",
    "\n",
    "        pad_w = IMAGE_SHAPE[0] - aw\n",
    "        pad_h = IMAGE_SHAPE[1] - ah\n",
    "\n",
    "        x = int(x * aw) + pad_w // 2\n",
    "        y = int(y * ah) + pad_h // 2\n",
    "\n",
    "        keypoints.putpixel((x, y), 1)\n",
    "\n",
    "      img = ImageOps.pad(img, IMAGE_SHAPE)\n",
    "      # keypoints = ImageOps.pad(keypoints, IMAGE_SHAPE)\n",
    "\n",
    "      n = str(run_i + i + 1).zfill(3)\n",
    "      img.save(os.path.join(out_path, f\"{n}blueberry.png\"))\n",
    "      keypoints.save(os.path.join(out_path, f\"{n}dots.png\"))\n",
    "\n",
    "      #save to zip file\n",
    "      byte_img = io.BytesIO()\n",
    "      img.save(byte_img, format=\"PNG\")\n",
    "\n",
    "      byte_keypoints = io.BytesIO()\n",
    "      keypoints.save(byte_keypoints, format=\"PNG\")\n",
    "\n",
    "      out_zip.writestr(f\"{n}blueberry.png\", byte_img.getvalue())\n",
    "      out_zip.writestr(f\"{n}dots.png\", byte_keypoints.getvalue())\n",
    "\n",
    "  return i + 1\n",
    "\n",
    "#done in order to maintain order\n",
    "running_i = 0\n",
    "running_i += process_images(running_i, train_path)\n",
    "running_i += process_images(running_i, valid_path)\n",
    "running_i += process_images(running_i, test_path)\n",
    "\n",
    "out_zip.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lArrcI-BIUnr"
   },
   "source": [
    "# Synthesize dataset_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "euobX_xcbNFd"
   },
   "outputs": [],
   "source": [
    "#@title Setup\n",
    "import os\n",
    "import numpy as np\n",
    "from PIL import Image, ImageDraw, ImageFilter\n",
    "from random import randrange, choice, random\n",
    "import matplotlib.pyplot as plt\n",
    "import zipfile\n",
    "import shutil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RV02vTrbbQrm"
   },
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "\n",
    "def load_tickets(size):\n",
    "  TICKETS_ZIP = \"/content/drive/MyDrive/samples.zip\" #@param\n",
    "  drive.mount('/content/drive')\n",
    "\n",
    "  path = os.path.join(\"tickets\", \"samples\")\n",
    "  os.makedirs(path, exist_ok=True)\n",
    "\n",
    "  if (os.path.isfile(TICKETS_ZIP)):\n",
    "    with zipfile.ZipFile(TICKETS_ZIP) as dataset:\n",
    "      dataset.extractall(path)\n",
    "\n",
    "  filenames = os.listdir(path)\n",
    "  samples = []\n",
    "\n",
    "  for f in filenames:\n",
    "    img = Image.open(os.path.join(path, f))\n",
    "    img.thumbnail((size, size))\n",
    "    samples.append(img)\n",
    "\n",
    "  shutil.rmtree(path)\n",
    "  return samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "N9LNR_DtWflO"
   },
   "outputs": [],
   "source": [
    "def place_object(bg, obj, pos=(0, 0)):\n",
    "  w, h = obj.size\n",
    "\n",
    "  x = pos[0] - w // 2\n",
    "  y = pos[1] - h // 2\n",
    "\n",
    "  padding = bg.copy()\n",
    "  padding.paste(obj, (x, y))\n",
    "\n",
    "  layered = Image.alpha_composite(bg, padding)\n",
    "  return layered\n",
    "\n",
    "def gen_image(count, samples, background=None, image_shape=(256,256), blur_radius = 0):\n",
    "  bg = background or Image.new(\"RGB\", image_shape, (0, 0, 0))\n",
    "  keypoints = Image.new(\"1\", bg.size, (0))\n",
    "\n",
    "  draw = ImageDraw.Draw(bg, mode=\"RGB\")\n",
    "\n",
    "  for i in range(count):\n",
    "    x = randrange(bg.size[0])\n",
    "    y = randrange(bg.size[1])\n",
    "\n",
    "    obj = choice(samples)\n",
    "\n",
    "    if isinstance(obj, Image.Image): #check if array\n",
    "      bg = place_object(bg, obj, (x, y))\n",
    "\n",
    "    elif obj[\"shape\"] == \"ellipse\":\n",
    "      s = obj[\"size\"]\n",
    "\n",
    "      bbox = [(x - s/2, y-s/2), (x + s/2, y+s/2)]\n",
    "      draw.ellipse(bbox, fill=obj[\"fill\"])\n",
    "\n",
    "    keypoints.putpixel((x, y), (1))\n",
    "\n",
    "  if (blur_radius != 0): bg = bg.filter(ImageFilter.BoxBlur(blur_radius))\n",
    "  return bg, keypoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "HXMUZn60OFjF"
   },
   "outputs": [],
   "source": [
    "def gen_tickets_data(path):\n",
    "  DATASET_SIZE = 200 #@param {type: \"slider\", max: 1000, min: 100}\n",
    "  MIN_TICKETS = 10 #@param {type: \"slider\"}\n",
    "  MAX_TICKETS = 50 #@param {type: \"slider\"}\n",
    "  TICKET_SIZE = 50 #@param {type: \"slider\"}\n",
    "\n",
    "  tickets = load_tickets((TICKET_SIZE, TICKET_SIZE))\n",
    "\n",
    "  for i in range(DATASET_SIZE):\n",
    "    count = randrange(MIN_TICKETS, MAX_TICKETS)\n",
    "\n",
    "    img, key = gen_image(count, tickets, object_size=TICKET_SIZE)\n",
    "\n",
    "    n = str(i+1).zfill(3)\n",
    "    img.save(os.path.join(path, f\"{n}ticket.png\")) #change from plural to singular\n",
    "    key.save(os.path.join(path, f\"{n}dots.png\"))\n",
    "\n",
    "  #clean up\n",
    "  for t in tickets:\n",
    "    t.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "Ny6IRXxXdt05"
   },
   "outputs": [],
   "source": [
    "#@title Synthesize data for the cells dataset {run: \"auto\"}\n",
    "\n",
    "def gen_cells_data(path):\n",
    "  DATASET_SIZE = 200 #@param {type: \"slider\", max: 1000, min: 1}\n",
    "  BG_SHAPE = (256, 256) #@param\n",
    "  CELL_SIZE = 10 #@param {type: \"slider\"}\n",
    "  BLUR_RADIUS = 2 #@param {type: \"slider\"}\n",
    "\n",
    "  MEAN = 175.96\n",
    "  STD = 61.244905094219874\n",
    "\n",
    "  #populate samples\n",
    "  samples = gen_cells_samples(CELL_SIZE)\n",
    "  #mimic distribution of real dataset\n",
    "  distribution = np.random.default_rng().normal(MEAN, STD, DATASET_SIZE)\n",
    "\n",
    "  for i in range(DATASET_SIZE):\n",
    "    #create bg\n",
    "    background = gen_cells_background(BG_SHAPE)\n",
    "    count = int(distribution[i])\n",
    "\n",
    "    img, key = gen_image(count, samples, background=background, blur_radius=BLUR_RADIUS)\n",
    "    img = img.convert(\"RGB\")\n",
    "\n",
    "    n = str(i+1).zfill(3)\n",
    "    img.save(os.path.join(path, f\"{n}cell.png\")) #change from plural to singular\n",
    "    key.save(os.path.join(path, f\"{n}dots.png\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "-rnROEeqp0tg"
   },
   "outputs": [],
   "source": [
    "def gen_cells_background(shape):\n",
    "  background = Image.new(\"RGB\", shape, (0, 0, 0, 255))\n",
    "  draw = ImageDraw.Draw(background, \"RGB\")\n",
    "\n",
    "  w, h = background.size\n",
    "\n",
    "  ellipse_count = 2\n",
    "  for i in range(ellipse_count):\n",
    "    x1y1 = (randrange(0, int(w/2)), randrange(0, int(h/2)))\n",
    "    x2y2 = (randrange(int(w/2), w), randrange(int(h/2), h))\n",
    "    bbox = [x1y1, x2y2]\n",
    "    draw.ellipse(bbox, fill=(0, 0, randrange(100, 250)))\n",
    "\n",
    "  background = background.filter(ImageFilter.GaussianBlur(100))\n",
    "\n",
    "  return background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "Y8mmiTzdg6Pz"
   },
   "outputs": [],
   "source": [
    "def gen_cells_samples(size):\n",
    "  UNIQUE_CELLS = 15 #@param {type: \"slider\"}\n",
    "  cells = []\n",
    "\n",
    "  for i in range(UNIQUE_CELLS):\n",
    "    cell = {\n",
    "        \"shape\": \"ellipse\",\n",
    "        \"size\": size,\n",
    "        \"fill\": (0, 0, randrange(120, 250)),\n",
    "    }\n",
    "    cells.append(cell)\n",
    "\n",
    "  return cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "hqI2HffzdtZb"
   },
   "outputs": [],
   "source": [
    "def gen_data(dataset):\n",
    "  path = os.path.join(dataset, \"synthetic\", \"img\")\n",
    "  os.makedirs(path, exist_ok=True)\n",
    "\n",
    "  {\n",
    "      \"tickets\": gen_tickets_data,\n",
    "      \"cell\": gen_cells_data\n",
    "  }[dataset](path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 273
    },
    "id": "bKoW0gBdTXNp",
    "outputId": "17f97398-f762-45ff-f17b-3b1965afa399"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=256x256>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATASET = \"cell\" #@param [\"ticket\", \"cell\"]\n",
    "gen_data(DATASET)\n",
    "\n",
    "Image.open(\"cell/synthetic/img/001cell.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CHwSoUolIHuX"
   },
   "source": [
    "# Run Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KjOyR_8df1to",
    "outputId": "694daee9-6d4e-439b-8ff4-3c0ae5963689"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: MODEL_PATH=.\n",
      "env: DATASET=cell\n"
     ]
    }
   ],
   "source": [
    "%env MODEL_PATH=.\n",
    "%env DATASET=cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HCvz1jvvZ32M",
    "outputId": "6e0b32af-6a52-49f7-c53a-7c0a2f53bc1c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fatal: destination path 'model' already exists and is not an empty directory.\n"
     ]
    }
   ],
   "source": [
    "!git clone https://github.com/Qanpi/tickets-ai $MODEL_PATH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "N0RDXtJurNA0",
    "outputId": "155f596e-e5b9-44a3-a405-b7ca7880209e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HEAD is now at 61b08ae reworked precision and accuracy to use n peaks\n",
      "remote: Enumerating objects: 7, done.\u001b[K\n",
      "remote: Counting objects: 100% (7/7), done.\u001b[K\n",
      "remote: Compressing objects: 100% (2/2), done.\u001b[K\n",
      "remote: Total 4 (delta 2), reused 4 (delta 2), pack-reused 0\u001b[K\n",
      "Unpacking objects: 100% (4/4), 3.94 KiB | 3.94 MiB/s, done.\n",
      "From https://github.com/Qanpi/tickets-ai\n",
      " * branch            master     -> FETCH_HEAD\n",
      "   61b08ae..810cc72  master     -> origin/master\n",
      "Updating 61b08ae..810cc72\n",
      "Fast-forward\n",
      " gen_data.py | 549 \u001b[32m+++++++++++++++++++++++++++++++++++++++++++\u001b[m\u001b[31m-----------------\u001b[m\n",
      " looper.py   |  41 \u001b[32m++\u001b[m\u001b[31m---\u001b[m\n",
      " 2 files changed, 418 insertions(+), 172 deletions(-)\n"
     ]
    }
   ],
   "source": [
    "!cd $MODEL_PATH && git reset --hard && git pull origin master"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "G4aMZQkhesLg",
    "outputId": "fa5efe85-1317-4a31-f2a2-4280855c7c4f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zsh:1: command not found: pip\r\n"
     ]
    }
   ],
   "source": [
    "!pip install -r $MODEL_PATH/requirements.txt -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "cellView": "form",
    "id": "4M8JEqHsMlmO"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zsh:1: command not found: nvidia-smi\r\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Verify Cuda availability\n",
    "!nvidia-smi\n",
    "\n",
    "import torch\n",
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "B7S7IX6Vpczl",
    "outputId": "1778486b-8133-4302-d958-be30814753c4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully loaded dataset cell to cell/synthetic.\n",
      "Mean: 176.01\n",
      "Standard deviation: 60.99204784232121\n"
     ]
    }
   ],
   "source": [
    "#@title Load DATASET\n",
    "!python3 $MODEL_PATH/gen_data.py --dataset $DATASET -p $DATASET/synthetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bS0cVpOv7_LG",
    "outputId": "4f71365e-be66-417e-ee32-79b7d4744cb1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully loaded dataset cell to cell/real.\n",
      "Mean: 175.96\n",
      "Standard deviation: 61.244905094219874\n"
     ]
    }
   ],
   "source": [
    "#@title Load DATASET\n",
    "!python $MODEL_PATH/gen_data.py --dataset $DATASET -p $DATASET/real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UkwVWaLHt2pD"
   },
   "outputs": [],
   "source": [
    "!cp $DATASET/real/valid.h5 $DATASET/synthetic/valid.h5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "37QDXJt4Lll_"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n",
      "^C\n"
     ]
    }
   ],
   "source": [
    "#@title Run training\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# for i in range(5):\n",
    "!python3 $MODEL_PATH/train.py $DATASET/synthetic -n UNet -e 100 --save $DATASET/aug -vf 0.5 -hf 0.5 -rt 0.5 --verbose\n",
    "  # clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BNvmO15R2TuX"
   },
   "outputs": [],
   "source": [
    "# !cd $MODEL_PATH && git config user.email \"aleksei.terin@outlook.com\"\n",
    "# !cd $MODEL_PATH && git config user.name \"Qanpi\"\n",
    "# !cd $MODEL_PATH && git commit -am \"fixed rotation and other minor bugs\"\n",
    "!cd $MODEL_PATH && git remote add colab https://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@github.com/username/repository.git\n",
    "!cd $MODEL_PATH && git push colab master"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ycbh96c_TZ0R",
    "outputId": "96bbdb20-0b21-4a73-9e4c-6a84356aeb32"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usage: infer.py [OPTIONS]\n",
      "Try 'infer.py --help' for help.\n",
      "\n",
      "Error: Invalid value for '-i' / '--infer_path': 'blueberry/img/070blueberry.png': No such file or directory\n"
     ]
    }
   ],
   "source": [
    "!python $MODEL_PATH/infer.py -n UNet -c $DATASET/UNet.pth -i $DATASET/img/070blueberry.png -v $DATASET/img/070dots.png --visualize --save ./infer.png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8JcHfx0NniiP"
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2ITPCkVSWSLK"
   },
   "source": [
    "To what extent can synthetically generated data be employed in training neural networks for real world purposes?\n",
    "- no random gauss blur -> bad results"
   ]
  }
 ],
 "metadata": {
  "accelerator": "TPU",
  "colab": {
   "include_colab_link": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}