Chap15 - Autoencoder

ExcelsiorCJH · Oct 30, 2018 · 55215b2 · 55215b2
1 parent 9484b9e
commit 55215b2
Show file tree

Hide file tree

Showing 3 changed files with 291 additions and 0 deletions.
diff --git a/Chap15-Autoencoders/Chap15-Autoencoders.ipynb b/Chap15-Autoencoders/Chap15-Autoencoders.ipynb
@@ -0,0 +1,257 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Chap15 - 오토인코더 - Autoencoder\n",
+    "\n",
+    "\n",
+    "저번 포스팅 [07. 순환 신경망, RNN](http://excelsior-cjh.tistory.com/183)에서는 자연어, 음성신호, 주식과 같은 연속적인 데이터에 적합한 모델인 RNN, LSTM, GRU에 대해 알아보았다. 이번 포스팅에서는 딥러닝에서의 비지도 학습(unsupervised learning)이라고 할 수 있는 **오코인코더**(autoencoder)에 대해 알아보도록 하자."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. 오토인코더 란?\n",
+    "\n",
+    "오토인코더(Autoencoder)는 아래의 그림과 같이 단순히 입력을 출력으로 복사하는 신경망이다. 어떻게 보면 간단한 신경망처럼 보이지만 네트워크에 여러가지 방법으로 제약을 줌으로써 어려운 신경망으로 만든다. 예를들어 아래 그림처럼 hidden layer의 뉴런 수를 input layer(입력층) 보다 작게해서 데이터를 압축(차원을 축소)한다거나, 입력 데이터에 노이즈(noise)를 추가한 후 원본 입력을 복원할 수 있도록 네트워크를 학습시키는 등 다양한 오토인코더가 있다. 이러한 제약들은 오토인코더가 단순히 입력을 바로 출력으로 복사하지 못하도록 방지하며, 데이터를 효율적으로 표현(representation)하는 방법을 학습하도록 제어한다.\n",
+    "\n",
+    "\n",
+    "\n",
+    "![](./images/ae01.png)\n",
+    "\n",
+    "\n",
+    "\n",
+    "오토인코더는 위의 그림에서 볼 수 있듯이 항상 인코더(encoder)와 디코더(decoder), 두 부분으로 구성되어 있다.\n",
+    "\n",
+    "- **인코더(encoder)** : 인지 네트워크(recognition network)라고도 하며, 입력을 내부 표현으로 변환한다.\n",
+    "- **디코더(decoder)** : 생성 네트워크(generative nework)라고도 하며, 내부 표현을 출력으로 변환한다.\n",
+    "\n",
+    "오토인코더는 위의 그림에서 처럼, 입력과 출력층의 뉴런 수가 동일하다는 것만 제외하면 일반적인 MLP(Multi-Layer Perceptron)과 동일한 구조이다. 오토인코더는 입력을 재구성하기 때문에 출력을 **재구성(reconstruction)**이라고도 하며, 손실함수는 입력과 재구성(출력)의 차이를 가지고 계산한다. \n",
+    "\n",
+    "위 그림의 오토인토더는 히든 레이어의 뉴런(노드, 유닛)이 입력층보다 작으므로 입력이 저차원으로 표현되는데, 이러한 오토인코더를 **Undercomplete Autoencoder**라고 한다. undercomplete 오토인코더는 저차원을 가지는 히든 레이어에 의해 입력을 그대로 출력으로 복사할 수 없기 때문에, 출력이 입력과 같은 것을 출력하기 위해 학습해야 한다. 이러한 학습을 통해 undercomplete 오토인코더는 입력 데이터에서 가장 중요한 특성(feature)을 학습하도록 만든다."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "\n",
+    "# 일관된 출력을 위해 유사난수 초기화\n",
+    "def reset_graph(seed=42):\n",
+    "    tf.reset_default_graph()\n",
+    "    tf.set_random_seed(seed)\n",
+    "    np.random.seed(seed)\n",
+    "\n",
+    "%matplotlib inline\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.rcParams['axes.labelsize'] = 14\n",
+    "plt.rcParams['xtick.labelsize'] = 12\n",
+    "plt.rcParams['ytick.labelsize'] = 12\n",
+    "\n",
+    "# 한글출력\n",
+    "# matplotlib.rc('font', family='AppleGothic')  # MacOS\n",
+    "matplotlib.rc('font', family='Malgun Gothic')  # Windows\n",
+    "plt.rcParams['axes.unicode_minus'] = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### functions for plotting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_image(image, shape=[28, 28]):\n",
+    "    plt.imshow(image.reshape(shape), cmap=\"Greys\", interpolation=\"nearest\")\n",
+    "    plt.axis(\"off\")\n",
+    "    \n",
+    "def plot_multiple_images(images, n_rows, n_cols, pad=2):\n",
+    "    images = images - images.min()  # 최소값을 0으로 만들어 패딩이 하얗게 보이도록 합니다.\n",
+    "    w,h = images.shape[1:]\n",
+    "    image = np.zeros(((w+pad)*n_rows+pad, (h+pad)*n_cols+pad))\n",
+    "    for y in range(n_rows):\n",
+    "        for x in range(n_cols):\n",
+    "            image[(y*(h+pad)+pad):(y*(h+pad)+pad+h),(x*(w+pad)+pad):(x*(w+pad)+pad+w)] = images[y*n_cols+x]\n",
+    "    plt.imshow(image, cmap=\"Greys\", interpolation=\"nearest\")\n",
+    "    plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Undercomplete Linear 오토인코더로 PCA 구현하기"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3D 데이터셋을 만듦\n",
+    "import numpy.random as rnd\n",
+    "\n",
+    "rnd.seed(4)\n",
+    "m = 200\n",
+    "w1, w2 = 0.1, 0.3\n",
+    "noise = 0.1\n",
+    "\n",
+    "angles = rnd.rand(m) * 3 * np.pi / 2 - 0.5\n",
+    "data = np.empty((m, 3))\n",
+    "data[:, 0] = np.cos(angles) + np.sin(angles)/2 + noise * rnd.randn(m) / 2\n",
+    "data[:, 1] = np.sin(angles) * 0.7 + noise * rnd.randn(m) / 2\n",
+    "data[:, 2] = data[:, 0] * w1 + data[:, 1] * w2 + noise * rnd.randn(m)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 데이터 정규화\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "\n",
+    "scaler = StandardScaler()\n",
+    "X_train = scaler.fit_transform(data[:100])\n",
+    "X_test = scaler.transform(data[100:])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reset_graph()\n",
+    "\n",
+    "################\n",
+    "# layer params #\n",
+    "################\n",
+    "n_inputs = 3\n",
+    "n_hidden = 2  # coding units\n",
+    "n_outputs = n_inputs\n",
+    "\n",
+    "# autoencoder\n",
+    "X = tf.placeholder(tf.float32, shape=[None, n_inputs])\n",
+    "hidden = tf.layers.dense(X, n_hidden)\n",
+    "outputs = tf.layers.dense(hidden, n_outputs)\n",
+    "\n",
+    "################\n",
+    "# Train params #\n",
+    "################\n",
+    "learning_rate = 0.01\n",
+    "n_iterations = 1000\n",
+    "pca = hidden\n",
+    "\n",
+    "# loss\n",
+    "reconstruction_loss = tf.reduce_mean(tf.square(outputs - X))  # MSE\n",
+    "# optimizer\n",
+    "train_op = tf.train.AdamOptimizer(learning_rate).minimize(reconstruction_loss)\n",
+    "\n",
+    "with tf.Session() as sess:\n",
+    "    tf.global_variables_initializer().run()\n",
+    "    for iteration in range(n_iterations):\n",
+    "        train_op.run(feed_dict={X: X_train})\n",
+    "    pca_val = pca.eval(feed_dict={X: X_test})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pca_val.shape : (100, 2)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 288x216 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(4,3))\n",
+    "plt.plot(pca_val[:,0], pca_val[:, 1], \"b.\")\n",
+    "plt.xlabel(\"$z_1$\", fontsize=18)\n",
+    "plt.ylabel(\"$z_2$\", fontsize=18, rotation=0)\n",
+    "print('pca_val.shape :', pca_val.shape)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "tensorflow",
+   "language": "python",
+   "name": "tensorflow"
+  },
+  "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Chap15-Autoencoders/Chap15-Autoencoders.md b/Chap15-Autoencoders/Chap15-Autoencoders.md
@@ -0,0 +1,34 @@
+# 08. 오토인코더 - Autoencoder
+
+
+
+저번 포스팅 [07. 순환 신경망, RNN](http://excelsior-cjh.tistory.com/183)에서는 자연어, 음성신호, 주식과 같은 연속적인 데이터에 적합한 모델인 RNN, LSTM, GRU에 대해 알아보았다. 이번 포스팅에서는 딥러닝에서의 비지도 학습(unsupervised learning)이라고 할 수 있는 **오코인코더**(autoencoder)에 대해 알아보도록 하자.
+
+
+
+## 1. 오토인코더 란?
+
+오토인코더(Autoencoder)는 아래의 그림과 같이 단순히 입력을 출력으로 복사하는 신경망이다. 어떻게 보면 간단한 신경망처럼 보이지만 네트워크에 여러가지 방법으로 제약을 줌으로써 어려운 신경망으로 만든다. 예를들어 아래 그림처럼 hidden layer의 뉴런 수를 input layer(입력층) 보다 작게해서 데이터를 압축(차원을 축소)한다거나, 입력 데이터에 노이즈(noise)를 추가한 후 원본 입력을 복원할 수 있도록 네트워크를 학습시키는 등 다양한 오토인코더가 있다. 이러한 제약들은 오토인코더가 단순히 입력을 바로 출력으로 복사하지 못하도록 방지하며, 데이터를 효율적으로 표현(representation)하는 방법을 학습하도록 제어한다.
+
+
+
+![](./images/ae01.png)
+
+
+
+오토인코더는 위의 그림에서 볼 수 있듯이 항상 인코더(encoder)와 디코더(decoder), 두 부분으로 구성되어 있다.
+
+- **인코더(encoder)** : 인지 네트워크(recognition network)라고도 하며, 입력을 내부 표현으로 변환한다.
+- **디코더(decoder)** : 생성 네트워크(generative nework)라고도 하며, 내부 표현을 출력으로 변환한다.
+
+오토인코더는 위의 그림에서 처럼, 입력과 출력층의 뉴런 수가 동일하다는 것만 제외하면 일반적인 MLP(Multi-Layer Perceptron)과 동일한 구조이다. 오토인코더는 입력을 재구성하기 때문에 출력을 **재구성(reconstruction)**이라고도 하며, 손실함수는 입력과 재구성(출력)의 차이를 가지고 계산한다. 
+
+위 그림의 오토인토더는 히든 레이어의 뉴런(노드, 유닛)이 입력층보다 작으므로 입력이 저차원으로 표현되는데, 이러한 오토인코더를 **Undercomplete Autoencoder**라고 한다. undercomplete 오토인코더는 저차원을 가지는 히든 레이어에 의해 입력을 그대로 출력으로 복사할 수 없기 때문에, 출력이 입력과 같은 것을 출력하기 위해 학습해야 한다. 이러한 학습을 통해 undercomplete 오토인코더는 입력 데이터에서 가장 중요한 특성(feature)을 학습하도록 만든다.
+
+
+
+## 2. Undercomplete Linear 오토인코더로 PCA 구현하기
+
+위에서 살펴본 Undercomplete 오토인코더에서 활성화 함수를 sigmoid, ReLU같은 비선형(non-linear)함수가 아니라 선형(linear) 함수를 사용하고, 손실함수로 MSE(Mean Squared Error)를 사용할 경우에는 [PCA](http://excelsior-cjh.tistory.com/167?category=918734)라고 볼 수 있다.
+
+아래의 예제코드는 가상의 3차원 데이터셋을 undercomplete 오토인코더를 사용해 2차원으로 축소하는 PCA를 수행한 코드이다. 전체 코드는 []
diff --git a/Chap15-Autoencoders/images/ae01.png b/Chap15-Autoencoders/images/ae01.png