07-cnn-resnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()\n",
    "import os\n",
    "import pickle\n",
    "import numpy as np\n",
    "\n",
    "CIFAR_DIR = \"./cifar-10-batches-py\"\n",
    "print(os.listdir(CIFAR_DIR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(filename):\n",
    "    \"\"\"read data from data file.\"\"\"\n",
    "    with open(filename, 'rb') as f:\n",
    "        u = pickle._Unpickler(f)\n",
    "        u.encoding = 'latin1'\n",
    "        data = u.load()\n",
    "        return data['data'], data['labels']\n",
    "\n",
    "class CifarData:\n",
    "    def __init__(self, filenames, need_shuffle):\n",
    "        all_data = []\n",
    "        all_labels = []\n",
    "        for filename in filenames:\n",
    "            data, labels = load_data(filename)\n",
    "            all_data.append(data)\n",
    "            all_labels.append(labels)\n",
    "        self._data = np.vstack(all_data)\n",
    "        self._data = self._data / 127.5 - 1\n",
    "        self._labels = np.hstack(all_labels)\n",
    "        \n",
    "        print(self._data.shape)\n",
    "        print(self._labels.shape)\n",
    "        \n",
    "        self._num_examples = self._data.shape[0]\n",
    "        self._need_shuffle = need_shuffle\n",
    "        self._indicator = 0\n",
    "        if self._need_shuffle:\n",
    "            self._shuffle_data()\n",
    "    \n",
    "    def _shuffle_data(self):\n",
    "        p = np.random.permutation(self._num_examples)\n",
    "        self._data = self._data[p]\n",
    "        self._labels = self._labels[p]\n",
    "        \n",
    "    def next_batch(self, batch_size):\n",
    "        \"\"\"return batch_size examples as a batch\"\"\"\n",
    "        end_indicator = self._indicator + batch_size\n",
    "        if end_indicator > self._num_examples:\n",
    "            if self._need_shuffle:\n",
    "                self._shuffle_data()\n",
    "                self._indicator = 0\n",
    "                end_indicator = batch_size\n",
    "            else:\n",
    "                raise Exception(\"have no more examples\")\n",
    "        if end_indicator > self._num_examples:\n",
    "            raise Exception(\"batch size is larger than all examples size\")\n",
    "        batch_data = self._data[self._indicator: end_indicator]\n",
    "        batch_labels = self._labels[self._indicator: end_indicator]\n",
    "        self._indicator = end_indicator\n",
    "        return batch_data, batch_labels\n",
    "\n",
    "train_filenames = [os.path.join(CIFAR_DIR, \"data_batch_%d\" % i) for i in range(1, 6)]\n",
    "test_filenames = [os.path.join(CIFAR_DIR, \"test_batch\")]\n",
    "\n",
    "train_data = CifarData(train_filenames, True)\n",
    "\n",
    "# batch_data, batch_labels = train_data.next_batch(10)\n",
    "# print(batch_data)\n",
    "# print(batch_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def residual_block(x, output_channel):\n",
    "    \"\"\"残差连接residual connection implementation\"\"\"\n",
    "    input_channel = x.get_shape().as_list()[-1]\n",
    "    if input_channel * 2 == output_channel:\n",
    "        increase_dim = True\n",
    "        strides = (2, 2)\n",
    "    elif input_channel == output_channel:\n",
    "        increase_dim = False\n",
    "        strides = (1, 1)\n",
    "    else:\n",
    "        raise Exception(\"input channel can't match output channel\")\n",
    "    conv1 = tf.layers.conv2d(x,\n",
    "                            output_channel,\n",
    "                            (3, 3),\n",
    "                            strides = strides,\n",
    "                            padding = 'same',\n",
    "                            activation = tf.nn.relu,\n",
    "                            name = 'conv1')\n",
    "    conv2 = tf.layers.conv2d(conv1,\n",
    "                            output_channel,\n",
    "                            (3, 3),\n",
    "                            strides = (1, 1),\n",
    "                            padding = 'same',\n",
    "                            activation = tf.nn.relu,\n",
    "                            name = 'conv2')\n",
    "    if increase_dim:\n",
    "        # [None, image_width, image_height, channel] -> [,,,channel * 2]\n",
    "        pooled_x = tf.layers.average_pooling2d(x,\n",
    "                                              (2, 2),\n",
    "                                              (2, 2),\n",
    "                                              padding = 'valid')\n",
    "        padded_x = tf.pad(pooled_x,\n",
    "                         [[0, 0],\n",
    "                          [0, 0],\n",
    "                          [0, 0],\n",
    "                          [input_channel // 2, input_channel // 2]])\n",
    "    else:\n",
    "        padded_x = x\n",
    "    output_x = conv2 + padded_x\n",
    "    return output_x\n",
    "\n",
    "def res_net(x,\n",
    "            num_residual_blocks,\n",
    "            num_filter_base,\n",
    "            class_num\n",
    "            ):\n",
    "    \"\"\"残差网络residual network implementation\"\"\"\n",
    "    num_subsampling = len(num_residual_blocks)\n",
    "    layers = []\n",
    "    # x: [None, width, height, channel] -> [width, height, channel]\n",
    "    input_size = x.get_shape().as_list()[1:]\n",
    "    with tf.variable_scope('conv0'):\n",
    "        conv0 = tf.layers.conv2d(x,\n",
    "                                num_filter_base,\n",
    "                                (3, 3),\n",
    "                                strides = (1, 1),\n",
    "                                padding = 'same',\n",
    "                                activation = tf.nn.relu,\n",
    "                                name = 'conv0')\n",
    "        layers.append(conv0)\n",
    "    # num_subsampling = 4, sample_id = [0, 1, 2, 3]\n",
    "    for sample_id in range(num_subsampling):\n",
    "        for i in range(num_residual_blocks[sample_id]):\n",
    "            with tf.variable_scope(\"conv%d_%d\" % (sample_id, i)):\n",
    "                conv = residual_block(\n",
    "                    layers[-1],\n",
    "                    num_filter_base * (2 ** sample_id))\n",
    "                layers.append(conv)\n",
    "    multiplier = 2 ** (num_subsampling - 1)\n",
    "    assert layers[-1].get_shape().as_list()[1:] \\\n",
    "        == [input_size[0] / multiplier,\n",
    "            input_size[1] / multiplier,\n",
    "            num_filter_base * multiplier]\n",
    "    with tf.variable_scope('fc'):\n",
    "        # layer[-1].shape : [None, width, height, channel]\n",
    "        global_pool = tf.reduce_mean(layers[-1], [1, 2])\n",
    "        logits = tf.layers.dense(global_pool, class_num)\n",
    "        layers.append(logits)\n",
    "    return layers[-1]\n",
    "\n",
    "\n",
    "# [None, 3072]\n",
    "x = tf.placeholder(tf.float32, [None, 3072])\n",
    "\n",
    "# [None]\n",
    "y = tf.placeholder(tf.int64, [None])\n",
    "\n",
    "x_image = tf.reshape(x, [-1, 3, 32, 32])\n",
    "\n",
    "# 32 * 32\n",
    "x_image = tf.transpose(x_image, perm=[0, 2, 3, 1])\n",
    "\n",
    "y_ = res_net(x_image, [2, 3, 2], 32, 10)\n",
    "\n",
    "\n",
    "# 交叉熵损失\n",
    "loss = tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_)\n",
    "# y_ -> softmax\n",
    "# y -> one_hot\n",
    "# loss = ylogy_\n",
    "\n",
    "\n",
    "# indices\n",
    "predict = tf.argmax(y_, 1)\n",
    "# [1, 0, 1, 1, 0, 1, 0 ...]\n",
    "correct_prediction = tf.equal(predict, y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float64))\n",
    "\n",
    "with tf.name_scope('train_op'):\n",
    "    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "batch_size = 20\n",
    "train_steps = 5000\n",
    "test_steps = 100\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    for i in range(train_steps):\n",
    "        batch_data, batch_labels = train_data.next_batch(batch_size)\n",
    "        loss_val, acc_val, _ = sess.run(\n",
    "            [loss, accuracy, train_op],\n",
    "            feed_dict={\n",
    "                x: batch_data,\n",
    "                y: batch_labels})\n",
    "        if (i + 1) % 100 == 0:\n",
    "            print('[Train] step: %d, loss: %4.5f, acc: %4.5f' % (i + 1, loss_val, acc_val))\n",
    "        if (i + 1) % 1000 == 0:\n",
    "            test_data = CifarData(test_filenames, False)\n",
    "            all_test_acc_val = []\n",
    "            for j in range(test_steps):\n",
    "                test_batch_data, test_batch_labels = test_data.next_batch(batch_size)\n",
    "                test_acc_val = sess.run(\n",
    "                    [accuracy],\n",
    "                    feed_dict = {\n",
    "                        x: test_batch_data,\n",
    "                        y: test_batch_labels\n",
    "                    })\n",
    "                all_test_acc_val.append(test_acc_val)\n",
    "            test_acc = np.mean(all_test_acc_val)\n",
    "            print('[Test ] step: %d, acc: %4.5f' % (i + 1, test_acc))"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}