{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"(ch:keras-tf)=\n",
"# 케라스와 텐서플로우"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**감사의 글**\n",
"\n",
"아래 내용은 프랑소와 숄레의 \n",
"[Deep Learning with Python(2판)](https://github.com/fchollet/deep-learning-with-python-notebooks)의 \n",
"소스코드 내용을 참고해서 작성되었습니다.\n",
"자료를 공개한 저자에게 진심어린 감사를 전합니다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**소스코드**\n",
"\n",
"여기서 언급되는 코드를\n",
"[(구글 코랩) 케라스와 텐서플로우](https://colab.research.google.com/github/codingalzi/dlp2/blob/master/notebooks/NB-keras_and_tf.ipynb)에서 \n",
"직접 실행할 수 있다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**슬라이드**\n",
"\n",
"본문 내용을 요약한 [슬라이드](https://github.com/codingalzi/dlp2/raw/master/slides/slides-keras_and_tf.pdf)를 다운로드할 수 있다."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**주요 내용**\n",
"\n",
"딥러닝 주요 라이브러리와 케라스의 핵심 API를 소개한다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 딥러닝 주요 라이브러리"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### 텐서플로우"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"텐서플로우는 파이썬에 기반한 머신러닝 플랫폼이며,\n",
"머신러닝 모델의 훈련에 특화된 텐서 연산을 지원한다.\n",
"\n",
"- 그레이디언트 자동 계산\n",
"- GPU, TPU 등 고성능 병렬 하드웨어 가속기 활용 가능\n",
"- 여러 대의 컴퓨터 또는 클라우드 컴퓨팅 서비스 활용 가능\n",
"- C++(게임), 자바스크립트(웹브라우저), TFLite(모바일 장치) 등과 호환 가능"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### 케라스"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"딥러닝 모델 구성 및 훈련에 효율적으로 사용될 수 있는 다양한 API를 제공하며,\n",
"텐서플로우의 프론트엔드front end 인터페이스 기능을 수행한다.\n",
"원래 텐서플로우와 독립적으로 개발되었지만 텐서플로우 2.0부터 텐서플로우 라이브러리의 최상위 프레임워크framework로 포함됐다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
":::{admonition} 모듈, 패키지, 라이브러리, 프레임워크\n",
":class: note\n",
"\n",
"한 번 구현한 파이썬 코드를 다른 파이썬 파일의 코드에서 공유해서 사용할 수 있도록 하기 위해 모듈module을 활용한다. \n",
"파이썬 모듈은 간단하게 말하면 하나의 파이썬 소스코드 파일이며, 확장자로 .py 가 사용된다. 모듈에는 보통 서로 연관된 함수와 클래스 등이 저장된다.\n",
"\n",
"하나의 모듈이 독립적으로 제공되기도 하지만 다른 모듈과 함께 하나의 모음집으로 제공되기도 하며,\n",
"모음집의 크기와 용도에 따라 패키지, 라이브러리, 프레임워크 등 다양한 이름으로 불린다.\n",
"\n",
"| 종류 | 설명 |\n",
"| :--- | :--- |\n",
"| 모듈module | 파이썬 소스코드 파일 |\n",
"| 패키지package | 모듈을 모아놓은 디렉토리(폴더) |\n",
"| 라이브러리library | 모듈, 패키지 등 재사용이 가능한 코드의 모음집을 통칭헤서 부르는 이름 |\n",
"| 프레임워크framework | 라이브러리 보다 포괄적인 개념. 라이브러리가 도구 모음집만 제공하는 반면에 프레임워크는 라이브러리와 함께 라이브러리를 쉽게 적용할 수 있는 틀frame과 아키텍처architecture를 함께 제공 |\n",
":::"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 케라스 3.0, 텐서플로우, 파이토치, 잭스"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"파이토치PyTorch 또한 텐서 연산을 지원하는 딥러닝 라이브러리이다.\n",
"텐서플로우와 케라스의 조합이 강력하지만 신경망의 보다 섬세한 조정은 약하다는 지적을 많이 받는 반면에\n",
"파이토치는 상대적으로 보다 자유롭게 신경망을 구성할 수 있다고 평가된다.\n",
"\n",
"케라스 3.0은 텐서플로우 뿐만 아니라 파이토치, 그리고 고성능 딥러닝 프레임워크인 잭스Jax의\n",
"프론트엔드 기능도 함께 지원한다.\n",
"잭스는 LLM 처럼 거대 모델 훈련을 위해 구글에서 만든 라이브러리이며 매우 빠른 연선을 지원한다.\n",
"\n",
"텐서플로우와 케라스의 조합이 여전히 보다 많이 사용되지만 딥러닝 연구에서 파이토치와 잭스의 활용 또한 점점 늘고 있다.\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### 딥러닝 개발환경"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"딥러닝 신경망 모델의 훈련을 위해서 GPU 또는 TPU 등을 활용할 것을 강력히 추천한다.\n",
"그렇지 않으면 딥러닝 신경망 모델의 훈련이 제대로 실행되지 않을 가능성이 높다.\n",
"[구글 코랩](https://colab.research.google.com/?hl=ko)을 이용하면\n",
"특별한 준비 없이 바로 신경망 모델을 GPU, TPU 등과 함께 훈련시킬 수 있다.\n",
"\n",
"또한 엔비디아 그래픽카드가 장착된 PC에서 딥러닝 모델을 훈련시킬 수 있다.\n",
"윈도우 11 운영체제에서 GPU를 지원하는 개발환경을 준비하는 요령은 [WSL2에 GPU 지원 Tensorflow, PyTorch 설치 요령](https://github.com/codingalzi/dlp2/blob/master/INSTALL.md)를 참고한다.\n",
"\n",
"보다 전문적인 딥러닝 연구를 위해 대용량의 메모리와 고성능의 CPU, GPU, TPU 가 필요한 경우\n",
"직접 모든 장비를 마련하기는 어려울 수 있다.\n",
"대신 [구글 클라우드 플랫폼](https://cloud.google.com/) 또는 \n",
"[아마존 웹서비스(AWS EC2)](https://aws.amazon.com/ko/?nc2=h_lg) 등에서\n",
"유료로 지원되는 고성능 클라우드 컴퓨팅 서비스를 활용할 것을 추천한다."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## 케라스 핵심 API"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"딥러닝 신경망 모델은 층layer으로 구성된다.\n",
"모델에 사용되는 층의 종류와 층을 쌓는 방식에 따라\n",
"모델이 처리할 수 있는 데이터와 훈련 방식이 달라진다.\n",
"케라스 라이브러리가 신경망의 효율적인 층의 구성과\n",
"모델 훈련에 적합한 다양한 API를 제공한다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 층 API"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"층은 입력 데이터를 지정된 방식에 따라 다른 모양의 데이터로 변환하여 전달하는\n",
"**순전파**forward pass를 담당한다.\n",
"또한 데이터 변환에 필요한 가중치weight와\n",
"편향bias을 저장한다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"데이터를 변환하는 방식에 따라 층의 기능이 달라진다. \n",
"케라스는 딥러닝 신경망 모델 구성에 가장 많이 사용되는 층을 다양한 클래스로 제공한다.\n",
"케라스를 활용하여 딥러닝 모델을 구성하는 일은 호환 가능한 층들을 적절하게 연결하여 층을 쌓는 것을 의미한다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**예제: `Dense` 층 상세**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"{numref}`%s절 `에서 MNIST 데이터셋을 이용한 분류 모델에 사용된\n",
"신경망 모델은 연속으로 쌓은 두 개의 `Dense` 층으로 구성된다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"model = keras.Sequential([\n",
" layers.Dense(512, activation=\"relu\"),\n",
" layers.Dense(10, activation=\"softmax\")\n",
"])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`Dense` 층은 `Dense` 클래스의 인스턴스로 생성되는데 \n",
"아래에 정의된 `SimpleDense` 클래스의 인스턴스를 `Dense` 층 대신 사용할 수 있다.\n",
"클래스 정의에서 다음 두 가지 사항에 주목한다.\n",
"\n",
"- `tensorflow.keras.layers` 모듈의 `Layer` 클래스 상속\n",
" - 케라스는 모든 종류의 층을 `tf.keras.layers` 모듈의 `Layer` 클래스의 자식 클래스로 제공하기 때문.\n",
"- `build()` 메서드와 `call()` 메서드 구현\n",
" - `build()` 메서드: 가중치와 편향 초기화\n",
" - `call()` 메서드: 데이터 변환 계산"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"from tensorflow import keras\n",
"\n",
"class SimpleDense(keras.layers.Layer):\n",
" def __init__(self, units, activation=None):\n",
" super().__init__()\n",
" self.units = units # 유닛 개수 지정\n",
" self.activation = activation # 활성화 함수 지정\n",
"\n",
" # 가중치와 편향 초기화 메서드\n",
" def build(self, input_shape):\n",
" input_dim = input_shape[-1] # 입력 샘플 백테의 차원\n",
" self.W = self.add_weight(shape=(input_dim, self.units),\n",
" initializer=\"random_normal\")\n",
" self.b = self.add_weight(shape=(self.units,),\n",
" initializer=\"zeros\")\n",
"\n",
" # 데이터 변환 메서드\n",
" def call(self, inputs):\n",
" y = inputs @ self.W + self.b\n",
" if self.activation is not None:\n",
" y = self.activation(y)\n",
" return y\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"클래스에서 선언된 `SimpleDense` 세 개의 메서드의 정의에 사용된 변수와 메서드는 다음과 같다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- 생성자 `__init__()` 메서드:\n",
" - `units`: 출력 샘플 벡터의 차원 지정\n",
" - `activation`: 활성화 함수 지정"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `build()` 메서드:\n",
" - `input_shape`: 입력값(`inputs`)으로 들어온 배치 2D 텐서의 모양. 1번 인덱스의 항목이 입력 샘플 벡터의 차원.\n",
" - `input_dim`: 입력 샘플 벡터의 차원\n",
" - `W`와 `b`: 가중치 텐서와 편향 벡터\n",
" - `add_weight(모양, 초기화방법)`: 지정된 모양의 텐서 생성 및 초기화. `Layer` 클래스에서 상속됨."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `call()` 메서드:\n",
" - `inputs`: 입력 배치. 2D 텐서 데이터셋"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**`SimpleDense` 층의 데이터 변환**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"모델 훈련 루프에 포함된 순전파는 층에서 층으로 이어지는 연속된 데이터 변환으로 이뤄진다.\n",
"`SimpleDense` 층을 이용하여 입력 배치 데이터셋이 변환되어 다음 층으로 전달되는 과정을 살펴본다.\n",
"\n",
"아래 코드에서 `my_dense` 변수는 하나의 `SimpleDense` 인스턴스로 선언된 층을 가리킨다.\n",
"\n",
"- 유닛 수: 512개\n",
"- 활성화 함수: `relu`\n",
"\n",
"```python\n",
"my_dense = SimpleDense(units=512, activation=tf.nn.relu)\n",
"```\n",
"\n",
"아래 코드는 입력 배치 예제 데이터셋으로 사용될 (128, 784) 모양의 텐서를\n",
"하나 임의로 생성한다.\n",
"\n",
"- 128: 배치 크기\n",
"- 784: MNIST 데이터셋의 손글씨 이미지 한 장의 픽셀 개수(`28 * 28 = 128`)\n",
"\n",
"```python\n",
"input_tensor = tf.ones(shape=(128, 784))\n",
"```\n",
"\n",
"이제 `my_dense`를 함수 호출하듯이 사용하면 출력값이 계산된다.\n",
"\n",
"```python\n",
"output_tensor = my_dense(input_tensor)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"층의 출력값은 `(128, 512)` 모양의 텐서다.\n",
"이유는 차원이 784인 각 데이터 샘플 벡터가 차원이 512인 벡터로 변환되기 때문이다.\n",
"512는 유닛 수임에 주목한다.\n",
"\n",
"```python\n",
"print(output_tensor.shape)\n",
"(128, 512)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**`Layer` 클래스의 `__call__()` 매직 메서드**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"이전 코드에서 `output_tensor`에 할당되는 값,\n",
"즉, `my_dense` 층을 통과하면서 변환된 값은\n",
"`my_dense`를 마치 `input_tensor`를 인자로 하는 함수 호출의 결과다.\n",
"하지만 `my_dense`는 `SimpleDense` 클래스의 인스턴스이지 함수가 아니다.\n",
"\n",
"그럼에도 불구하고 층 객체를 마치 함수처럼 사용할 수 있는 이유는\n",
"`Layer` 클래스로부터 상속하는 `__call__()` 메서드가 작동하기 때문이다.\n",
"즉, `my_dense(input_tensor)`가 실행되면\n",
"파이썬 실행기는 내부적으로 다음과 같이 `__call___()` 메서드를 호출한다.\n",
"\n",
"```python\n",
"my_dense.__call__(input_tensor)\n",
"```\n",
"\n",
"`__call__()` 매직 메서드가 하는 일의 핵심을 코드로 나타내면 다음과 같다. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"def __call__(self, inputs):\n",
" if not self.built:\n",
" self.build(inputs.shape)\n",
" self.built = True\n",
" return self.call(inputs)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"즉, `__call__()` 메서드는 다음 두 가지를 책임진다.\n",
"\n",
"- 모델 훈련을 시작할 때 층에 필요한 가중치 텐서와 편형 텐서가 없는 경우 적절한 모양의\n",
" 가중치 텐서와 편향 벡터를 초기화한다.\n",
" 또한 역전파 과정에서 옵티마이저에 의해 업데이트된 가중치 텐서와 편향 벡터를 저장한다.\n",
" - `self.built`: 모델 훈련에 사용될 가중치와 편향이 준비되어 있는지 여부 기억\n",
" - `self.build(inputs.shape)`: 입력 데이터셋의 모양 정보를 이용하여\n",
" 적절한 모양의 가중치 텐서는 정규 분포를 이용하여 무작위로,\n",
" 적절한 모양의 편향 벡터는 0 벡터로 초기화.\n",
"\n",
"- 저장된 가중치 텐서와 편향 벡터를 이용하여 벡터를 변환하여 출력값으로 반환한다.\n",
" - `self.call(inputs)`: 입력 텐서를 출력 텐서로 변환하는 계산 실행"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`my_dense.__call__(input_tensor)`와 연관지어 설명하면 다음과 같다.\n",
"\n",
"- `build()` 메서드 호출. 가중치 텐서와 편향 텐서가 존재하지 않은 경우 아래 내용 실행.\n",
" - `(784, 512)` 모양의 가중치 텐서 `W` 생성 및 무작위 초기화.\n",
" - `(512, )` 모양의 편향 벡터 `b` 생성 및 `0`으로 초기화.\n",
"\n",
"- `call()` 메서드 호출. 저장되어 있는 가중치 텐서와 편향 벡터를 이용하여 입력 데이터셋을\n",
" 아래 방식으로 변환.\n",
"\n",
" ```python\n",
" y = input_tensor @ W + b # 아핀 변환\n",
" y = tf.nn.relu(y) # 활성화 함수 적용\n",
" ```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 모델 API"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"여러 개의 층으로 구성된 리스트를 이용하여 순차 모델을 구성하는 `Sequential` 클래스는\n",
"층을 일렬로 쌓아 올리는 모델이다.\n",
"마지막 층을 제외한 모든 층은 이전 층에서 전달된 입력 텐서를\n",
"변환한 다음에 다음 층으로 전달한다.\n",
"반면에 마지막 층에서 변환된 값은 모델의 최종 예측값으로 사용된다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**`tf.keras.Model` 클래스**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`Sequential` 클래스를 포함하여 케라스가 지원하는 모델 클래스는 `tensorflow.keras.Model` 클래스를 상속한다.\n",
"예를 들어 아래 코드는 `Sequential` 클래스와 유사하게 작동하는 `MySequential` 클래스를 \n",
"`tensorflow.keras.Model` 클래스를 상속한다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"from tensorflow import keras\n",
"\n",
"class MySequential(keras.Model):\n",
" def __init__(self, list_layers): # 층들의 리스트 지정\n",
" super().__init__()\n",
" self.list_layers = list_layers\n",
"\n",
" # 순전파: 층과 층을 선형적으로 연결\n",
" def call(self, inputs):\n",
" outputs = inputs\n",
" for layer in self.list_layers: # 이전 층에서 변환된 텐서를 다음 층으로 바로 전달\n",
" outputs = layer(outputs)\n",
" return outputs\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"앞서 두 개의 `Dense` 층으로 구성된 순차 모델을 \n",
"`MySequential` 클래스와 두 개의 `SimpleDense` 층을 이용하여\n",
"다음과 같이 선언할 수 있다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"layer_1 = SimpleDense(units=512, activation=tf.nn.relu) # 첫째 밀집층\n",
"layer_2 = SimpleDense(units=10, activation=tf.nn.softmax) # 둘째 밀집층\n",
"\n",
"model = MySequential([layer_1, layer_2])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`SimpleDense`층 대신 `Dense` 층을 이용한다면 다음과 같이 활성화 함수를 문자열로 지정할 수 있음에 주의한다.\n",
"\n",
"```python\n",
"layer_1 = Dense(units=512, activation='relu') # 첫째 밀집층\n",
"layer_2 = Dense(units=10, activation='softmax') # 둘째 밀집층\n",
"\n",
"model = MySequential([layer_1, layer_2])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**모델의 학습과정과 층의 구성**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"모델의 학습과정은 전적으로 층의 구성방식에 의존한다. \n",
"그리고 층의 구성 방식은 주어진 데이터셋과 모델이 해결해야 하는 문제에 따라 달라진다.\n",
"층을 구성할 때 특별히 정해진 규칙은 없지만 \n",
"문제 유형에 따른 권장 모델이 다양하게 개발되었다.\n",
"\n",
"앞으로 보다 복잡하고 다양한 방식으로 층을 구성하는 방식들을 살펴볼 것이다.\n",
"예를 들어, 아래 그림은 {numref}`%s장 자연어 처리 `에서 소개하는\n",
"트랜스포머Transformer 모델의 복잡한 층 연결 구조를 보여준다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### 모델 컴파일 API"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"모델 컴파일은 선언된 모델을 진행하기 위해 필요한 다음 세 가지 설정을 추가로 지정하는 과정을 가리킨다.\n",
"\n",
"- 손실 함수\n",
" - 훈련 중 모델의 성능이 얼마나 나쁜지 측정.\n",
" - 가중치와 편향 의존.\n",
" - 가중치와 편향에 대해 미분 가능해야 함.\n",
" - 옵티마이저가 경사하강법을 적용할 때 사용되는 함수.\n",
"- 옵티마이저\n",
" - 가중치와 편향을 업데이트하는 역전파 반복 실행\n",
"- 평가지표 \n",
" - 훈련과 테스트 과정을 모니터링 할 때 사용되는 모델 평가 지표.\n",
" - 손실 함수와는 달리 훈련에 직접 사용되지는 않음."
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "code"
},
"source": [
"케라스는 모델 컴파일에 사용되는 다양한 API를 제공하며 \n",
"아래 코드에서처럼 문자열로 지정될 수 있다.\n",
"\n",
"```python\n",
"model.compile(optimizer=\"rmsprop\",\n",
" loss=\"mean_squared_error\",\n",
" metrics=[\"accuracy\"])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "code"
},
"source": [
"위 코드에서 사용된 각각의 문자열이 가리키는 API는 다음과 같다.\n",
"\n",
"| 문자열 | 파이썬 객체 |\n",
"| :--- | :--- |\n",
"| `\"rmsprop\"` | `keras.optimizers.RMSprop()` |\n",
"| `\"mean_squared_error\"` | `keras.losses.MeanSquaredError()` |\n",
"| `\"accuracy\"` | `keras.metrics.BinaryAccuracy()]` |\n",
"\n",
"앞서 `SimpleDense`를 통해 본 것처럼 문자열 대신 API를 직접 지정해도 된다."
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "code"
},
"source": [
"```python\n",
"model.compile(optimizer=keras.optimizers.RMSprop(),\n",
" loss=keras.losses.MeanSquaredError(),\n",
" metrics=[keras.metrics.BinaryAccuracy()])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "code"
},
"source": [
"하지만 다음 두 가지의 경우엔 문자열 대신 해당 API를 직접 지정해야 한다.\n",
"- 사용자가 직접 학습률(`learning_rate`)을 지정하는 옵티마이저를 사용하고자 하는 경우처럼 모델의 하이퍼파라미터를 기본값이 아닌 다른 값으로 지정하고자 하는 경우\n",
"- 사용자가 직접 정의한 API를 사용하고자 하는 경우\n",
"\n",
"다음은 직접 객체를 지정하는 방식으로 모델을 컴파일하는 형식을 보여준다.\n",
"\n",
"```python\n",
"model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-4),\n",
" loss=사용자정의손실함수객체,\n",
" metrics=[사용자정의평가지표_1, 사용자정의평가지표_2])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"일반적으로 가장 많이 사용되는 옵티마이저, 손실함수, 평가지표는 다음과 같으며\n",
"앞으로 다양한 예제를 통해 적절한 옵티마이저, 손실함수, 평가지표를 선택하는 방법을 살펴볼 것이다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**옵티마이저 API**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"다양한 옵티마이저의 장단점에 대해서는 [Hands-on Machine Learning 3판](https://www.oreilly.com/library/view/hands-on-machine-learning/9781098125967/)의 11장에 정리되어 있다.\n",
"\n",
"| 옵티마이저 | 문자열 |\n",
"| :--- | :--- |\n",
"| keras.optimizers.SGD | \"SGD\" |\n",
"| keras.optimizers.RMSprop | \"rmsprop\" |\n",
"| keras.optimizers.Adam | \"adam\" |\n",
"| keras.optimizers.AdamW | \"adamw\" |\n",
"| keras.optimizers.Adagrad | \"adagrad\" |\n",
"| keras.optimizers.Nadam | \"nadam\" |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**손실 함수 API**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"일반적으로 모델의 종류에 따라 손실 함수를 선택한다.\n",
"\n",
"| 손실 함수 | 문자열 | 용도 |\n",
"| :--- | :--- | :--- |\n",
"| keras.losses.CategoricalCrossentropy | \"categorical_crossentropy\" | 다중 클래스 분류. 원-핫 형식 타깃 |\n",
"| keras.losses.SparseCategoricalCrossentropy | \"sparse_categorical_crossentropy\" | 다중 클래스 분류. 정수 타깃 |\n",
"| keras.losses.BinaryCrossentropy | \"binary_crossentropy\" | 이진 분류 |\n",
"| keras.losses.MeanSquaredError | \"mean_squared_error\" | 회귀 |\n",
"| keras.losses.MeanAbsoluteError | \"mean_absolute_error\" | 회귀 |\n",
"| keras.losses.CosineSimilarity | \"cosine_similarity\" | 문장 번역, 물건 추천, 이미지 분류 등 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**평가지표 API**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"일반적으로 모델 종류와 목적에 따라 평가 지표를 선택한다.\n",
"\n",
"| 평가지표 | 문자열 | 용도 |\n",
"| :--- | :--- | :--- |\n",
"| keras.metrics.CategoricalAccuracy | \"categorical_accuracy\" | 다중클래스 분류 정확도 측정. 원-핫 형식 타깃 |\n",
"| keras.metrics.SparseCategoricalAccuracy | \"sparse_categorical_accuracy\" | 다중클래스 분류 정확도 측정. 정수 타깃 |\n",
"| keras.metrics.BinaryAccuracy | \"binary_accuracy\" | 이진 분류 정확도 측정 |\n",
"| keras.metrics.AUC | 없음 | 다중 클래스 분류 AUC 측정 |\n",
"| keras.metrics.Precision | 없음 | 다중 클래스 분류 정밀도 측정 |\n",
"| keras.metrics.Recall | 없음 | 다중 클래스 분류 재현율 측정 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 모델 훈련 API"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"컴파일된 모델의 `fit()` 메서드를 적절한 인자와 함께 호출하면\n",
"스텝 단위로 반복되는 **훈련 루프**training loop가 실행된다.\n",
"훈련 루푸는 지정된 에포크 만큼 또는 학습이 충분히 이루어졌다는 평가가 내려질 때까지 반복된다."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**지도학습 모델 훈련**"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"지도 학습 모델의 훈련은 아래 코드에서처럼 적절한 인자들과 함께 `fit()` 메서드를 호출할 때 진행된다.\n",
"\n",
"- `inputs`: 훈련셋\n",
"- `targets`: 타깃셋\n",
"- `epochs`: 에포크 수\n",
"- `batch_size`: 배치 크기\n",
"\n",
"```python\n",
"training_history = model.fit(\n",
" inputs,\n",
" targets,\n",
" epochs=5,\n",
" batch_size=128\n",
")\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**`History` 객체: 훈련 결과**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"훈련이 종료되면 `fit()` 메서드는 모델의 훈련 결과를 담고 있는 `History` 객체가 반환된다.\n",
"예를 들어 `History` 객체의 `history` 속성은 에포크별로 계산된 손실값과 평가지표값을\n",
"사전 자료형으로 가리킨다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"training_history.history\n",
"```\n",
"```\n",
"{'loss': [0.2729695439338684,\n",
" 0.11179507523775101,\n",
" 0.07302209734916687,\n",
" 0.0526457279920578,\n",
" 0.04022042825818062],\n",
" 'accuracy': [0.9212833046913147,\n",
" 0.9672333598136902,\n",
" 0.9783666729927063,\n",
" 0.9844833612442017,\n",
" 0.988099992275238]}\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**검증셋 활용**"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"머신러닝 모델 훈련의 목표는 훈련셋에 대한 높은 성능이 아니라\n",
"훈련에서 보지 못한 새로운 데이터에 대한 높은 성능이다.\n",
"\n",
"새로운 데이터에 대한 모델의 성능을 예측하기 위해 검증셋, 즉 검증용 데이터셋을 훈련중에 활용할 수 있다.\n",
"주어진 훈련셋의 20~30 % 정도를 검증셋으로 지정한다.\n",
"훈련셋의 크기에 따라 검증셋의 비율을 적절하게 조정한다.\n",
"또한 훈련셋 자체가 매우 작은 경우엔 검증셋을 따로 분리하기 보다는 K-겹 교차 검증 등을 사용해야 한다.\n",
"\n",
"훈련셋과 검증셋이 서로 겹치지 않도록 주의해야 한다.\n",
"그렇지 않으면 훈련 중에 모델이 검증셋에 포함된 데이터를 학습하기에\n",
"정확환 모델 평가를 할 수 없게 된다."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"아래 코드는 미리 지정된 검증셋 `val_inputs`와 검증 타깃셋 `val_targets`를\n",
"`validation_data`의 키워드 인자로 지정해서\n",
"모델 훈련이 진행되는 동안 에포크가 끝날 때마다 모델의 검증셋에 대한 \n",
"성능을 측정하도록 한다.\n",
"\n",
"```python\n",
"model.fit(\n",
" training_inputs,\n",
" training_targets,\n",
" epochs=5,\n",
" batch_size=16,\n",
" validation_data=(val_inputs, val_targets)\n",
")\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"그러면 훈련이 종료되어 생성된 `History` 객체에\n",
"검증셋에 대한 손실값과 정확도도 함께 저장된다."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python\n",
"training_history.history\n",
"```\n",
"```\n",
"{'loss': [0.02950882911682129,\n",
" 0.021471761167049408,\n",
" 0.015012570656836033,\n",
" 0.011033009737730026,\n",
" 0.0080801947042346],\n",
" 'accuracy': [0.991428554058075,\n",
" 0.9937618970870972,\n",
" 0.9962857365608215,\n",
" 0.9974523782730103,\n",
" 0.9982380867004395],\n",
" 'val_loss': [0.029974577948451042,\n",
" 0.03373847156763077,\n",
" 0.03262251615524292,\n",
" 0.03768538683652878,\n",
" 0.03493628650903702],\n",
" 'val_accuracy': [0.9906111359596252,\n",
" 0.9896666407585144,\n",
" 0.9901666641235352,\n",
" 0.9882222414016724,\n",
" 0.9900555610656738]}\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 모델 평가 API"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"훈련이 종료된 모델을 실전 성능 평가를 \n",
"`evaluate()` 메서드를 테스트셋과 함께 호출한다.\n",
"모델의 실전 성능 평가 또한 지정된 배치 단위로 실행된다.\n",
"\n",
"```python\n",
"loss_and_metrics = model.evaluate(test_images, test_labels, batch_size=128)\n",
"```\n",
"\n",
"`evaluate()` 메서드는 테스트셋에 대한 손실값과 평가지표값을 담은 리스트를 반환한다.\n",
"\n",
"```python\n",
"print(loss_and_metrics)\n",
"```\n",
"```\n",
"[0.06799975782632828, 0.98089998960495]\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 모델 활용 API"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"실전에 배치된 모델은 새로이 입력된 데이터에 대한 예측을 실행한다.\n",
"학습된 모델의 예측값은 `predict()` 메서드를 활용하여 계산한다.\n",
"예측 또한 지정 크기의 배치 단위로 실행된다.\n",
"\n",
"```python\n",
"predictions = model.predict(new_inputs, batch_size=128)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 연습 문제"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. [(실습) 케라스와 텐서플로우](https://colab.research.google.com/github/codingalzi/dlp2/blob/master/excs/exc-keras_and_tf.ipynb)"
]
}
],
"metadata": {
"colab": {
"collapsed_sections": [],
"name": "chapter03_introduction-to-keras-and-tf.i",
"private_outputs": false,
"provenance": [],
"toc_visible": true
},
"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.12.2"
},
"vscode": {
"interpreter": {
"hash": "6c86b3592b6800d985c04531f2c445f0fa6967131b8dd6395a925f7622e55602"
}
}
},
"nbformat": 4,
"nbformat_minor": 1
}
![](\"https://drek4537l1klr.cloudfront.net/chollet2/v-7/Figures/keras_and_tf.png\")
![](\"https://github.com/codingalzi/dlp2/blob/master/jupyter-book/imgs/cross_framework_keras_3.jpg?raw=true\")
![](\"https://drek4537l1klr.cloudfront.net/chollet2/v-7/Figures/transformer0001.png\"){kind=spacer}