CV_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b1e1f497",
   "metadata": {},
   "source": [
    "## 선형회귀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fa79171e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2b6a8165",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 선형회귀 모델(wx + b)을 위한 tf.Variable을 선언. linear regression은 차원이 1차원이므로 shape을 1로 지정\n",
    "W= tf.Variable(tf.random.normal(shape=[1]))\n",
    "b = tf.Variable(tf.random.normal(shape=[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d612aa38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모델 함수 정의\n",
    "def linear_model(x):\n",
    "    return W*x + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "393ef63b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#손실함수 정의, MSE 사용\n",
    "def mse_loss(y_pred, y):\n",
    "    return tf.reduce_mean(tf.square(y_pred - y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8a037033",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화를 위한 gradient decent optimizer 정의\n",
    "optimizer = tf.optimizers.SGD(0.01) #stochastic gradient decent 사용한 듯, learning rate 0.01로 설정\n",
    "# https://www.tensorflow.org/api_docs/python/tf/keras/optimizers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "784d5781",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화 함수\n",
    "def train_step(x,y):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = linear_model(x)\n",
    "        loss = mse_loss(y_pred, y)\n",
    "    gradients = tape.gradient(loss, [W,b])\n",
    "    optimizer.apply_gradients(zip(gradients, [W,b])) # zip은 리스트의 개별 요소들을 인덱스 순서에 맞게 쌍으로 묶어준다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c94cbb20",
   "metadata": {},
   "source": [
    "### training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "45002257",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 트레이닝을 위한 입력값과 출력값을 준비\n",
    "x_train = [1,2,3,4]\n",
    "y_train = [2,4,6,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "165a3244",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 경사 하강법 1000번\n",
    "for i in range(1000):\n",
    "    train_step(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3a6f815",
   "metadata": {},
   "source": [
    "### test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "728bb2a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test = [3.5,5,5.5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ccbd3701",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7.0031505 10.011592  11.014405  12.017219 ]\n"
     ]
    }
   ],
   "source": [
    "print(linear_model(x_test).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8faabb69",
   "metadata": {},
   "source": [
    "## Softmax Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4da87658",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5ab41bf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#MNIST 데이터 다운로드, numpy array 형태로 넘어옴.\n",
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4aede496",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 이미지들을 float32 데이터 타입으로 변경\n",
    "x_train, x_test = x_train.astype('float32'), x_test.astype('float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b70f4b04",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 28*28 형태의 이미지를 784차원으로 flattening\n",
    "# 2-dim을 1-dim으로 만들어주는 것. \n",
    "x_train, x_test = x_train.reshape([-1,784]), x_test.reshape([-1,784]) # -1은 magic number로 data의 개수를 자동으로 할당함. \n",
    "                                                                      # 60000개와 10000개로 자동으로 맞추어줌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f3bfc470",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [0, 255] 사이의 값을 [0,1] 사이의 값으로 Normalize\n",
    "x_train, x_test = x_train / 255., x_test / 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c65a937d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 레이블 데이터에 one-hot encoding\n",
    "y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7f14f0a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져옴\n",
    "train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train)) # tf.data.Dataset는 데이터를 미니배치로 묶기 쉽도록\n",
    "                                                                    # 추상화해 놓은 클래스\n",
    "train_data = train_data.repeat().shuffle(60000).batch(100) # batch 100개씩 묶겠다.\n",
    "train_data_iter = iter(train_data) # 추후 next 함수와 상호작용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a69a79c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.keras,Model을 이용해서 Softmax Regression 모델 정의\n",
    "\n",
    "# tf.keras.Model을 상속받는 class 생성\n",
    "class SoftmaxRegression(tf.keras.Model):\n",
    "    def __init__(self):\n",
    "        super(SoftmaxRegression, self).__init__() # 케라스 모델의 기본적인 생성자 부분을 재호출\n",
    "        # 모델 building\n",
    "        # https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dens\n",
    "        self.softmax_layer = tf.keras.layers.Dense(10, # 넘기고자 하는 output dimension.\n",
    "                                                  activation=None,\n",
    "                                                  kernel_initializer='zeros', # W와 b의 초기값을 0으로 지정.\n",
    "                                                  bias_initializer='zeros')\n",
    "    def call(self, x):\n",
    "        logits = self.softmax_layer(x)\n",
    "        \n",
    "        return tf.nn.softmax(logits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e6c50a29",
   "metadata": {},
   "outputs": [],
   "source": [
    "# cross-entropy 손실함수 정의\n",
    "def cross_entropy_loss(y_pred, y):\n",
    "    return tf.reduce_mean(-tf.reduce_sum(y*tf.math.log(y_pred), axis=[1])) # 손실함수 직접 정의\n",
    "    #return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logtis, labels=y)) # 이미 정의돼 있는 함수. \n",
    "                                                                                        # 이 경우, call함수의 반환값이 \n",
    "                                                                                        #softmax함수가 씌워진 값이아닌\n",
    "                                                                                        #raw logit값이어야 한다.\n",
    "    # tf.nn.softmax_cross_entropy_with_logits API를 이용한 구현"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "98b061e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화를 위한 그라디언트 디센트 optimizer 정의\n",
    "optimizer = tf.optimizers.SGD(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2c9c5963",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화 함수\n",
    "def train_step(model, x,y):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = model(x)\n",
    "        loss = cross_entropy_loss(y_pred, y)\n",
    "    gradients = tape.gradient(loss, model.trainable_variables) # trainable_variables를 사용할 경우, \n",
    "                                                                # 이전에 만든 모델의 모든 구조를 반환해줌\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0b1a265b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모델의 정확도 출력 함수\n",
    "def compute_accuracy(y_pred, y):\n",
    "    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y,1)) # argmax를 사용해서 가장 큰 값을 prediction 값으로 확정해주는 것.\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "    \n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e7434501",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SoftmazRegression 모델 선언\n",
    "SoftmaxRegression_model = SoftmaxRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "eeab2a2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1000번 반복으로 최적화\n",
    "for i in range(1000):\n",
    "    batch_xs, batch_ys = next(train_data_iter)\n",
    "    train_step(SoftmaxRegression_model, batch_xs, batch_ys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "63fd40cf",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "정확도(Accuracy): 0.918900 \n"
     ]
    }
   ],
   "source": [
    "# 정확도 출력\n",
    "print(\"정확도(Accuracy): %f \" % compute_accuracy(SoftmaxRegression_model(x_test), y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d735e8c",
   "metadata": {},
   "source": [
    "## ANN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "de0d3070",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# MNIST 데이터를 다운로드 합니다.\n",
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "# 이미지들을 float32 데이터 타입으로 변경합니다.\n",
    "x_train, x_test = x_train.astype('float32'), x_test.astype('float32')\n",
    "# 28*28 형태의 이미지를 784차원으로 flattening 합니다.\n",
    "x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])\n",
    "# [0, 255] 사이의 값을 [0, 1]사이의 값으로 Normalize합니다.\n",
    "x_train, x_test = x_train / 255., x_test / 255.\n",
    "# 레이블 데이터에 one-hot encoding을 적용합니다.\n",
    "y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f6031575",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 학습을 위해 설정값 정의\n",
    "learning_rate = 0.001\n",
    "num_epochs = 30 # 학습횟수\n",
    "batch_size = 256 # 배치개수\n",
    "display_step = 1 # 손실함수 출력 주기\n",
    "input_size = 784\n",
    "hidden1_size = 256\n",
    "hidden2_size = 256\n",
    "output_size = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "aea48e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져옴\n",
    "train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n",
    "train_data = train_data.shuffle(60000).batch(batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "450951b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_normal_intializer_with_stddev_1():\n",
    "    return tf.keras.initializers.RandomNormal(mean=0.0, stddev=1.0, seed=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fa71fa97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.keras.Model을 이용해서 ANN모델을 정의\n",
    "class ANN(tf.keras.Model):\n",
    "    def __init__(self):\n",
    "        super(ANN, self).__init__()\n",
    "        self.hidden_layer_1 = tf.keras.layers.Dense(hidden1_size,\n",
    "                                                   activation='relu',\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "        self.hidden_layer_2 = tf.keras.layers.Dense(hidden2_size,\n",
    "                                                   activation='relu',\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "        self.output_layer = tf.keras.layers.Dense(output_size,\n",
    "                                                   activation=None,\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "        \n",
    "    def call(self, x):\n",
    "        H1_output = self.hidden_layer_1(x)\n",
    "        H2_output = self.hidden_layer_2(H1_output)\n",
    "        logits = self.output_layer(H2_output)\n",
    "\n",
    "        return logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c44b47b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# cross-entropy 손실함수 정의\n",
    "def cross_entropy_loss(logits, y):\n",
    "    return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e2821d81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화를 위한 Adam optimizer\n",
    "optimizer = tf.optimizers.Adam(learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f17082a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화 함수\n",
    "def train_step(model, x,y):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_pred = model(x)\n",
    "        loss = cross_entropy_loss(y_pred, y)\n",
    "    gradients = tape.gradient(loss, model.trainable_variables) # trainable_variables를 사용할 경우, \n",
    "                                                                # 이전에 만든 모델의 모든 구조를 반환해줌\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "68bcefe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모델의 정확도 출력 함수\n",
    "def compute_accuracy(y_pred, y):\n",
    "    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y,1)) # argmax를 사용해서 가장 큰 값을 prediction 값으로 확정해주는 것.\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "    \n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e51d9f73",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ANN 모델 선언\n",
    "ANN_model = ANN()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "599c8917",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "반복(Epoch): 1, 손실 함수(Loss): 277.867828\n",
      "반복(Epoch): 2, 손실 함수(Loss): 61.296265\n",
      "반복(Epoch): 3, 손실 함수(Loss): 39.818485\n",
      "반복(Epoch): 4, 손실 함수(Loss): 29.075478\n",
      "반복(Epoch): 5, 손실 함수(Loss): 22.508543\n",
      "반복(Epoch): 6, 손실 함수(Loss): 17.982603\n",
      "반복(Epoch): 7, 손실 함수(Loss): 14.631808\n",
      "반복(Epoch): 8, 손실 함수(Loss): 11.954827\n",
      "반복(Epoch): 9, 손실 함수(Loss): 9.843960\n",
      "반복(Epoch): 10, 손실 함수(Loss): 8.167468\n",
      "반복(Epoch): 11, 손실 함수(Loss): 6.681476\n",
      "반복(Epoch): 12, 손실 함수(Loss): 5.526685\n",
      "반복(Epoch): 13, 손실 함수(Loss): 4.613533\n",
      "반복(Epoch): 14, 손실 함수(Loss): 3.700699\n",
      "반복(Epoch): 15, 손실 함수(Loss): 2.985919\n",
      "반복(Epoch): 16, 손실 함수(Loss): 2.459886\n",
      "반복(Epoch): 17, 손실 함수(Loss): 1.964166\n",
      "반복(Epoch): 18, 손실 함수(Loss): 1.614003\n",
      "반복(Epoch): 19, 손실 함수(Loss): 1.309060\n",
      "반복(Epoch): 20, 손실 함수(Loss): 1.076161\n",
      "반복(Epoch): 21, 손실 함수(Loss): 0.762862\n",
      "반복(Epoch): 22, 손실 함수(Loss): 0.576540\n",
      "반복(Epoch): 23, 손실 함수(Loss): 0.464878\n",
      "반복(Epoch): 24, 손실 함수(Loss): 0.387580\n",
      "반복(Epoch): 25, 손실 함수(Loss): 0.279718\n",
      "반복(Epoch): 26, 손실 함수(Loss): 0.215415\n",
      "반복(Epoch): 27, 손실 함수(Loss): 0.189472\n",
      "반복(Epoch): 28, 손실 함수(Loss): 0.140393\n",
      "반복(Epoch): 29, 손실 함수(Loss): 0.107103\n",
      "반복(Epoch): 30, 손실 함수(Loss): 0.091050\n",
      "정확도(Accuracy): 0.943800 \n"
     ]
    }
   ],
   "source": [
    "# 지정된 횟수만큼 최적화 수행\n",
    "for epoch in range(num_epochs):\n",
    "    average_loss = 0.\n",
    "    total_batch = int(x_train.shape[0] / batch_size)\n",
    "    \n",
    "    # 모든 batch에 대해 최적화 수행\n",
    "    for batch_x, batch_y in train_data:\n",
    "        #옵티마이저를 실행해서 파라미터 업데이트\n",
    "        _, current_loss = train_step(ANN_model, batch_x, batch_y), cross_entropy_loss(ANN_model(batch_x), batch_y)\n",
    "        \n",
    "        # 평균 손실을 측정\n",
    "        average_loss += current_loss / total_batch\n",
    "        \n",
    "    # 지정된 epoch마다 학습 결과 출력\n",
    "    if epoch % display_step == 0:\n",
    "        print(\"반복(Epoch): %d, 손실 함수(Loss): %f\" % ((epoch +1), average_loss))\n",
    "\n",
    "#정확도 출력\n",
    "print(\"정확도(Accuracy): %f \" % compute_accuracy(ANN_model(x_test), y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edd9da89",
   "metadata": {},
   "source": [
    "## AutoEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e0b3875c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f6c285e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# MNIST 데이터를 다운로드 합니다.\n",
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "# 이미지들을 float32 데이터 타입으로 변경합니다.\n",
    "x_train, x_test = x_train.astype('float32'), x_test.astype('float32')\n",
    "# 28*28 형태의 이미지를 784차원으로 flattening 합니다.\n",
    "x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])\n",
    "# [0, 255] 사이의 값을 [0, 1]사이의 값으로 Normalize합니다.\n",
    "x_train, x_test = x_train / 255., x_test / 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6c96bb21",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 학습에 필요한 설정값 저장\n",
    "# 학습을 위해 설정값 정의\n",
    "learning_rate = 0.02\n",
    "training_epochs = 50 # 학습횟수\n",
    "batch_size = 256 # 배치개수\n",
    "display_step = 1 # 손실함수 출력 주기\n",
    "example_to_show = 10 # 보여줄 MNIST Reconstruction 이미지 개수\n",
    "input_size = 784\n",
    "hidden1_size = 256\n",
    "hidden2_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9fd272af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져옴\n",
    "train_data = tf.data.Dataset.from_tensor_slices(x_train) # unsupervised learning이기 때문에 y_train이 필요 없음!\n",
    "train_data = train_data.shuffle(60000).batch(batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "066e0782",
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_normal_intializer_with_stddev_1():\n",
    "    return tf.keras.initializers.RandomNormal(mean=0.0, stddev=1.0, seed=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "fd1ab607",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.keras.Model 을 이용해서 Autoencoder모델 정의\n",
    "class AutoEncoder(tf.keras.Model):\n",
    "    def __init__(self):\n",
    "        super(AutoEncoder, self).__init__()\n",
    "        # 인코딩 - 784 --> 256 --> 128\n",
    "        self.hidden_layer_1 = tf.keras.layers.Dense(hidden1_size,\n",
    "                                                   activation='sigmoid',\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "        self.hidden_layer_2 = tf.keras.layers.Dense(hidden2_size,\n",
    "                                                   activation='sigmoid',\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "        # 디코딩 128 --> 256 --> 784\n",
    "        self.hidden_layer_3 = tf.keras.layers.Dense(hidden1_size,\n",
    "                                                   activation='sigmoid',\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "        self.output_layer = tf.keras.layers.Dense(input_size,\n",
    "                                                   activation='sigmoid',\n",
    "                                                   kernel_initializer=random_normal_intializer_with_stddev_1(),\n",
    "                                                   bias_initializer=random_normal_intializer_with_stddev_1())\n",
    "    def call(self, x):\n",
    "        H1_output = self.hidden_layer_1(x)\n",
    "        H2_output = self.hidden_layer_2(H1_output)\n",
    "        H3_output = self.hidden_layer_3(H2_output)\n",
    "        reconstructed_x = self.output_layer(H3_output)\n",
    "\n",
    "        return reconstructed_x\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "faf60343",
   "metadata": {},
   "outputs": [],
   "source": [
    "# MSE 손실함수 정의\n",
    "def mse_loss(y_pred, y_true):\n",
    "    return tf.reduce_mean(tf.pow(y_true - y_pred, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "10590a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "# optimizer 정의\n",
    "optimizer = tf.optimizers.RMSprop(learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "531b4745",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 최적화\n",
    "def train_step(model, x):\n",
    "    with tf.GradientTape() as tape:\n",
    "        y_true = x\n",
    "        y_pred = model(x)\n",
    "        loss = mse_loss(y_pred, y_true)\n",
    "    gradients = tape.gradient(loss, model.trainable_variables) # trainable_variables를 사용할 경우, \n",
    "                                                                # 이전에 만든 모델의 모든 구조를 반환해줌\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7e2d6347",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모델 선언\n",
    "AutoEncoder_model = AutoEncoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0f3b9161",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "반복(Epoch): 1, 손실함수(Loss): 0.187886\n",
      "반복(Epoch): 2, 손실함수(Loss): 0.182231\n",
      "반복(Epoch): 3, 손실함수(Loss): 0.178720\n",
      "반복(Epoch): 4, 손실함수(Loss): 0.179544\n",
      "반복(Epoch): 5, 손실함수(Loss): 0.174285\n",
      "반복(Epoch): 6, 손실함수(Loss): 0.169742\n",
      "반복(Epoch): 7, 손실함수(Loss): 0.168718\n",
      "반복(Epoch): 8, 손실함수(Loss): 0.168720\n",
      "반복(Epoch): 9, 손실함수(Loss): 0.163348\n",
      "반복(Epoch): 10, 손실함수(Loss): 0.158542\n",
      "반복(Epoch): 11, 손실함수(Loss): 0.157211\n",
      "반복(Epoch): 12, 손실함수(Loss): 0.159805\n",
      "반복(Epoch): 13, 손실함수(Loss): 0.152371\n",
      "반복(Epoch): 14, 손실함수(Loss): 0.153542\n",
      "반복(Epoch): 15, 손실함수(Loss): 0.152338\n",
      "반복(Epoch): 16, 손실함수(Loss): 0.150553\n",
      "반복(Epoch): 17, 손실함수(Loss): 0.146694\n",
      "반복(Epoch): 18, 손실함수(Loss): 0.146913\n",
      "반복(Epoch): 19, 손실함수(Loss): 0.144389\n",
      "반복(Epoch): 20, 손실함수(Loss): 0.140764\n",
      "반복(Epoch): 21, 손실함수(Loss): 0.140541\n",
      "반복(Epoch): 22, 손실함수(Loss): 0.138056\n",
      "반복(Epoch): 23, 손실함수(Loss): 0.139517\n",
      "반복(Epoch): 24, 손실함수(Loss): 0.136527\n",
      "반복(Epoch): 25, 손실함수(Loss): 0.135074\n",
      "반복(Epoch): 26, 손실함수(Loss): 0.136485\n",
      "반복(Epoch): 27, 손실함수(Loss): 0.128877\n",
      "반복(Epoch): 28, 손실함수(Loss): 0.132487\n",
      "반복(Epoch): 29, 손실함수(Loss): 0.128919\n",
      "반복(Epoch): 30, 손실함수(Loss): 0.127723\n",
      "반복(Epoch): 31, 손실함수(Loss): 0.125405\n",
      "반복(Epoch): 32, 손실함수(Loss): 0.125163\n",
      "반복(Epoch): 33, 손실함수(Loss): 0.127285\n",
      "반복(Epoch): 34, 손실함수(Loss): 0.124977\n",
      "반복(Epoch): 35, 손실함수(Loss): 0.126413\n",
      "반복(Epoch): 36, 손실함수(Loss): 0.124066\n",
      "반복(Epoch): 37, 손실함수(Loss): 0.123599\n",
      "반복(Epoch): 38, 손실함수(Loss): 0.123218\n",
      "반복(Epoch): 39, 손실함수(Loss): 0.122458\n",
      "반복(Epoch): 40, 손실함수(Loss): 0.123107\n",
      "반복(Epoch): 41, 손실함수(Loss): 0.122695\n",
      "반복(Epoch): 42, 손실함수(Loss): 0.123480\n",
      "반복(Epoch): 43, 손실함수(Loss): 0.120127\n",
      "반복(Epoch): 44, 손실함수(Loss): 0.119007\n",
      "반복(Epoch): 45, 손실함수(Loss): 0.121934\n",
      "반복(Epoch): 46, 손실함수(Loss): 0.119002\n",
      "반복(Epoch): 47, 손실함수(Loss): 0.118294\n",
      "반복(Epoch): 48, 손실함수(Loss): 0.118689\n",
      "반복(Epoch): 49, 손실함수(Loss): 0.119842\n",
      "반복(Epoch): 50, 손실함수(Loss): 0.119800\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(training_epochs):\n",
    "    for batch_x in train_data:\n",
    "        _, current_loss = train_step(AutoEncoder_model, batch_x), mse_loss(AutoEncoder_model(batch_x), batch_x)\n",
    "    \n",
    "    if epoch  % display_step == 0:\n",
    "        print(\"반복(Epoch): %d, 손실함수(Loss): %f\" % ((epoch + 1), current_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "31c481a0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Public\\Documents\\ESTsoft\\CreatorTemp\\ipykernel_968\\2465294082.py:9: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  f.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x200 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 테스트 데이터로 Reconstruction을 수행합니다.\n",
    "reconstructed_result = AutoEncoder_model(x_test[:example_to_show])\n",
    "# 원본 MNIST 데이터와 Reconstruction 결과를 비교합니다.\n",
    "f, a = plt.subplots(2, 10, figsize=(10, 2))\n",
    "for i in range(example_to_show):\n",
    "  a[0][i].imshow(np.reshape(x_test[i], (28, 28)))\n",
    "  a[1][i].imshow(np.reshape(reconstructed_result[i], (28, 28)))\n",
    "f.savefig('reconstructed_mnist_image.png')  # reconstruction 결과를 png로 저장합니다.\n",
    "f.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}