DNN/2. DNN_CIFAR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据准备\n",
    "首先看一下CIFAR-10数据是怎么读取的，下面的函数是根据官网示例改编的函数，其直接返回ndarray形式的X与Y。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def unpickle(file):\n",
    "    '''\n",
    "    CIFAR-10数据读取函数\n",
    "    '''\n",
    "    import pickle\n",
    "    with open(file, 'rb') as fd:\n",
    "        data = pickle.load(fd, encoding='bytes')\n",
    "    return data[b'data'], np.array(data[b'labels'])\n",
    "\n",
    "\n",
    "data, target = unpickle('../dataset/cifar-10-batches-py/data_batch_1')\n",
    "\n",
    "plt.clf()\n",
    "# 原数据的维度顺序为(n_samples,n_channels,width,height)，绘图时需要把channel转置到最后\n",
    "plt.imshow(data[0].reshape((3, 32, 32)).transpose((1, 2, 0)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于深度学习中的大型数据，mini-batch式学习是很有必要的，并且还会频繁对数据做一些其他的操作。所以定义一个专门的数据类用于管理数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "\n",
    "class CifarData:\n",
    "    def __init__(self, paths, batch_size=32, normalize=False, shuffle=False):\n",
    "        '''\n",
    "        paths: 文件路径\n",
    "        '''\n",
    "        self._data = list()\n",
    "        self._target = list()\n",
    "        self._n_samples = 0\n",
    "        self.n_features = 0\n",
    "\n",
    "        self._idx = 0    # mini-batch的游标\n",
    "        self._batch_size = batch_size\n",
    "\n",
    "        self._load(paths)\n",
    "\n",
    "        if shuffle:\n",
    "            self._shuffle_data()\n",
    "        if normalize:\n",
    "            self._normalize_data()\n",
    "\n",
    "        print(self._data.shape, self._target.shape)\n",
    "\n",
    "    def _load(self, paths):\n",
    "        '''\n",
    "        载入数据\n",
    "        '''\n",
    "        for path in paths:\n",
    "            data, labels = unpickle(path)\n",
    "            self._data.append(data)\n",
    "            self._target.append(labels)\n",
    "\n",
    "        # 将所有批次的数据拼接起来\n",
    "        self._data, self._target = np.vstack(\n",
    "            self._data), np.hstack(self._target)\n",
    "\n",
    "        self._n_samples, self.n_features = self._data.shape[0], self._data.shape[1]\n",
    "\n",
    "    def _shuffle_data(self):\n",
    "        '''\n",
    "        打乱数据\n",
    "        '''\n",
    "        idxs = np.random.permutation(self._n_samples)\n",
    "        self._data = self._data[idxs]\n",
    "        self._target = self._target[idxs]\n",
    "\n",
    "    def _normalize_data(self):\n",
    "        scaler = StandardScaler()\n",
    "        self._data = scaler.fit_transform(self._data)\n",
    "\n",
    "    def next_batch(self):\n",
    "        '''\n",
    "        生成mini-batch\n",
    "        '''\n",
    "        while self._idx < self._n_samples:\n",
    "            yield self._data[self._idx: (self._idx+self._batch_size)], self._target[self._idx: (self._idx+self._batch_size)]\n",
    "            self._idx += self._batch_size\n",
    "\n",
    "        self._idx = 0\n",
    "        self._shuffle_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:595: DataConversionWarning: Data with input dtype uint8 was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:595: DataConversionWarning: Data with input dtype uint8 was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50000, 3072) (50000,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:595: DataConversionWarning: Data with input dtype uint8 was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 3072) (10000,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:595: DataConversionWarning: Data with input dtype uint8 was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "CIFAR_DIR = \"../dataset/cifar-10-batches-py/\"\n",
    "train_filenames = [os.path.join(\n",
    "    CIFAR_DIR, 'data_batch_{}'.format(i)) for i in range(1, 6)]\n",
    "test_filenames = [os.path.join(CIFAR_DIR, 'test_batch')]\n",
    "\n",
    "batch_size = 32\n",
    "train_data = CifarData(\n",
    "    train_filenames, batch_size=batch_size, normalize=True, shuffle=True)\n",
    "test_data = CifarData(test_filenames, batch_size=batch_size,\n",
    "                      normalize=True, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 网络结构设计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入层单元数为(数据特征)，设计隐藏层单元数为100、50，输出单元数为10(多分类任务)\n",
    "\n",
    "unit_I = train_data.n_features    # 输入层的单元数，与特征数相等\n",
    "unit_h1 = 100    # 第一层隐藏层的单元数\n",
    "unit_h2 = 50\n",
    "unit_O = 10    # 输出层单元数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 搭建网络\n",
    "TensorFlow自身提供了增加层数的方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-6-af9cd9c4782c>:7: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/python/ops/losses/losses_impl.py:209: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    }
   ],
   "source": [
    "# 输入必须是可由用户指定的，所以设为placeholder\n",
    "X = tf.placeholder(tf.float32, [None, unit_I])  # 数据的样本数不指定，只指定特征数\n",
    "Y = tf.placeholder(tf.int64, [None])    # 目标值为列向量，int64为了兼容\n",
    "\n",
    "# 网络结构图\n",
    "with tf.name_scope('DNN'):\n",
    "    hidden1 = tf.layers.dense(X, unit_h1, activation=tf.nn.relu)\n",
    "    hidden2 = tf.layers.dense(hidden1, unit_h2, activation=tf.nn.relu)\n",
    "    Y_pred = tf.layers.dense(hidden2, unit_O)\n",
    "\n",
    "# 评估子图\n",
    "with tf.name_scope('Eval'):\n",
    "    # 计算一维向量与onehot向量之间的损失\n",
    "    loss = tf.losses.sparse_softmax_cross_entropy(labels=Y, logits=Y_pred)\n",
    "    predict = tf.argmax(Y_pred, 1)\n",
    "    accuracy = tf.reduce_mean(tf.cast(tf.equal(predict, Y), tf.float32))\n",
    "\n",
    "# 优化图\n",
    "with tf.name_scope('train_op'):\n",
    "    lr = 1e-3\n",
    "    train_op = tf.train.AdamOptimizer(lr).minimize(loss)\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True    # 按需使用显存"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, batch_loss: 1.8539013862609863, batch_acc: 0.375\n",
      "epoch: 1, batch_loss: 2.1398262977600098, batch_acc: 0.34375\n",
      "epoch: 1, batch_loss: 1.2638787031173706, batch_acc: 0.5625\n",
      "epoch: 2, batch_loss: 1.2767705917358398, batch_acc: 0.46875\n",
      "epoch: 3, batch_loss: 1.144681692123413, batch_acc: 0.59375\n",
      "epoch: 3, test_acc: 0.46575480699539185\n",
      "epoch: 3, batch_loss: 1.4559743404388428, batch_acc: 0.53125\n",
      "epoch: 4, batch_loss: 1.0261310338974, batch_acc: 0.65625\n",
      "epoch: 5, batch_loss: 1.0441352128982544, batch_acc: 0.65625\n",
      "epoch: 5, batch_loss: 1.1458637714385986, batch_acc: 0.625\n",
      "epoch: 6, batch_loss: 1.600606083869934, batch_acc: 0.5\n",
      "epoch: 6, test_acc: 0.5044928193092346\n",
      "epoch: 7, batch_loss: 0.6468024253845215, batch_acc: 0.875\n",
      "epoch: 7, batch_loss: 1.311150312423706, batch_acc: 0.5\n",
      "epoch: 8, batch_loss: 1.0780742168426514, batch_acc: 0.6875\n",
      "epoch: 8, batch_loss: 1.5215224027633667, batch_acc: 0.53125\n",
      "epoch: 9, batch_loss: 1.3531839847564697, batch_acc: 0.53125\n",
      "epoch: 9, test_acc: 0.506489634513855\n",
      "epoch: 10, batch_loss: 1.18514084815979, batch_acc: 0.5\n",
      "epoch: 10, batch_loss: 0.9860854744911194, batch_acc: 0.625\n",
      "epoch: 11, batch_loss: 1.7611647844314575, batch_acc: 0.5\n",
      "epoch: 12, batch_loss: 1.246474027633667, batch_acc: 0.6875\n",
      "epoch: 12, batch_loss: 1.172136664390564, batch_acc: 0.53125\n",
      "epoch: 12, test_acc: 0.5022963285446167\n",
      "epoch: 13, batch_loss: 0.8340892791748047, batch_acc: 0.6875\n",
      "epoch: 14, batch_loss: 1.061861276626587, batch_acc: 0.625\n",
      "epoch: 14, batch_loss: 0.9322909116744995, batch_acc: 0.59375\n",
      "epoch: 15, batch_loss: 0.6713175773620605, batch_acc: 0.8125\n",
      "epoch: 15, batch_loss: 0.9016571044921875, batch_acc: 0.71875\n",
      "epoch: 15, test_acc: 0.5038937926292419\n",
      "epoch: 16, batch_loss: 1.0425465106964111, batch_acc: 0.75\n",
      "epoch: 17, batch_loss: 0.9375545978546143, batch_acc: 0.71875\n",
      "epoch: 17, batch_loss: 1.2366777658462524, batch_acc: 0.71875\n",
      "epoch: 18, batch_loss: 0.7009583711624146, batch_acc: 0.75\n",
      "epoch: 19, batch_loss: 1.4150614738464355, batch_acc: 0.40625\n",
      "epoch: 19, test_acc: 0.5087859630584717\n",
      "epoch: 19, batch_loss: 0.8226215243339539, batch_acc: 0.71875\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(config=config) as sess:\n",
    "    sess.run(init)\n",
    "    epochs = 20\n",
    "\n",
    "    batch_cnt = 0\n",
    "    for epoch in range(epochs):\n",
    "        for batch_data, batch_labels in train_data.next_batch():\n",
    "            batch_cnt += 1\n",
    "            loss_val, acc_val, _ = sess.run([loss, accuracy, train_op],\n",
    "                                            feed_dict={X: batch_data,\n",
    "                                                       Y: batch_labels})\n",
    "\n",
    "            # 每1000batch输出一次信息\n",
    "            if (batch_cnt+1) % 1000 == 0:\n",
    "                print('epoch: {}, batch_loss: {}, batch_acc: {}'\n",
    "                      .format(epoch, loss_val, acc_val))\n",
    "\n",
    "            # 每5000batch做一次验证\n",
    "            if (batch_cnt+1) % 5000 == 0:\n",
    "                all_test_acc_val = list()\n",
    "                for test_batch_data, test_batch_labels in test_data.next_batch():\n",
    "                    test_acc_val = sess.run([accuracy],\n",
    "                                            feed_dict={X: test_batch_data,\n",
    "                                                       Y: test_batch_labels})\n",
    "                    all_test_acc_val.append(test_acc_val)\n",
    "                test_acc = np.mean(all_test_acc_val)\n",
    "                print('epoch: {}, test_acc: {}'.format(epoch, test_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}