{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "Tce3stUlHN0L"
},
"source": [
"##### Copyright 2020 The TensorFlow Authors."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"cellView": "form",
"execution": {
"iopub.execute_input": "2022-12-14T21:12:37.108190Z",
"iopub.status.busy": "2022-12-14T21:12:37.107967Z",
"iopub.status.idle": "2022-12-14T21:12:37.111752Z",
"shell.execute_reply": "2022-12-14T21:12:37.111218Z"
},
"id": "tuOe1ymfHZPu"
},
"outputs": [],
"source": [
"#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
"# you may not use this file except in compliance with the License.\n",
"# You may obtain a copy of the License at\n",
"#\n",
"# https://www.apache.org/licenses/LICENSE-2.0\n",
"#\n",
"# Unless required by applicable law or agreed to in writing, software\n",
"# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
"# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
"# See the License for the specific language governing permissions and\n",
"# limitations under the License."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qFdPvlXBOdUN"
},
"source": [
"# 그래디언트 및 자동 미분 소개"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MfBg1C5NB3X0"
},
"source": [
""
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "r6P32iYYV27b"
},
"source": [
"## 자동 미분 및 그래디언트\n",
"\n",
"[자동 미분](https://en.wikipedia.org/wiki/Automatic_differentiation)은 신경망 학습을 위한 [역전파](https://en.wikipedia.org/wiki/Backpropagation)와 같은 머신러닝 알고리즘을 구현하는 데 유용합니다.\n",
"\n",
"이 가이드에서는 특히 [즉시 실행](eager.ipynb)에서 TensorFlow로 그래디언트를 계산하는 방법을 알아봅니다."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MUXex9ctTuDB"
},
"source": [
"## 설정"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:37.115341Z",
"iopub.status.busy": "2022-12-14T21:12:37.114744Z",
"iopub.status.idle": "2022-12-14T21:12:39.435381Z",
"shell.execute_reply": "2022-12-14T21:12:39.434641Z"
},
"id": "IqR2PQG4ZaZ0"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 21:12:38.383389: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
"2022-12-14 21:12:38.383494: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
"2022-12-14 21:12:38.383503: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
]
}
],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"import tensorflow as tf"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "xHxb-dlhMIzW"
},
"source": [
"## 그래디언트 계산하기\n",
"\n",
"자동으로 미분하기 위해 TensorFlow는 *정방향 패스* 동안 어떤 연산이 어떤 순서로 발생하는지 기억해야 합니다. 그런 다음 *역방향 패스* 동안 TensorFlow는 이 연산 목록을 역순으로 이동하여 그래디언트를 계산합니다."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1CLWJl0QliB0"
},
"source": [
"## 그래디언트 테이프\n",
"\n",
"텐서플로는 자동 미분(주어진 입력 변수에 대한 연산의 그래디언트(gradient)를 계산하는 것)을 위한 [tf.GradientTape](https://www.tensorflow.org/api_docs/python/tf/GradientTape) API를 제공합니다. `tf.GradientTape`는 컨텍스트(context) 안에서 실행된 모든 연산을 테이프(tape)에 \"기록\"합니다. 그 다음 텐서플로는 [후진 방식 자동 미분(reverse mode differentiation)](https://en.wikipedia.org/wiki/Automatic_differentiation)을 사용해 테이프에 \"기록된\" 연산의 그래디언트를 계산합니다.\n",
"\n",
"예를 들면:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:39.439932Z",
"iopub.status.busy": "2022-12-14T21:12:39.439143Z",
"iopub.status.idle": "2022-12-14T21:12:42.810503Z",
"shell.execute_reply": "2022-12-14T21:12:42.809665Z"
},
"id": "Xq9GgTCP7a4A"
},
"outputs": [],
"source": [
"x = tf.Variable(3.0)\n",
"\n",
"with tf.GradientTape() as tape:\n",
" y = x**2"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CR9tFAP_7cra"
},
"source": [
"일부 연산을 기록한 후에는 `GradientTape.gradient(target, sources)`를 사용하여 일부 소스(종종 모델 변수)에 상대적인 일부 대상(종종 손실)의 그래디언트를 계산합니다."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:42.814844Z",
"iopub.status.busy": "2022-12-14T21:12:42.814139Z",
"iopub.status.idle": "2022-12-14T21:12:42.824955Z",
"shell.execute_reply": "2022-12-14T21:12:42.824347Z"
},
"id": "LsvrwF6bHroC"
},
"outputs": [
{
"data": {
"text/plain": [
"6.0"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# dy = 2x * dx\n",
"dy_dx = tape.gradient(y, x)\n",
"dy_dx.numpy()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Q2_aqsO25Vx1"
},
"source": [
"위의 예제는 스칼라를 사용하지만, `tf.GradientTape`는 모든 텐서에서 쉽게 작동합니다."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:42.828157Z",
"iopub.status.busy": "2022-12-14T21:12:42.827587Z",
"iopub.status.idle": "2022-12-14T21:12:43.151842Z",
"shell.execute_reply": "2022-12-14T21:12:43.151108Z"
},
"id": "vacZ3-Ws5VdV"
},
"outputs": [],
"source": [
"w = tf.Variable(tf.random.normal((3, 2)), name='w')\n",
"b = tf.Variable(tf.zeros(2, dtype=tf.float32), name='b')\n",
"x = [[1., 2., 3.]]\n",
"\n",
"with tf.GradientTape(persistent=True) as tape:\n",
" y = x @ w + b\n",
" loss = tf.reduce_mean(y**2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "i4eXOkrQ-9Pb"
},
"source": [
"두 변수 모두에 대해 `loss`의 그래디언트를 가져오려면, 두 변수를 `gradient` 메서드에 소스로 전달할 수 있습니다. 테이프는 소스가 전달되는 방식에 대해 융통성이 있으며 목록 또는 사전의 중첩된 조합을 허용하고 같은 방식으로 구조화된 그래디언트를 반환합니다(`tf.nest` 참조)."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.156108Z",
"iopub.status.busy": "2022-12-14T21:12:43.155593Z",
"iopub.status.idle": "2022-12-14T21:12:43.168800Z",
"shell.execute_reply": "2022-12-14T21:12:43.168229Z"
},
"id": "luOtK1Da_BR0"
},
"outputs": [],
"source": [
"[dl_dw, dl_db] = tape.gradient(loss, [w, b])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Ei4iVXi6qgM7"
},
"source": [
"각 소스에 대한 그래디언트는 소스의 형상을 갖습니다."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.172111Z",
"iopub.status.busy": "2022-12-14T21:12:43.171601Z",
"iopub.status.idle": "2022-12-14T21:12:43.175114Z",
"shell.execute_reply": "2022-12-14T21:12:43.174475Z"
},
"id": "aYbWRFPZqk4U"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(3, 2)\n",
"(3, 2)\n"
]
}
],
"source": [
"print(w.shape)\n",
"print(dl_dw.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "dI_SzxHsvao1"
},
"source": [
"다음은 그래디언트 계산입니다. 이번에는 변수의 사전을 전달합니다."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.178177Z",
"iopub.status.busy": "2022-12-14T21:12:43.177758Z",
"iopub.status.idle": "2022-12-14T21:12:43.184413Z",
"shell.execute_reply": "2022-12-14T21:12:43.183806Z"
},
"id": "d73cY6NOuaMd"
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_vars = {\n",
" 'w': w,\n",
" 'b': b\n",
"}\n",
"\n",
"grad = tape.gradient(loss, my_vars)\n",
"grad['b']"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HZ2LvHifEMgO"
},
"source": [
"## 모델에 대한 그래디언트\n",
"\n",
"[검사점 설정](checkpoint.ipynb) 및 [내보내기](saved_model.ipynb)를 위해 `tf.Variables`를 `tf.Module` 또는 해당 서브 클래스(layers.Layer와 keras.Model) 중 하나로 수집하는 것이 일반적입니다.\n",
"\n",
"대부분의 경우 모델의 훈련 가능한 변수에 대한 그래디언트를 계산하려고 합니다. `tf.Module`의 모든 서브 클래스는 `Module.trainable_variables` 속성에서 변수를 집계하므로 몇 줄의 코드로 이러한 그래디언트를 계산할 수 있습니다. "
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.187809Z",
"iopub.status.busy": "2022-12-14T21:12:43.187160Z",
"iopub.status.idle": "2022-12-14T21:12:43.207591Z",
"shell.execute_reply": "2022-12-14T21:12:43.207023Z"
},
"id": "JvesHtbQESc-"
},
"outputs": [],
"source": [
"layer = tf.keras.layers.Dense(2, activation='relu')\n",
"x = tf.constant([[1., 2., 3.]])\n",
"\n",
"with tf.GradientTape() as tape:\n",
" # Forward pass\n",
" y = layer(x)\n",
" loss = tf.reduce_mean(y**2)\n",
"\n",
"# Calculate gradients with respect to every trainable variable\n",
"grad = tape.gradient(loss, layer.trainable_variables)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.210897Z",
"iopub.status.busy": "2022-12-14T21:12:43.210422Z",
"iopub.status.idle": "2022-12-14T21:12:43.213894Z",
"shell.execute_reply": "2022-12-14T21:12:43.213351Z"
},
"id": "PR_ezr6UFrpI"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dense/kernel:0, shape: (3, 2)\n",
"dense/bias:0, shape: (2,)\n"
]
}
],
"source": [
"for var, g in zip(layer.trainable_variables, grad):\n",
" print(f'{var.name}, shape: {g.shape}')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "f6Gx6LS714zR"
},
"source": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.plot(x, y, label='y')\n",
"plt.plot(x, dy_dx, label='dy/dx')\n",
"plt.legend()\n",
"_ = plt.xlabel('x')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6kADybtQzYj4"
},
"source": [
"## 흐름 제어하기\n",
"\n",
"그래디언트 테이프는 실행되는 연산을 기록하기 때문에 Python 제어 흐름이 자연스럽게 처리됩니다(예: `if` 및 `while` 구문).\n",
"\n",
"여기서는 `if`의 각 분기에 서로 다른 변수가 사용됩니다. 그래디언트는 사용된 변수에만 연결됩니다."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.520452Z",
"iopub.status.busy": "2022-12-14T21:12:43.519996Z",
"iopub.status.idle": "2022-12-14T21:12:43.528811Z",
"shell.execute_reply": "2022-12-14T21:12:43.528240Z"
},
"id": "ciFLizhrrjy7"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tf.Tensor(1.0, shape=(), dtype=float32)\n",
"None\n"
]
}
],
"source": [
"x = tf.constant(1.0)\n",
"\n",
"v0 = tf.Variable(2.0)\n",
"v1 = tf.Variable(2.0)\n",
"\n",
"with tf.GradientTape(persistent=True) as tape:\n",
" tape.watch(x)\n",
" if x > 0.0:\n",
" result = v0\n",
" else:\n",
" result = v1**2 \n",
"\n",
"dv0, dv1 = tape.gradient(result, [v0, v1])\n",
"\n",
"print(dv0)\n",
"print(dv1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HKnLaiapsjeP"
},
"source": [
"제어문 자체는 미분할 수 없으므로 그래디언트 기반 최적화 프로그램에는 보이지 않습니다.\n",
"\n",
"위 예제에서 `x` 값에 따라 테이프는 `result = v0` 또는 `result = v1**2`를 기록합니다. `x`에 대한 그래디언트는 항상 `None`입니다."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.531798Z",
"iopub.status.busy": "2022-12-14T21:12:43.531359Z",
"iopub.status.idle": "2022-12-14T21:12:43.534827Z",
"shell.execute_reply": "2022-12-14T21:12:43.534201Z"
},
"id": "8k05WmuAwPm7"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"dx = tape.gradient(result, x)\n",
"\n",
"print(dx)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "egypBxISAHhx"
},
"source": [
"## `gradient`가 `None`을 반환하는 경우\n",
"\n",
"대상이 소스와 연결되어 있지 않으면 `gradient`가 `None`을 반환합니다.\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.537856Z",
"iopub.status.busy": "2022-12-14T21:12:43.537400Z",
"iopub.status.idle": "2022-12-14T21:12:43.542431Z",
"shell.execute_reply": "2022-12-14T21:12:43.541860Z"
},
"id": "CU185WDM81Ut"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"x = tf.Variable(2.)\n",
"y = tf.Variable(3.)\n",
"\n",
"with tf.GradientTape() as tape:\n",
" z = y * y\n",
"print(tape.gradient(z, x))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "sZbKpHfBRJym"
},
"source": [
"여기서 `z`는 명확하게 `x`에 연결되어 있지 않지만, 그래디언트의 연결을 끊을 수 있는 몇 가지 덜 명확한 방법이 있습니다."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eHDzDOiQ8xmw"
},
"source": [
"### 1. 변수를 텐서로 대체했습니다.\n",
"\n",
"[ \"테이프의 감시 대상 제어\"{/ a0} 섹션에서 테이프가 자동으로 `tf.Variable`을 감시하지만 `tf.Tensor`는 감시하지 않는 것을 살펴보았습니다.]()\n",
"\n",
"한 가지 일반적인 오류는 `Variable.assign`를 사용하여 `tf.Variable`를 업데이트하는 대신 실수로 `tf.Variable`을 `tf.Tensor`로 대체하는 것입니다. 예를 들면, 다음과 같습니다."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.545526Z",
"iopub.status.busy": "2022-12-14T21:12:43.545021Z",
"iopub.status.idle": "2022-12-14T21:12:43.550577Z",
"shell.execute_reply": "2022-12-14T21:12:43.549998Z"
},
"id": "QPKY4Tn9zX7_"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ResourceVariable : tf.Tensor(1.0, shape=(), dtype=float32)\n",
"EagerTensor : None\n"
]
}
],
"source": [
"x = tf.Variable(2.0)\n",
"\n",
"for epoch in range(2):\n",
" with tf.GradientTape() as tape:\n",
" y = x+1\n",
"\n",
" print(type(x).__name__, \":\", tape.gradient(y, x))\n",
" x = x + 1 # This should be `x.assign_add(1)`"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3gwZKxgA97an"
},
"source": [
"### 2. TensorFlow 외부에서 계산했습니다.\n",
"\n",
"계산에서 TensorFlow를 종료하면 테이프가 그래디언트 경로를 기록할 수 없습니다. 예를 들면, 다음과 같습니다."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.553374Z",
"iopub.status.busy": "2022-12-14T21:12:43.552928Z",
"iopub.status.idle": "2022-12-14T21:12:43.560912Z",
"shell.execute_reply": "2022-12-14T21:12:43.560352Z"
},
"id": "jmoLCDJb_yw1"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"x = tf.Variable([[1.0, 2.0],\n",
" [3.0, 4.0]], dtype=tf.float32)\n",
"\n",
"with tf.GradientTape() as tape:\n",
" x2 = x**2\n",
"\n",
" # This step is calculated with NumPy\n",
" y = np.mean(x2, axis=0)\n",
"\n",
" # Like most ops, reduce_mean will cast the NumPy array to a constant tensor\n",
" # using `tf.convert_to_tensor`.\n",
" y = tf.reduce_mean(y, axis=0)\n",
"\n",
"print(tape.gradient(y, x))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "p3YVfP3R-tp7"
},
"source": [
"### 3. 정수 또는 문자열을 통해 그래디언트를 구했습니다.\n",
"\n",
"정수와 문자열은 구별할 수 없습니다. 계산 경로에서 이러한 데이터 유형을 사용하면 그래디언트는 없습니다.\n",
"\n",
"아무도 문자열을 미분할 것으로 기대하지는 않지만, `dtype`을 지정하지 않으면 실수로 `int` 상수 또는 변수를 만들기 쉽습니다."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.563762Z",
"iopub.status.busy": "2022-12-14T21:12:43.563314Z",
"iopub.status.idle": "2022-12-14T21:12:43.569099Z",
"shell.execute_reply": "2022-12-14T21:12:43.568543Z"
},
"id": "9jlHXHqfASU3"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"x = tf.constant(10)\n",
"\n",
"with tf.GradientTape() as g:\n",
" g.watch(x)\n",
" y = x * x\n",
"\n",
"print(g.gradient(y, x))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RsdP_mTHX9L1"
},
"source": [
"TensorFlow는 유형 간에 자동으로 전송되지 않으므로 실제로 그래디언트가 누락되는 대신 유형 오류가 발생합니다."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WyAZ7C8qCEs6"
},
"source": [
"### 4. 상태 저장 개체를 통해 그래디언트를 구했습니다.\n",
"\n",
"상태가 그래디언트를 중지합니다. 상태 저장 객체에서 읽을 때 테이프는 현재 상태만 볼 수 있으며 현재 상태에 이르게 된 기록은 볼 수 없습니다.\n",
"\n",
"`tf.Tensor`는 변경할 수 없습니다. 텐서가 작성된 후에는 변경할 수 없습니다. *값*은 있지만 *상태는* 없습니다. 지금까지 논의된 모든 연산은 상태 비저장입니다. `tf.matmul`의 출력은 입력에만 의존합니다.\n",
"\n",
"`tf.Variable`은 내부 상태와 값을 갖습니다. 변수를 사용하면 상태를 읽습니다. 변수와 관련하여 그래디언트를 계산하는 것이 일반적이지만, 변수의 상태는 그래디언트 계산이 더 멀리 돌아가지 않도록 차단합니다. 예를 들면, 다음과 같습니다.\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.571820Z",
"iopub.status.busy": "2022-12-14T21:12:43.571598Z",
"iopub.status.idle": "2022-12-14T21:12:43.578440Z",
"shell.execute_reply": "2022-12-14T21:12:43.577816Z"
},
"id": "C1tLeeRFE479"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"x0 = tf.Variable(3.0)\n",
"x1 = tf.Variable(0.0)\n",
"\n",
"with tf.GradientTape() as tape:\n",
" # Update x1 = x1 + x0.\n",
" x1.assign_add(x0)\n",
" # The tape starts recording from x1.\n",
" y = x1**2 # y = (x1 + x0)**2\n",
"\n",
"# This doesn't work.\n",
"print(tape.gradient(y, x0)) #dy/dx0 = 2*(x1 + x0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "xKA92-dqF2r-"
},
"source": [
"마찬가지로, `tf.data.Dataset` 반복기(iterator)와 `tf.queue`는 상태 저장이며 이들을 통과하는 텐서의 모든 그래디언트를 중지합니다."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HHvcDGIbOj2I"
},
"source": [
"## 그래디언트가 등록되지 않음"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aoc-A6AxVqry"
},
"source": [
"일부 `tf.Operation`는 **미분 불가능한 것으로 등록되어** `None`을 반환합니다. 다른 연산에는 **그래디언트가 등록되지 않았습니다**.\n",
"\n",
"`tf.raw_ops` 페이지에는 그래디언트가 등록된 저수준 op가 표시됩니다.\n",
"\n",
"그래디언트가 등록되지 않은 float op를 통해 그래디언트를 얻고자 시도하면 테이프가 자동으로 `None`을 반환하는 대신 오류가 발생합니다. 이렇게 하면 무언가 잘못되었다는 것을 알 수 있습니다.\n",
"\n",
"예를 들어, `tf.image.adjust_contrast` 함수는 그래디언트를 가질 수 있지만 그래디언트는 구현되지 않은 `raw_ops.AdjustContrastv2`를 래핑합니다.\n"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.581644Z",
"iopub.status.busy": "2022-12-14T21:12:43.581199Z",
"iopub.status.idle": "2022-12-14T21:12:43.591662Z",
"shell.execute_reply": "2022-12-14T21:12:43.591100Z"
},
"id": "HSb20FXc_V0U"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"LookupError: gradient registry has no entry for: AdjustContrastv2\n"
]
}
],
"source": [
"image = tf.Variable([[[0.5, 0.0, 0.0]]])\n",
"delta = tf.Variable(0.1)\n",
"\n",
"with tf.GradientTape() as tape:\n",
" new_image = tf.image.adjust_contrast(image, delta)\n",
"\n",
"try:\n",
" print(tape.gradient(new_image, [image, delta]))\n",
" assert False # This should not happen.\n",
"except LookupError as e:\n",
" print(f'{type(e).__name__}: {e}')\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pDoutjzATiEm"
},
"source": [
"이 op를 통해 미분해야 하는 경우, 그래디언트를 구현하고 등록하거나(`tf.RegisterGradient` 사용) 다른 ops를 사용하여 함수를 다시 구현해야 합니다."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GCTwc_dQXp2W"
},
"source": [
"## None 대신 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TYDrVogA89eA"
},
"source": [
"연결되지 않은 그래디언트의 경우 `None` 대신 0을 가져오는 것이 편리한 경우가 있습니다. 연결되지 않은 그래디언트가 있을 때 `unconnected_gradients` 인수를 사용하여 반환할 항목을 결정할 수 있습니다."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T21:12:43.594841Z",
"iopub.status.busy": "2022-12-14T21:12:43.594252Z",
"iopub.status.idle": "2022-12-14T21:12:43.601314Z",
"shell.execute_reply": "2022-12-14T21:12:43.600778Z"
},
"id": "U6zxk1sf9Ixx"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tf.Tensor([0. 0.], shape=(2,), dtype=float32)\n"
]
}
],
"source": [
"x = tf.Variable([2., 2.])\n",
"y = tf.Variable(3.)\n",
"\n",
"with tf.GradientTape() as tape:\n",
" z = y**2\n",
"print(tape.gradient(z, x, unconnected_gradients=tf.UnconnectedGradients.ZERO))"
]
}
],
"metadata": {
"colab": {
"collapsed_sections": [
"Tce3stUlHN0L"
],
"name": "autodiff.ipynb",
"toc_visible": true
},
"kernelspec": {
"display_name": "Python 3",
"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.9.16"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
![](\"https://www.tensorflow.org/images/tf_logo_32px.png\"){kind=logo}
TensorFlow.org에서 보기 ![](\"https://www.tensorflow.org/images/colab_logo_32px.png\"){kind=logo}
Google Colab에서 실행![](\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\")
GitHub에서 소스 보기 ![](\"https://www.tensorflow.org/images/download_logo_32px.png\"){kind=logo}
노트북 다운로드