AE/Auto_Encoder.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n",
      "/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": [
    "# 数据准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "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'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n",
      "/usr/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "# 在这里经测试发现MinMaxScaler比StandardScaler效果更好\n",
    "# 并且plt.imshow()支持[0,1]的输入\n",
    "from sklearn.preprocessing import MinMaxScaler\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.scaler = MinMaxScaler()    # 缩放器，用于逆缩放恢复原始数据\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",
    "        self._data = self.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:590: DataConversionWarning: Data with input dtype uint8 was converted to float64 by MinMaxScaler.\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:590: DataConversionWarning: Data with input dtype uint8 was converted to float64 by MinMaxScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 3072) (10000,)\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",
    "\n",
    "# 为了便于后期的可视化\n",
    "train_data = CifarData(train_filenames, batch_size=batch_size,\n",
    "                       normalize=True, shuffle=True)\n",
    "test_data = CifarData(test_filenames, batch_size=batch_size,\n",
    "                      normalize=True, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 网络结构设计\n",
    "AE是一个无监督学习器，网络结构很简单，单层自编码器的结构为：输入层-编码层-解码(输出)层，loss即为输入层与解码层的区别。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "unit_I = train_data.n_features    # 输入单元数，等于特征数\n",
    "\n",
    "unit_h = 512    # 编码尺寸\n",
    "\n",
    "unit_O = unit_I    # 输出单元数，类别数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 搭建网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-6-c752dfbd2c29>:6: 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:667: 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",
    "\n",
    "with tf.name_scope('AE'):\n",
    "    encoder = tf.layers.dense(X, unit_h, activation=tf.nn.relu)\n",
    "    decoder = tf.layers.dense(encoder, unit_O, activation=None)\n",
    "\n",
    "# 评估图\n",
    "with tf.name_scope('Eval'):\n",
    "    # 计算一维向量与onehot向量之间的损失\n",
    "    loss = tf.losses.mean_squared_error(labels=X, predictions=decoder)\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: 0.010108386166393757\n",
      "epoch: 1, batch_loss: 0.008593515492975712\n",
      "epoch: 1, batch_loss: 0.007346900179982185\n",
      "epoch: 2, batch_loss: 0.008170894347131252\n",
      "epoch: 3, batch_loss: 0.00800139456987381\n",
      "epoch: 3, test_loss: 0.00846326444298029\n",
      "epoch: 3, batch_loss: 0.008797270245850086\n",
      "epoch: 4, batch_loss: 0.010427377186715603\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(config=config) as sess:\n",
    "    sess.run(init)\n",
    "    epochs = 5\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,  _ = sess.run(\n",
    "                [loss, train_op],\n",
    "                feed_dict={\n",
    "                    X: batch_data,\n",
    "                    Y: batch_labels})\n",
    "\n",
    "            # 每1000batch输出一次信息\n",
    "            if (batch_cnt+1) % 1000 == 0:\n",
    "                print('epoch: {}, batch_loss: {}'.format(\n",
    "                    epoch, loss_val))\n",
    "\n",
    "            # 每5000batch做一次验证\n",
    "            if (batch_cnt+1) % 5000 == 0:\n",
    "                all_test_loss_val = list()\n",
    "                for test_batch_data, test_batch_labels in test_data.next_batch():\n",
    "                    test_loss_val = sess.run(\n",
    "                        [loss],\n",
    "                        feed_dict={\n",
    "                            X: test_batch_data,\n",
    "                            Y: test_batch_labels\n",
    "                        })\n",
    "                    all_test_loss_val.append(test_loss_val)\n",
    "                test_loss = np.mean(all_test_loss_val)\n",
    "                print('epoch: {}, test_loss: {}'.format(epoch, test_loss))\n",
    "\n",
    "    # 训练完后取出一批测试集做预测，用于可视化\n",
    "    # 注意这里使用的是测试集\n",
    "    X_raw = None\n",
    "    for x, _ in test_data.next_batch():\n",
    "        X_raw = x\n",
    "        break\n",
    "    X_rec = sess.run(decoder, feed_dict={X: X_raw})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "\n",
    "val_idx = random.randrange(len(X_raw))    # 随机选出一张用于可视化的图片\n",
    "\n",
    "\n",
    "plt.clf()\n",
    "fig, axs = plt.subplots(1, 2, figsize=(2, 1))\n",
    "axs[0].imshow(X_raw[val_idx].reshape((3, 32, 32)).transpose((1, 2, 0)))\n",
    "axs[1].imshow(X_rec[val_idx].reshape((3, 32, 32)).transpose((1, 2, 0)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后还是想提一句的是，这里可视化用的是测试集中的图片，一般网上实现AE使用的都是训练集的图片。当然，使用训练集图片可以查看AE模型的压缩效果，因为AE本来就是用于压缩数据。当使用测试集图片时，体现的是AE模型在像素级别上的推理能力。\n",
    "\n",
    "对于多层AE模型，简单的堆叠全连接层即可，不过注意，encoder层的单元数是越来越少的，而decoder层的单元数是越来越多的。"
   ]
  }
 ],
 "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
}