자동 미분과 GradientTape 완벽 가이드

딥러닝의 핵심인 자동 미분을 TensorFlow의 GradientTape으로 구현하는 방법을 배웁니다. 미분의 기초부터 경사하강법, 선형 회귀, 고차 미분까지 단계별로 설명합니다.

---

목차

1. 미분의_기초_개념
2. tf.GradientTape_사용법
3. 경사하강법_이해
4. 간단한_선형_회귀_구현
5. Persistent_GradientTape
6. 고차_미분_계산

---

1. 미분의 기초 개념

어느 날 김개발 씨가 딥러닝 강의를 듣다가 멈칫했습니다. 강사가 "손실 함수의 기울기를 구해서 가중치를 업데이트합니다"라고 설명하는데, 도대체 기울기가 무엇이고 왜 필요한 걸까요?

고등학교 때 배운 미분이 여기서 다시 등장할 줄이야.

미분은 한마디로 함수의 변화율, 즉 기울기를 구하는 것입니다. 마치 자동차의 속도계가 현재 위치가 얼마나 빠르게 변하는지 알려주는 것처럼, 미분은 함수가 특정 지점에서 얼마나 빠르게 변하는지 알려줍니다.

딥러닝에서 이 기울기 정보가 있어야 모델이 어느 방향으로 학습해야 하는지 알 수 있습니다.

다음 코드를 살펴봅시다.

import tensorflow as tf

# 간단한 함수: f(x) = x^2
# 미분하면: f'(x) = 2x
x = tf.Variable(3.0)

# GradientTape으로 연산을 기록합니다
with tf.GradientTape() as tape:
    y = x ** 2  # f(x) = x^2

# x에 대한 y의 미분값(기울기)을 계산합니다
gradient = tape.gradient(y, x)

print(f"x = 3일 때, f(x) = x^2의 미분값: {gradient.numpy()}")
# 출력: 6.0 (2 * 3 = 6)

김개발 씨는 입사 6개월 차 주니어 개발자입니다. 회사에서 추천 시스템을 개선하라는 업무를 맡았는데, 딥러닝 모델을 튜닝해야 한다고 합니다.

문제는 딥러닝의 핵심 원리를 제대로 이해하지 못했다는 것입니다. 선배 개발자 박시니어 씨가 다가와 말합니다.

"딥러닝을 이해하려면 먼저 미분을 알아야 해요. 걱정 마세요, 고등학교 수학처럼 복잡하게 손으로 계산할 필요는 없어요." 그렇다면 미분이란 정확히 무엇일까요?

쉽게 비유하자면, 미분은 마치 등산할 때 현재 서 있는 위치의 경사도를 측정하는 것과 같습니다. 경사가 급하면 빠르게 올라가거나 내려가야 하고, 경사가 완만하면 천천히 이동해도 됩니다.

이 경사도 정보가 바로 미분값, 즉 기울기입니다. 수학적으로 미분은 함수 f(x)에서 x가 아주 조금 변할 때 f(x)가 얼마나 변하는지를 나타냅니다.

예를 들어 f(x) = x^2이라면, x가 3에서 3.001로 변할 때 f(x)는 9에서 9.006001로 변합니다. 이 변화의 비율이 바로 미분값입니다.

딥러닝에서 미분이 왜 중요할까요? 신경망은 수많은 가중치를 가지고 있습니다.

이 가중치들을 어떻게 조정해야 모델의 예측이 정답에 가까워질까요? 바로 여기서 미분이 등장합니다.

손실 함수의 기울기를 계산하면, 가중치를 어느 방향으로 얼마나 조정해야 하는지 알 수 있습니다. 위의 코드를 살펴보겠습니다.

먼저 tf.Variable로 변수 x를 정의합니다. Variable은 "이 값은 학습 과정에서 변할 수 있어요"라고 TensorFlow에게 알려주는 것입니다.

그 다음 tf.GradientTape 블록 안에서 연산을 수행합니다. 이 블록은 마치 녹음기처럼 모든 연산을 기록합니다.

마지막으로 **tape.gradient(y, x)**를 호출하면, 기록된 연산을 역으로 추적하여 x에 대한 y의 미분값을 계산합니다. f(x) = x^2의 미분은 f'(x) = 2x이므로, x=3일 때 미분값은 6이 됩니다.

실제 현업에서는 이보다 훨씬 복잡한 함수를 다룹니다. 수백만 개의 가중치와 여러 층의 신경망을 미분해야 합니다.

손으로 계산하는 것은 사실상 불가능합니다. 바로 이것이 자동 미분이 필요한 이유입니다.

다시 김개발 씨의 이야기로 돌아가 봅시다. 박시니어 씨의 설명을 들은 김개발 씨는 고개를 끄덕였습니다.

"아, 미분이 그래서 필요한 거군요! 모델이 학습할 방향을 알려주는 나침반 같은 거네요."

실전 팁

💡 - 미분값이 양수면 함수가 증가하는 방향, 음수면 감소하는 방향입니다

• tf.Variable로 선언해야 GradientTape이 추적할 수 있습니다

---

2. tf.GradientTape 사용법

김개발 씨가 미분의 개념을 이해하고 나니, 이제 실제로 코드로 구현해볼 차례입니다. TensorFlow에서 제공하는 GradientTape을 사용하면 복잡한 미분 공식을 외우지 않아도 자동으로 기울기를 계산할 수 있습니다.

마법 같은 이 도구를 어떻게 사용하는 걸까요?

tf.GradientTape은 TensorFlow에서 자동 미분을 수행하는 핵심 도구입니다. 마치 카세트 테이프가 음악을 녹음하듯, GradientTape은 텐서 연산을 녹음합니다.

녹음이 끝나면 테이프를 되감아 각 연산의 기울기를 역순으로 계산합니다. 이것이 바로 역전파 알고리즘의 핵심입니다.

다음 코드를 살펴봅시다.

import tensorflow as tf

# 여러 변수에 대한 기울기 계산
w = tf.Variable(2.0)
b = tf.Variable(1.0)
x = tf.constant(3.0)

with tf.GradientTape() as tape:
    # 선형 함수: y = w*x + b
    y = w * x + b

# w와 b에 대한 기울기를 동시에 계산
gradients = tape.gradient(y, [w, b])

print(f"w에 대한 기울기: {gradients[0].numpy()}")  # 3.0 (x의 값)
print(f"b에 대한 기울기: {gradients[1].numpy()}")  # 1.0 (상수항의 미분)

김개발 씨가 TensorFlow 문서를 읽다가 GradientTape이라는 단어를 발견했습니다. "테이프?

왜 테이프지?" 궁금해하던 김개발 씨에게 박시니어 씨가 설명을 시작합니다. "옛날 카세트 테이프 알지?

음악을 녹음하고, 되감아서 다시 들을 수 있잖아. GradientTape도 똑같아요." GradientTape의 동작 원리를 자세히 살펴봅시다.

먼저 with tf.GradientTape() as tape: 구문으로 녹음을 시작합니다. 이 블록 안에서 일어나는 모든 텐서 연산은 테이프에 기록됩니다.

덧셈, 곱셈, 제곱, 행렬 연산 등 모든 것이 녹음됩니다. 블록이 끝나면 녹음도 끝납니다.

이제 tape.gradient() 함수를 호출하면, 테이프를 되감으면서 각 연산의 기울기를 역순으로 계산합니다. 이것이 바로 역전파 알고리즘입니다.

위의 코드에서 y = w * x + b라는 선형 함수를 정의했습니다. 이 함수를 w에 대해 미분하면 x가 나오고, b에 대해 미분하면 1이 나옵니다.

x가 3이므로 w에 대한 기울기는 3.0, b에 대한 기울기는 1.0입니다. 여기서 중요한 점이 있습니다.

tf.Variable로 선언한 변수만 자동으로 추적됩니다. x는 tf.constant로 선언했기 때문에 기본적으로 추적되지 않습니다.

학습시키고 싶은 파라미터는 반드시 Variable로 선언해야 합니다. 만약 상수도 추적하고 싶다면 tape.watch() 함수를 사용합니다.

tape.watch(x)를 호출하면 상수 x도 추적 대상에 포함됩니다. 실무에서는 어떻게 활용할까요?

신경망의 가중치와 편향을 w와 b라고 생각해보세요. 입력 데이터 x가 들어오면 예측값 y가 계산됩니다.

이 예측값과 실제 정답의 차이가 손실입니다. GradientTape으로 손실에 대한 w와 b의 기울기를 구하면, 가중치를 어떻게 조정해야 하는지 알 수 있습니다.

주의할 점이 있습니다. GradientTape은 기본적으로 한 번만 사용할 수 있습니다.

tape.gradient()를 호출하면 테이프에 기록된 자원이 해제됩니다. 여러 번 기울기를 계산하려면 persistent=True 옵션을 사용해야 합니다.

이 내용은 뒤에서 자세히 다루겠습니다. 김개발 씨는 코드를 직접 실행해보며 감탄했습니다.

"와, 이렇게 간단하게 미분이 되다니! 손으로 편미분 공식 유도할 필요가 없네요."

실전 팁

💡 - tf.Variable은 자동 추적, tf.constant는 tape.watch() 필요

• tape.gradient()의 두 번째 인자로 리스트를 전달하면 여러 변수의 기울기를 동시에 계산

---

3. 경사하강법 이해

기울기를 구할 수 있게 되었으니, 이제 이 기울기를 어떻게 활용하는지 알아볼 차례입니다. 김개발 씨가 "그래서 기울기로 뭘 하는 건가요?"라고 묻자, 박시니어 씨가 웃으며 대답합니다.

"이제 본격적으로 학습을 시킬 거예요. 경사하강법이라고 들어봤어요?"

경사하강법은 기울기의 반대 방향으로 조금씩 이동하여 손실 함수의 최솟값을 찾는 최적화 알고리즘입니다. 마치 안개 낀 산에서 가장 낮은 골짜기를 찾아 내려가는 것과 같습니다.

현재 위치에서 가장 가파른 내리막 방향으로 한 걸음씩 이동하면 결국 가장 낮은 곳에 도달합니다.

다음 코드를 살펴봅시다.

import tensorflow as tf

# 최솟값을 찾고 싶은 함수: f(x) = (x-3)^2
# 최솟값은 x=3일 때 f(x)=0

x = tf.Variable(0.0)  # 시작점
learning_rate = 0.1   # 학습률

for step in range(20):
    with tf.GradientTape() as tape:
        loss = (x - 3) ** 2  # 손실 함수

    gradient = tape.gradient(loss, x)

    # 경사하강법: x = x - learning_rate * gradient
    x.assign_sub(learning_rate * gradient)

    if step % 5 == 0:
        print(f"Step {step}: x = {x.numpy():.4f}, loss = {loss.numpy():.4f}")

박시니어 씨가 화이트보드에 산 모양의 그래프를 그립니다. "여기 산이 있다고 상상해봐요.

안개가 자욱해서 주변밖에 안 보여요. 가장 낮은 골짜기를 어떻게 찾을까요?" 김개발 씨가 대답합니다.

"음... 발밑을 더듬어서 내리막 방향으로 가면 되지 않을까요?" "바로 그거예요!

그게 경사하강법이에요." 경사하강법의 핵심 아이디어는 단순합니다. 현재 위치에서 기울기를 계산하고, 그 기울기의 반대 방향으로 이동합니다.

기울기가 양수면 함수가 증가하는 방향이므로, 반대로 가야 함수값이 줄어듭니다. 위의 코드에서 손실 함수는 f(x) = (x-3)^2입니다.

이 함수는 x=3일 때 최솟값 0을 가집니다. 우리의 목표는 아무것도 모르는 상태에서 시작해서 x=3을 찾아가는 것입니다.

처음에 x는 0으로 시작합니다. GradientTape으로 기울기를 계산하면 -6이 나옵니다.

기울기가 음수이므로 x를 증가시켜야 합니다. x.assign_sub(learning_rate * gradient)는 x에서 (학습률 x 기울기)를 빼는 연산입니다.

음수를 빼면 더해지므로 x가 증가합니다. 여기서 학습률이 중요한 역할을 합니다.

학습률이 너무 크면 최솟값을 지나쳐버릴 수 있습니다. 마치 산을 내려가다가 너무 큰 걸음으로 뛰어서 반대편 산으로 넘어가는 것과 같습니다.

반대로 학습률이 너무 작으면 최솟값에 도달하는 데 너무 오래 걸립니다. 코드를 실행하면 x가 0에서 시작해서 점점 3에 가까워지는 것을 볼 수 있습니다.

20번의 반복 후에는 거의 정확히 3에 도달합니다. 이것이 바로 신경망이 학습하는 원리입니다.

실제 딥러닝에서는 수백만 개의 파라미터에 대해 이 과정을 동시에 수행합니다. 손실 함수도 훨씬 복잡하고, 데이터도 방대합니다.

하지만 근본 원리는 동일합니다. 기울기를 계산하고, 그 반대 방향으로 조금씩 이동합니다.

김개발 씨가 눈을 빛내며 말합니다. "아, 그래서 딥러닝 학습에 시간이 오래 걸리는 거군요!

조금씩 조금씩 최적의 값을 찾아가니까요." "맞아요. 그래서 GPU가 필요한 거예요.

이 계산을 엄청나게 빠르게 해주거든요."

실전 팁

💡 - 학습률이 너무 크면 발산, 너무 작으면 학습이 느림

• assign_sub는 -= 연산과 같지만 텐서에서 사용할 수 있음

---

4. 간단한 선형 회귀 구현

이론을 배웠으니 이제 실제 문제를 풀어볼 시간입니다. 김개발 씨가 데이터 분석팀에서 넘겨받은 간단한 데이터가 있습니다.

입력 x와 출력 y 사이의 관계를 찾아야 합니다. 선형 회귀를 직접 구현해보면서 GradientTape의 진가를 확인해봅시다.

선형 회귀는 데이터의 패턴을 직선으로 표현하는 가장 기본적인 머신러닝 알고리즘입니다. y = wx + b 형태의 직선에서 최적의 w와 b를 찾는 것이 목표입니다.

GradientTape과 경사하강법을 사용하면 이 문제를 우아하게 해결할 수 있습니다.

다음 코드를 살펴봅시다.

import tensorflow as tf
import numpy as np

# 샘플 데이터 생성 (실제로는 y = 2x + 1)
X = np.array([1, 2, 3, 4, 5], dtype=np.float32)
Y = np.array([3, 5, 7, 9, 11], dtype=np.float32)

# 학습할 파라미터
w = tf.Variable(0.0)
b = tf.Variable(0.0)

learning_rate = 0.01

# 학습 루프
for epoch in range(100):
    with tf.GradientTape() as tape:
        predictions = w * X + b
        loss = tf.reduce_mean((predictions - Y) ** 2)  # MSE 손실

    gradients = tape.gradient(loss, [w, b])
    w.assign_sub(learning_rate * gradients[0])
    b.assign_sub(learning_rate * gradients[1])

print(f"학습된 w: {w.numpy():.4f}, b: {b.numpy():.4f}")

김개발 씨가 데이터를 엑셀에서 확인합니다. x가 1일 때 y는 3, x가 2일 때 y는 5...

뭔가 규칙이 있는 것 같습니다. 하지만 데이터가 수천 개라면 눈으로 확인하기 어렵습니다.

박시니어 씨가 말합니다. "선형 회귀를 사용하면 돼요.

데이터를 가장 잘 설명하는 직선을 찾아주거든요." 선형 회귀의 목표는 y = wx + b 형태의 직선에서 최적의 가중치 w와 편향 b를 찾는 것입니다. 여기서 최적이란 모든 데이터 포인트와 직선 사이의 거리가 최소가 되는 것을 의미합니다.

이 거리를 측정하는 방법이 손실 함수입니다. 가장 흔히 사용하는 것이 **MSE(Mean Squared Error)**입니다.

예측값과 실제값의 차이를 제곱하고 평균을 냅니다. 제곱하는 이유는 음수와 양수 오차가 상쇄되는 것을 막기 위함입니다.

코드를 단계별로 살펴봅시다. 먼저 샘플 데이터를 준비합니다.

실제로 이 데이터는 y = 2x + 1 관계를 따릅니다. 우리의 모델이 이 관계를 찾아낼 수 있을까요?

w와 b를 0으로 초기화합니다. 아직 아무것도 모르는 상태입니다.

GradientTape 블록 안에서 예측값을 계산하고, MSE 손실을 구합니다. tf.reduce_mean은 모든 데이터 포인트에 대한 평균을 계산합니다.

tape.gradient로 w와 b에 대한 기울기를 구합니다. 그리고 경사하강법으로 w와 b를 업데이트합니다.

이 과정을 100번 반복합니다. 코드를 실행하면 w는 약 2.0, b는 약 1.0으로 수렴합니다.

우리 모델이 원래 관계인 y = 2x + 1을 정확히 찾아낸 것입니다. 실제 현업에서는 tf.keras의 내장 모델과 옵티마이저를 사용합니다.

하지만 내부에서 일어나는 일은 정확히 우리가 방금 구현한 것과 같습니다. 원리를 이해하면 복잡한 모델도 디버깅하기 쉬워집니다.

김개발 씨가 감탄합니다. "신기하네요!

컴퓨터가 스스로 규칙을 찾아내다니." 박시니어 씨가 웃으며 대답합니다. "이게 머신러닝의 핵심이에요.

우리가 규칙을 알려주는 게 아니라, 데이터에서 규칙을 학습하는 거죠."

실전 팁

💡 - 학습률이 너무 크면 손실이 발산하므로 작은 값부터 시작

• 실무에서는 tf.keras.optimizers.SGD 같은 내장 옵티마이저 사용

---

5. Persistent GradientTape

김개발 씨가 한 가지 의문이 생겼습니다. "같은 연산에 대해 여러 변수의 기울기를 따로따로 계산하고 싶으면 어떻게 하죠?" 기본 GradientTape은 한 번 사용하면 사라집니다.

이 문제를 해결하는 것이 바로 Persistent GradientTape입니다.

Persistent GradientTape은 여러 번 기울기를 계산할 수 있는 특별한 테이프입니다. 기본 테이프는 한 번 재생하면 사라지지만, persistent=True 옵션을 주면 여러 번 재생할 수 있습니다.

다만 메모리를 수동으로 해제해야 하므로 주의가 필요합니다.

다음 코드를 살펴봅시다.

import tensorflow as tf

x = tf.Variable(3.0)

# persistent=True로 여러 번 사용 가능한 테이프 생성
with tf.GradientTape(persistent=True) as tape:
    y = x ** 2      # y = x^2
    z = x ** 3      # z = x^3

# 같은 테이프로 여러 번 기울기 계산
dy_dx = tape.gradient(y, x)  # 2x = 6
dz_dx = tape.gradient(z, x)  # 3x^2 = 27

print(f"dy/dx = {dy_dx.numpy()}")  # 6.0
print(f"dz/dx = {dz_dx.numpy()}")  # 27.0

# 중요: 메모리 해제
del tape

김개발 씨가 복잡한 모델을 디버깅하고 있습니다. 손실 함수가 여러 개의 항으로 구성되어 있어서, 각 항에 대한 기울기를 따로 확인하고 싶습니다.

그런데 문제가 생겼습니다. "어?

tape.gradient()를 두 번 호출했더니 에러가 나네요?" 박시니어 씨가 설명합니다. "기본 GradientTape은 한 번만 사용할 수 있어요.

카세트 테이프를 한 번 재생하면 자동으로 지워진다고 생각하면 돼요." 이 문제를 해결하는 것이 Persistent GradientTape입니다. persistent=True 옵션을 주면 테이프가 자동으로 지워지지 않습니다.

원하는 만큼 여러 번 기울기를 계산할 수 있습니다. 위의 코드에서 y = x^2와 z = x^3 두 개의 함수를 정의했습니다.

같은 테이프를 사용해서 dy/dx와 dz/dx를 각각 계산합니다. x=3일 때 dy/dx = 23 = 6이고, dz/dx = 39 = 27입니다.

하지만 주의할 점이 있습니다. Persistent 테이프는 자동으로 메모리가 해제되지 않습니다.

사용이 끝나면 반드시 del tape으로 명시적으로 삭제해야 합니다. 그렇지 않으면 메모리 누수가 발생할 수 있습니다.

언제 Persistent 테이프를 사용할까요? 첫째, 같은 연산에 대해 여러 타겟의 기울기를 계산할 때 유용합니다.

둘째, 디버깅 목적으로 중간 결과를 확인할 때 편리합니다. 셋째, 복잡한 손실 함수의 각 구성 요소를 분석할 때 사용합니다.

그러나 일반적인 학습 루프에서는 Persistent 테이프가 필요하지 않습니다. 한 번의 역전파로 모든 파라미터의 기울기를 한꺼번에 계산할 수 있기 때문입니다.

tape.gradient(loss, [w1, w2, w3, ...]) 형태로 리스트를 전달하면 됩니다. 김개발 씨가 정리합니다.

"그러니까 특별한 경우에만 persistent 옵션을 쓰고, 보통은 기본 테이프로 충분하다는 거죠?" 박시니어 씨가 고개를 끄덕입니다. "맞아요.

그리고 persistent 테이프를 쓸 때는 del을 잊지 마세요!"

실전 팁

💡 - persistent 테이프는 특별한 경우에만 사용

• 사용 후 반드시 del tape으로 메모리 해제

---

6. 고차 미분 계산

김개발 씨가 논문을 읽다가 "2차 미분"이라는 단어를 발견했습니다. 1차 미분도 이제 이해했는데, 2차 미분은 뭘까요?

물리학에서 속도의 변화율이 가속도이듯, 기울기의 기울기를 구하는 것이 바로 고차 미분입니다. TensorFlow에서는 GradientTape을 중첩해서 고차 미분을 계산합니다.

고차 미분은 미분을 여러 번 수행하는 것입니다. 1차 미분이 함수의 기울기라면, 2차 미분은 기울기의 변화율, 즉 함수의 곡률을 나타냅니다.

TensorFlow에서는 GradientTape을 중첩하여 고차 미분을 계산합니다. 이는 뉴턴 방법이나 Hessian 행렬 계산에 활용됩니다.

다음 코드를 살펴봅시다.

import tensorflow as tf

x = tf.Variable(2.0)

# GradientTape 중첩으로 2차 미분 계산
with tf.GradientTape() as tape2:
    with tf.GradientTape() as tape1:
        y = x ** 3  # f(x) = x^3

    # 1차 미분: f'(x) = 3x^2
    dy_dx = tape1.gradient(y, x)

# 2차 미분: f''(x) = 6x
d2y_dx2 = tape2.gradient(dy_dx, x)

print(f"f(x) = x^3 일 때")
print(f"x = 2에서 f'(x) = {dy_dx.numpy()}")    # 3*4 = 12
print(f"x = 2에서 f''(x) = {d2y_dx2.numpy()}")  # 6*2 = 12

박시니어 씨가 물리학 예시를 들어 설명합니다. "위치를 시간에 대해 미분하면 속도가 나와요.

속도를 다시 미분하면 가속도가 나오죠. 이게 바로 고차 미분이에요." 수학적으로 f(x) = x^3을 예로 들어봅시다.

1차 미분은 f'(x) = 3x^2입니다. 이것을 다시 미분하면 f''(x) = 6x가 됩니다.

x=2일 때 f'(2) = 12이고, f''(2) = 12입니다. TensorFlow에서 고차 미분을 계산하려면 GradientTape을 중첩해야 합니다.

위의 코드를 자세히 살펴봅시다. 바깥쪽 tape2와 안쪽 tape1, 두 개의 테이프를 생성합니다.

안쪽 tape1 블록에서 원래 함수 y = x^3을 계산합니다. tape1.gradient(y, x)로 1차 미분 dy_dx를 구합니다.

여기서 중요한 점은 이 1차 미분 계산 자체가 tape2 블록 안에서 일어난다는 것입니다. 따라서 tape2는 dy_dx가 어떻게 계산되었는지 기록하고 있습니다.

마지막으로 tape2.gradient(dy_dx, x)를 호출하면 1차 미분의 미분, 즉 2차 미분을 얻습니다. 고차 미분은 언제 사용할까요?

첫째, 뉴턴 방법과 같은 2차 최적화 알고리즘에서 사용합니다. 1차 미분만 사용하는 경사하강법보다 빠르게 수렴할 수 있습니다.

둘째, Hessian 행렬을 계산할 때 필요합니다. Hessian은 모든 파라미터 쌍에 대한 2차 편미분으로 구성됩니다.

셋째, 물리 시뮬레이션에서 가속도를 계산할 때 활용됩니다. 다만 실무에서 고차 미분을 직접 계산하는 경우는 드뭅니다.

계산 비용이 크기 때문입니다. 대부분의 딥러닝 모델은 1차 미분 기반의 옵티마이저로 충분합니다.

Adam, SGD, RMSprop 등이 모두 1차 미분을 사용합니다. 김개발 씨가 정리합니다.

"GradientTape을 겹겹이 쌓으면 원하는 만큼 고차 미분을 할 수 있군요. 3차, 4차도 가능하겠네요?" 박시니어 씨가 대답합니다.

"이론적으로는 가능해요. 하지만 계산량이 기하급수적으로 늘어나니까 실제로 3차 이상은 거의 사용하지 않아요." 김개발 씨는 오늘 배운 내용을 정리하며 뿌듯해합니다.

미분의 기초부터 GradientTape 사용법, 경사하강법, 선형 회귀, Persistent 테이프, 그리고 고차 미분까지. 이제 딥러닝의 핵심 원리를 이해하게 되었습니다.

실전 팁

💡 - 고차 미분은 계산 비용이 크므로 꼭 필요할 때만 사용

• 3개 이상의 테이프를 중첩하면 3차 미분도 가능

---

이상으로 학습을 마칩니다. 위 내용을 직접 코드로 작성해보면서 익혀보세요!