{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10種類の小さい画像（CIFAR-10）\n",
    "\n",
    "*CIFAR-10*というデータセットは多数の小さい画像から構成されている。各画像に対して、その画像に映っているものを表わすテキストラベルが付与されている。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__目次__\n",
    "\n",
    "- <a href=\"#overview\">データセットの概要</a>\n",
    "\n",
    "- <a href=\"#data_check\">（画像、ラベル）の対を調べる</a>\n",
    "\n",
    "- <a href=\"#make_h5\">作業用のデータを整える</a>\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"overview\"></a>\n",
    "## データセットの概要\n",
    "\n",
    "CIFAR-10は、機械学習の研究開発で著名なAlex Krizhevsky氏のトロント大学でのホームページから入手できる。\n",
    "\n",
    "```\n",
    "http://www.cs.toronto.edu/~kriz/cifar.html\n",
    "```\n",
    "\n",
    "このデータセットの源泉となるのは、8000万枚もの小さい画像からなる*Tiny Images*という著名なデータセットである[<a href=\"http://horatio.cs.nyu.edu/mit/tiny/data/index.html\">link</a>]。CIFAR-10はそのごく一部を抜粋したもので、10種類のラベル（*airplane*, *automobile*, *bird*, *cat*, *deer*, *dog*, *frog*, *horse*, *ship*, *truck*）に絞られている。ちなみに、__CIFAR__の略称は(C)anadian (I)nstitute (for (A)dvanced (R)esearchからきている。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/cifar-10.png\" alt=\"CIFAR-10 examples\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "基本情報は以下の通りである。\n",
    "\n",
    "- 6万枚の画像\n",
    "- 大きさは32x32のRGB画像\n",
    "- ラベルには10種類ある\n",
    "- 各クラスの数は均等で、一クラスにつき6,000枚ある\n",
    "\n",
    "まずはこの<a href=\"DataSources.ipynb\">データセット自体を入手した</a>上で、その中身を覗いてみよう。\n",
    "\n",
    "```\n",
    "$ ls cifar-10-batches-bin\n",
    "batches.meta.txt  data_batch_2.bin  data_batch_4.bin  readme.html\n",
    "data_batch_1.bin  data_batch_3.bin  data_batch_5.bin  test_batch.bin\n",
    "```\n",
    "\n",
    "`batches.meta.txt`は単なるラベル名を示すテキストで、一行に一つのラベル。あとはバイナリ形式のバッチが6つある。訓練用のもの（`data_batch_*.bin`）と検証用のもの（`test_batch.bin`）からなる。ラベルの分布について、前掲のホームページより引用すると、\n",
    "\n",
    "> The test batch contains exactly 1000 randomly-selected images from each class. The training batches contain the remaining images in random order, but some training batches may contain more images from one class than another. Between them, the training batches contain exactly 5000 images from each class. \n",
    "\n",
    "ということであるので、バッチを単独に使うと完全に均一ではないが、バッチを足し合わせるとどのクラスもまったく同じ枚数である。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"data_check\"></a>\n",
    "## （画像、ラベル）の対を調べる\n",
    "\n",
    "訓練データのファイルを開く。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.BufferedReader name='data/cifar10/cifar-10-batches-bin/data_batch_1.bin'>\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "toread = \"data/cifar10/cifar-10-batches-bin/data_batch_1.bin\"\n",
    "\n",
    "f_bin = open(toread, mode=\"rb\")\n",
    "\n",
    "print(f_bin)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "重要なのは、正しくデータを読めているかどうか検証することである。一番わかやすいのは、自分の目で、「あるはずだ」という中身があることを確かめることである。ドキュメンテーションに目を通すと、今回のバイナリ形式はきわめて単純で、詳細は下記のとおりである。\n",
    "\n",
    "- データ点の基本形は`<1 x label><3072 x pixel>`である。1バイトがラベルで、そのあとの3072ものバイトは画素値である。したがって、連続する3073バイトが一つの（画像、ラベル）の対に相当するので、各バッチでこれが1万回繰り返される。\n",
    "\n",
    "- ラベルの取る値は0から9までである。\n",
    "- 画像は32x32ピクセルで、一つの画素値に1バイトが使われる。色チャンネルが3つあって、red、 green、blueという順で続く。\n",
    "- 画素値の並び方は*row-major*なので、二次元の画像として表示する場合は、配列の行ごとに埋めていく（それに対して、*column-major*の場合は列ごとに埋める）。\n",
    "\n",
    "この程度の情報があれば難なく準備ができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First byte:\n",
      "bytes:  b'\\x06'\n",
      "int:  6\n"
     ]
    }
   ],
   "source": [
    "print(\"First byte:\") # should be a label.\n",
    "b = f_bin.read(1)\n",
    "print(\"bytes: \", b)\n",
    "print(\"int: \", int.from_bytes(b, byteorder=\"big\", signed=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここで出てきたPythonのバイトデータ`b'\\x06'`は、最初の1バイトを16進法(hexadecimal)で表記したものである。先頭の``\\x``はバイトごとの区切りを示す。画素値は0から255の値を取るのだが、16進法の2桁を使うと、$0, 1, 2, \\ldots$から$(15 \\times 16^{1} + 15 \\times 16^{0}) = 255$までの整数を表現することができるので、ちょうど良い。\n",
    "\n",
    "続いて、次の5個のピクセルの値を見てみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bytes:  b';'\n",
      "int:  59\n",
      "bytes:  b'+'\n",
      "int:  43\n",
      "bytes:  b'2'\n",
      "int:  50\n",
      "bytes:  b'D'\n",
      "int:  68\n",
      "bytes:  b'b'\n",
      "int:  98\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    b = f_bin.read(1)\n",
    "    print(\"bytes: \", b)\n",
    "    print(\"int: \", int.from_bytes(b, byteorder=\"big\", signed=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "いきなり新しい記号がここで出てきたが、たとえば`b';'`などは当然、普通の16進法の表記ではない。PythonはASCII記号を使って表わすことがたくさんある。今回は16進法の`0x3b`を`b';'`で表しているが、大事なのはその中身が正しいかどうかである。`seek()`で最初の画素値に戻り、画像の全ピクセルを読み込んでみる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_bin.seek(1)\n",
    "my_array = np.zeros((32,32,3), dtype=np.uint8)\n",
    "for c in range(3): # colour channel\n",
    "    for i in range(32): # rows\n",
    "        for j in range(32): # columns\n",
    "            b = f_bin.read(1)\n",
    "            my_array[i,j,c] = int.from_bytes(b, byteorder=\"big\", signed=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f0110202d68>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "粗いことは粗いが、蛙の画像に見えることは確かである。この画像のラベルは6だったので、ゼロから数え上げて7番目のラベルとなる。付属データとしての`batches.meta.txt`の内容を覗いてみると、\n",
    "\n",
    "```\n",
    "$ cat batches.meta.txt\n",
    "airplane\n",
    "automobile\n",
    "bird\n",
    "cat\n",
    "deer\n",
    "dog\n",
    "frog\n",
    "horse\n",
    "ship\n",
    "truck\n",
    "```\n",
    "\n",
    "と嬉しいことに、6がfrogに相当する。もう一つのペアを見てみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bytes:  b'\\t'\n",
      "int:  9\n"
     ]
    }
   ],
   "source": [
    "b = f_bin.read(1)\n",
    "print(\"bytes: \", b)\n",
    "print(\"int: \", int.from_bytes(b, byteorder=\"big\", signed=False))\n",
    "my_array = np.zeros((32,32,3), dtype=np.uint8)\n",
    "for c in range(3): # colour channel\n",
    "    for i in range(32): # rows\n",
    "        for j in range(32): # columns\n",
    "            b = f_bin.read(1)\n",
    "            my_array[i,j,c] = int.from_bytes(b, byteorder=\"big\", signed=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f01101a02b0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これも粗いが、そこそこ大きなトラックに見える。ラベルは9で、10番目のラベルである。これもめでたく、truckと確認できて、どうも正しく読めているようである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"make_h5\"></a>\n",
    "## 作業用のデータを整える\n",
    "\n",
    "前節では、位置（縦、横）と色チャンネルの三次元配列を使ってカラー画像を表示していたのだが、学習に際しては、画像を一つの長いベクトルとしたほうが使い勝手が良い。次はこれらのベクトルを行とする二次元配列を構成して、階層型データファイルにまとめる作業であるが、そのために__PyTables__という大変便利なパッケージを使う[<a href=\"http://www.pytables.org/\">link</a>]。\n",
    "\n",
    "まずは新しい階層型ファイルを作る（.h5形式）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tables\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Key information.\n",
    "NUM_CLASSES = 10\n",
    "NUM_LABELS = 1\n",
    "NUM_PIXELS = 32*32\n",
    "NUM_CHANNELS = 3\n",
    "NUM_BATCHIM = 10000 # number of images per batch.\n",
    "\n",
    "# A dictionary mapping label values (ints) to strings.\n",
    "toread = \"data/cifar10/cifar-10-batches-bin/batches.meta.txt\"\n",
    "LABEL_DICT = {}\n",
    "with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n",
    "    for cnt, line in enumerate(f):\n",
    "        LABEL_DICT[cnt] = line.split(\"\\n\")[0] # to remove the line-breaks.\n",
    "    LABEL_DICT.pop(10) # to remove the empty line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/cifar10/data.h5 (File) 'CIFAR-10 data'\n",
      "Last modif.: 'Fri Jul 27 10:35:59 2018'\n",
      "Object Tree: \n",
      "/ (RootGroup) 'CIFAR-10 data'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Open file connection, writing new file to disk.\n",
    "myh5 = tables.open_file(\"data/cifar10/data.h5\",\n",
    "                        mode=\"w\",\n",
    "                        title=\"CIFAR-10 data\")\n",
    "print(myh5) # currently empty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元の`RootGroup`には、訓練用と検証用のグループを追加する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/cifar10/data.h5 (File) 'CIFAR-10 data'\n",
      "Last modif.: 'Fri Jul 27 10:35:59 2018'\n",
      "Object Tree: \n",
      "/ (RootGroup) 'CIFAR-10 data'\n",
      "/test (Group) 'Testing data'\n",
      "/train (Group) 'Training data'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "myh5.create_group(myh5.root, \"train\", \"Training data\")\n",
    "myh5.create_group(myh5.root, \"test\", \"Testing data\")\n",
    "print(myh5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "この`train`と`test`はそれぞれ、*enumerative array* (`EArray`クラス, 数え上げ配列)を持たせて、データを格納するための準備を始める。通常の`Array`オブジェクトと違って、あとでデータを追加することで伸ばし広げられる性質を有する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/cifar10/data.h5 (File) 'CIFAR-10 data'\n",
      "Last modif.: 'Fri Jul 27 10:35:59 2018'\n",
      "Object Tree: \n",
      "/ (RootGroup) 'CIFAR-10 data'\n",
      "/test (Group) 'Testing data'\n",
      "/test/inputs (EArray(0, 3072)) 'Input images'\n",
      "/test/labels (EArray(0, 1)) 'Label values'\n",
      "/train (Group) 'Training data'\n",
      "/train/inputs (EArray(0, 3072)) 'Input images'\n",
      "/train/labels (EArray(0, 1)) 'Label values'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Training data arrays.\n",
    "a = tables.UInt8Atom()\n",
    "myh5.create_earray(myh5.root.train,\n",
    "                   name=\"labels\",\n",
    "                   atom=a,\n",
    "                   shape=(0,NUM_LABELS),\n",
    "                   title=\"Label values\")\n",
    "a = tables.Float32Atom()\n",
    "myh5.create_earray(myh5.root.train,\n",
    "                   name=\"inputs\",\n",
    "                   atom=a,\n",
    "                   shape=(0,NUM_CHANNELS*NUM_PIXELS),\n",
    "                   title=\"Input images\")\n",
    "\n",
    "# Testing data arrays.\n",
    "a = tables.UInt8Atom()\n",
    "myh5.create_earray(myh5.root.test,\n",
    "                   name=\"labels\",\n",
    "                   atom=a,\n",
    "                   shape=(0,NUM_LABELS),\n",
    "                   title=\"Label values\")\n",
    "a = tables.Float32Atom()\n",
    "myh5.create_earray(myh5.root.test,\n",
    "                   name=\"inputs\",\n",
    "                   atom=a,\n",
    "                   shape=(0,NUM_CHANNELS*NUM_PIXELS),\n",
    "                   title=\"Input images\")\n",
    "\n",
    "print(myh5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "空っぽの配列ができているので、あとは埋めるだけである。1番目の次元は「伸張できる次元」と決まっており、最初はデータが入っていないのでゼロとなっているが、追加するたびに伸びていく。さて、データを読んでから簡単な前処理をしよう。\n",
    "\n",
    "このデータを最終的に使うモデルによっては、入力の数値が大きすぎると計算が困難になる場合がある。今の画素値は$\\{0,1,\\ldots,255\\}$から値を取るが、たとえば、ロジスティック回帰のように画素値の線形和を指数関数に渡すと、膨大な数になってしまう。これを回避すべく、単位区間$[0,1]$への正規化が便利である。もともとあるVALUEを(VALUE - MIN) / (MAX - MIN)という新しい値に変換させるだけである。浮動小数点数を使うので、より大きな容量を食うことになるが、その代わりに学習用のデータとしての有用性が高い。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_inputs(x):\n",
    "    '''\n",
    "    Normalization of the inputs.\n",
    "    '''\n",
    "    return np.float32(x/255.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- BATCH 1 --\n",
      "Working... image 0\n",
      "Working... image 1000\n",
      "Working... image 2000\n",
      "Working... image 3000\n",
      "Working... image 4000\n",
      "Working... image 5000\n",
      "Working... image 6000\n",
      "Working... image 7000\n",
      "Working... image 8000\n",
      "Working... image 9000\n",
      "-- BATCH 2 --\n",
      "Working... image 0\n",
      "Working... image 1000\n",
      "Working... image 2000\n",
      "Working... image 3000\n",
      "Working... image 4000\n",
      "Working... image 5000\n",
      "Working... image 6000\n",
      "Working... image 7000\n",
      "Working... image 8000\n",
      "Working... image 9000\n"
     ]
    }
   ],
   "source": [
    "todo_batches = [1, 2]\n",
    "\n",
    "# Storage preparation.\n",
    "datum_input = np.zeros((NUM_CHANNELS*NUM_PIXELS,), dtype=np.float32)\n",
    "datum_label = np.zeros((1,), dtype=np.uint8)\n",
    "\n",
    "# Loop over the batch itinerary.\n",
    "for bt in todo_batches:\n",
    "    \n",
    "    fname = \"data_batch_\" + str(bt) + \".bin\"\n",
    "    toread = os.path.join(\"data\", \"cifar10\", \"cifar-10-batches-bin\", fname)\n",
    "    f_bin = open(toread, mode=\"rb\")\n",
    "    \n",
    "    print(\"--\", \"BATCH\", bt, \"--\")\n",
    "    \n",
    "    for i in range(NUM_BATCHIM):\n",
    "        if i % 1000 == 0:\n",
    "            print(\"Working... image\", i)\n",
    "            \n",
    "        b = f_bin.read(1)\n",
    "        datum_label[0] = int.from_bytes(b, byteorder=\"big\", signed=False)\n",
    "\n",
    "        for j in range(NUM_CHANNELS*NUM_PIXELS):\n",
    "            # Populate a long vector.\n",
    "            b = f_bin.read(1)\n",
    "            datum_input[j] = int.from_bytes(b, byteorder=\"big\", signed=False)\n",
    "            \n",
    "        # Append.\n",
    "        myh5.root.train.inputs.append([process_inputs(datum_input)]) # inputs\n",
    "        myh5.root.train.labels.append([datum_label]) # labels\n",
    "    \n",
    "    f_bin.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上記のコードを実行すると、確かに指定したバッチ数の分だけ`train`下の配列に加わったことが確認できる。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/cifar10/data.h5 (File) 'CIFAR-10 data'\n",
      "Last modif.: 'Fri Jul 27 10:39:34 2018'\n",
      "Object Tree: \n",
      "/ (RootGroup) 'CIFAR-10 data'\n",
      "/test (Group) 'Testing data'\n",
      "/test/inputs (EArray(0, 3072)) 'Input images'\n",
      "/test/labels (EArray(0, 1)) 'Label values'\n",
      "/train (Group) 'Training data'\n",
      "/train/inputs (EArray(20000, 3072)) 'Input images'\n",
      "/train/labels (EArray(20000, 1)) 'Label values'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(myh5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "まったく同様に、`test`に対してもデータを追加する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- TEST BATCH --\n",
      "Working... image 0\n",
      "Working... image 1000\n",
      "Working... image 2000\n",
      "Working... image 3000\n",
      "Working... image 4000\n",
      "Working... image 5000\n",
      "Working... image 6000\n",
      "Working... image 7000\n",
      "Working... image 8000\n",
      "Working... image 9000\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Storage preparation.\n",
    "datum_input = np.zeros((NUM_CHANNELS*NUM_PIXELS,), dtype=np.float32)\n",
    "datum_label = np.zeros((1,), dtype=np.uint8)\n",
    "\n",
    "# Loop over the batch itinerary.\n",
    "fname = \"test_batch.bin\"\n",
    "toread = os.path.join(\"data\", \"cifar10\", \"cifar-10-batches-bin\", fname)\n",
    "f_bin = open(toread, mode=\"rb\")\n",
    "    \n",
    "print(\"--\", \"TEST BATCH\", \"--\")\n",
    "    \n",
    "for i in range(NUM_BATCHIM):\n",
    "    if i % 1000 == 0:\n",
    "        print(\"Working... image\", i)\n",
    "            \n",
    "    b = f_bin.read(1)\n",
    "    datum_label[0] = int.from_bytes(b, byteorder=\"big\", signed=False)\n",
    "\n",
    "    for j in range(NUM_CHANNELS*NUM_PIXELS):\n",
    "        # Populate a long vector.\n",
    "        b = f_bin.read(1)\n",
    "        datum_input[j] = int.from_bytes(b, byteorder=\"big\", signed=False)\n",
    "            \n",
    "    # Append.\n",
    "    myh5.root.test.inputs.append([process_inputs(datum_input)]) # inputs\n",
    "    myh5.root.test.labels.append([datum_label]) # labels\n",
    "    \n",
    "f_bin.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再度、その中身を確認するとともに、ファイルとの接続を閉じる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/cifar10/data.h5 (File) 'CIFAR-10 data'\n",
      "Last modif.: 'Fri Jul 27 10:41:27 2018'\n",
      "Object Tree: \n",
      "/ (RootGroup) 'CIFAR-10 data'\n",
      "/test (Group) 'Testing data'\n",
      "/test/inputs (EArray(10000, 3072)) 'Input images'\n",
      "/test/labels (EArray(10000, 1)) 'Label values'\n",
      "/train (Group) 'Training data'\n",
      "/train/inputs (EArray(20000, 3072)) 'Input images'\n",
      "/train/labels (EArray(20000, 1)) 'Label values'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(myh5)\n",
    "myh5.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "新しい`.h5`形式のデータファイルが出来上がっているのだが、その内容が正しいか、念の為にもう一度確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 4 = deer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 6 = frog\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 0 = airplane\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LABEL: 4 = deer\n"
     ]
    }
   ],
   "source": [
    "# Read an arbitrary image.\n",
    "f = tables.open_file(\"data/cifar10/data.h5\", mode=\"r\")\n",
    "todo_vals = [1509, 1959, 1988, 9018]\n",
    "for i in range(len(todo_vals)):\n",
    "    todo = todo_vals[i]\n",
    "    myinput = f.root.train.inputs.read(start=todo, stop=(todo+1), step=1)\n",
    "    mylabel = f.root.train.labels.read(start=todo, stop=(todo+1), step=1)\n",
    "    myim = myinput.flatten().reshape((3,32,32))\n",
    "    myim = np.swapaxes(myim, 0, 1) # note the axis swapping.\n",
    "    myim = np.swapaxes(myim, 1, 2) # note the axis swapping.\n",
    "    plt.imshow(myim)\n",
    "    plt.show()\n",
    "    print(\"LABEL:\", mylabel[0][0], \"=\", LABEL_DICT[mylabel[0][0]])\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}