custom_model_in_keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 케라스 API를 사용한 사용자 정의 모델 만들기 with 텐서플로 2.3\n",
    "\n",
    "DLD(Daejeon Learning Day) 2020을 위해 작성된 노트북입니다.\n",
    "\n",
    "* 깃허브 주소: https://github.com/rickiepark/handson-ml2/blob/master/custom_model_in_keras.ipynb\n",
    "* 코랩 주소: https://colab.research.google.com/github/rickiepark/handson-ml2/blob/master/custom_model_in_keras.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.3.0'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "tf.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MNIST 손글씨 숫자 데이터 적재"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "\n",
    "X_train = X_train.reshape(-1, 784) / 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 784)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Sequential()` 클래스와 함수형 API의 관계"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Sequential()`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "시퀀셜 모델에 10개의 유닛을 가진 완전 연결 층을 추가합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 10)                7850      \n",
      "=================================================================\n",
      "Total params: 7,850\n",
      "Trainable params: 7,850\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "seq_model = tf.keras.Sequential()\n",
    "\n",
    "seq_model.add(tf.keras.layers.Dense(units=10, \n",
    "                                    activation='softmax',\n",
    "                                    input_shape=(784,)))\n",
    "\n",
    "seq_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4386 - accuracy: 0.8830\n",
      "Epoch 2/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3024 - accuracy: 0.9159\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f2781d38ef0>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_model.compile(loss='sparse_categorical_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "seq_model.fit(X_train, y_train, batch_size=32, epochs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수형 API:\n",
    "\n",
    "함수형 API를 사용할 때는 `Input()`을 사용해 입력의 크기를 정의해야 합니다. 하지만 `InputLayer` 층이 추가되어 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"functional_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         [(None, 784)]             0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 10)                7850      \n",
      "=================================================================\n",
      "Total params: 7,850\n",
      "Trainable params: 7,850\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs = tf.keras.layers.Input(784)\n",
    "\n",
    "outputs = tf.keras.layers.Dense(units=10,\n",
    "                                activation='softmax')(inputs)  # __call()__ 메서드 호출\n",
    "# dense = tf.keras.layers.Dense(units=10, activation='softmax')\n",
    "# outputs = dense(inputs)\n",
    "\n",
    "func_model = tf.keras.Model(inputs, outputs)\n",
    "\n",
    "func_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4412 - accuracy: 0.8821\n",
      "Epoch 2/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3027 - accuracy: 0.9160\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f277f245710>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_model.compile(loss='sparse_categorical_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "func_model.fit(X_train, y_train, batch_size=32, epochs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Input`의 정체는 무엇일까요? 이 함수는 `InputLayer` 클래스의 객체를 만들어 그 결과를 반환합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tf.keras.layers.Input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "사실 신경망의 입력층은 입력 그 자체입니다. `InputLayer` 객체의 입력 노드 출력을 그대로 `Dense` 층에 주입할 수 있습니다. 모든 층은 입력과 출력 노드를 정의합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"functional_3\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_2 (InputLayer)         [(None, 784)]             0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                7850      \n",
      "=================================================================\n",
      "Total params: 7,850\n",
      "Trainable params: 7,850\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# inputs = tf.keras.layers.Input(784)\n",
    "\n",
    "input_layer = tf.keras.layers.InputLayer(784)\n",
    "inputs = input_layer._inbound_nodes[0].outputs\n",
    "\n",
    "outputs = tf.keras.layers.Dense(units=10,\n",
    "                                activation='softmax')(inputs)\n",
    "\n",
    "input_layer_model = tf.keras.Model(inputs, outputs)\n",
    "\n",
    "input_layer_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4338 - accuracy: 0.8850\n",
      "Epoch 2/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3025 - accuracy: 0.9161\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f277f193be0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_layer_model.compile(loss='sparse_categorical_crossentropy', \n",
    "                          metrics=['accuracy'])\n",
    "input_layer_model.fit(X_train, y_train, batch_size=32, epochs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수형 API를 사용한 모델은 `layers` 속성에 `InputLayer` 클래스를 포함합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tensorflow.python.keras.engine.input_layer.InputLayer at 0x7f277f3be5c0>,\n",
       " <tensorflow.python.keras.layers.core.Dense at 0x7f27dc1d3a20>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_model.layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하지만 시퀀셜 모델은 `layers` 속성에 `InputLayer` 클래스가 보이지 않습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tensorflow.python.keras.layers.core.Dense at 0x7f2781d04978>]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_model.layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "모델은 감춰진 `_layers` 속성이 또 있습니다. 여기에서 `InputLayer` 클래스를 확인할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tensorflow.python.keras.engine.input_layer.InputLayer at 0x7f2781d04f98>,\n",
       " <tensorflow.python.keras.layers.core.Dense at 0x7f2781d04978>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_model._layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "또는 `_input_layers` 속성에서도 확인할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<tensorflow.python.keras.engine.input_layer.InputLayer at 0x7f2781d04f98>],\n",
       " [<tensorflow.python.keras.engine.input_layer.InputLayer at 0x7f277f3be5c0>])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_model._input_layers, func_model._input_layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<tensorflow.python.keras.layers.core.Dense at 0x7f2781d04978>],\n",
       " [<tensorflow.python.keras.layers.core.Dense at 0x7f27dc1d3a20>])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq_model._output_layers, func_model._output_layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Model` 클래스로 만든 `func_model`은 사실 `Functional` 클래스의 객체입니다. `Model` 클래스는 서브클래싱에 사용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensorflow.python.keras.engine.functional.Functional"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_model.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "시퀀셜 모델은 함수형 모델의 특별한 경우입니다. (`Model` --> `Functional` --> `Sequential`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 사용자 정의 층 만들기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`tf.layers.Layer` 클래스를 상속하고 `build()` 메서드에서 가중치를 만든다음 `call()` 메서드에서 연산을 구현합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyDense(tf.keras.layers.Layer):\n",
    "    \n",
    "    def __init__(self, units, activation=None, **kwargs):\n",
    "        # units와 activation 매개변수 외에 나머지 변수를 부모 클래스의 생성자로 전달합니다.\n",
    "        super(MyDense, self).__init__(**kwargs)\n",
    "        self.units = units\n",
    "        # 문자열로 미리 정의된 활성화 함수를 선택합니다. e.g., 'softmax', 'relu'\n",
    "        self.activation = tf.keras.activations.get(activation)\n",
    "        \n",
    "    def build(self, input_shape):\n",
    "        # __call__() 메서드를 호출할 때 호출됩니다. 가중치 생성을 지연합니다.\n",
    "        # 가중치와 절편을 생성합니다.\n",
    "        self.kernel = self.add_weight(name='kernel', \n",
    "                                      shape=[input_shape[-1], self.units],\n",
    "                                      initializer='glorot_uniform'   # 케라스의 기본 초기화\n",
    "                                     )\n",
    "        self.bias = self.add_weight(name='bias',\n",
    "                                    shape=[self.units],\n",
    "                                    initializer='zeros')\n",
    "    \n",
    "    def call(self, inputs):  # training=None은 training은 배치 정규화나 드롭아웃 같은 경우 사용\n",
    "        # __call__() 메서드를 호출할 때 호출됩니다.\n",
    "        # 실제 연산을 수행합니다. [batch_size, units]\n",
    "        z = tf.matmul(inputs, self.kernel) + self.bias\n",
    "        if self.activation:\n",
    "            return self.activation(z)\n",
    "        return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"functional_5\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_3 (InputLayer)         [(None, 784)]             0         \n",
      "_________________________________________________________________\n",
      "my_dense (MyDense)           (None, 10)                7850      \n",
      "=================================================================\n",
      "Total params: 7,850\n",
      "Trainable params: 7,850\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs = tf.keras.layers.Input(784)\n",
    "# Layer.__call__() --> MyDense().build() --> Layer.build() --> MyDense().call()\n",
    "outputs = MyDense(units=10, activation='softmax')(inputs)\n",
    "\n",
    "my_dense_model = tf.keras.Model(inputs, outputs)\n",
    "\n",
    "my_dense_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4339 - accuracy: 0.8830\n",
      "Epoch 2/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3017 - accuracy: 0.9154\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f277f0d0e10>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dense_model.compile(loss='sparse_categorical_crossentropy', \n",
    "                       metrics=['accuracy'])\n",
    "my_dense_model.fit(X_train, y_train, batch_size=32, epochs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 사용자 정의 모델 만들기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit(), compile(), predict(), evaluate() 등의 메서드 제공\n",
    "class MyModel(tf.keras.Model):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(MyModel, self).__init__()\n",
    "        self.output_layer = MyDense(units=10, activation='softmax')\n",
    "    \n",
    "    def call(self, inputs):\n",
    "        return self.output_layer(inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4412 - accuracy: 0.8818\n",
      "Epoch 2/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3026 - accuracy: 0.9162\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f27681b61d0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_model = MyModel()\n",
    "\n",
    "my_model.compile(loss='sparse_categorical_crossentropy', \n",
    "                       metrics=['accuracy'])\n",
    "my_model.fit(X_train, y_train, batch_size=32, epochs=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 사용자 정의 훈련"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyCustomStep(MyModel):\n",
    "    \n",
    "    def train_step(self, data):\n",
    "        # fit()에서 전달된 데이터\n",
    "        x, y = data\n",
    "\n",
    "        # 그레이디언트 기록 시작\n",
    "        with tf.GradientTape() as tape:\n",
    "            # 정방향 계산\n",
    "            y_pred = self(x)\n",
    "            # compile() 메서드에서 지정한 손실 계산\n",
    "            loss = self.compiled_loss(y, y_pred)\n",
    "\n",
    "        # 훈련가능한 파라미터에 대한 그레이디언트 계산\n",
    "        gradients = tape.gradient(loss, self.trainable_variables)\n",
    "        # 파라미터 업데이트\n",
    "        self.optimizer.apply_gradients(zip(gradients, self.trainable_variables))\n",
    "        # compile() 메서드에서 지정한 지표 계산\n",
    "        self.compiled_metrics.update_state(y, y_pred)\n",
    "        \n",
    "        # 현재까지 지표와 결괏값을 딕셔너리로 반환\n",
    "        return {m.name: m.result() for m in self.metrics}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.4383 - accuracy: 0.8842\n",
      "Epoch 2/2\n",
      "1875/1875 [==============================] - 4s 2ms/step - loss: 0.3022 - accuracy: 0.9160\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f27680877b8>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_custom_step = MyCustomStep()\n",
    "\n",
    "my_custom_step.compile(loss='sparse_categorical_crossentropy', \n",
    "                       metrics=['accuracy'])\n",
    "my_custom_step.fit(X_train, y_train, batch_size=32, epochs=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TensorFlow 2.3 on Python 3.6 (CUDA 10.1)",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}