Skip to content

TensorFlow 치트시트

구글이 만든 엔드투엔드 오픈 소스 머신러닝 플랫폼.

01

시작하기

설치와 기초

TensorFlow 2.x는 기본적으로 즉시 실행(eager) 모드로 동작합니다(일반 Python처럼 연산이 바로 실행됨). tf.config.list_physical_devices('GPU')로 CUDA GPU가 보이는지 확인하세요. GPU 지원은 Linux/Windows에서 [and-cuda] 추가 패키지를 설치하거나 Apple Silicon에서는 tensorflow-metal을 사용하세요. TF 2.x는 Keras를 tf.keras로 통합했으며 대부분의 워크플로에서 쓰는 고수준 API입니다.

tensorflow
# install TensorFlow (CPU)
pip install tensorflow

# with GPU support on Linux/Windows (CUDA-enabled)
pip install tensorflow[and-cuda]

import tensorflow as tf

# check version and devices
print(tf.__version__)
print("GPU:", tf.config.list_physical_devices('GPU'))

# eager execution is on by default in TF2
print(tf.executing_eagerly())   # True

첫 텐서

tf.constant는 불변 텐서를 만들고 tf.zeros / tf.ones / tf.random.*은 흔한 패턴을 만듭니다. 모든 텐서에는 shape, dtype, rank가 있습니다. .numpy()는 NumPy로 되돌리는 다리이며 GPU에서는 동기 복사를 유발할 수 있습니다. ML의 기본값인 float32 같은 명시적 dtype을 사용해 성능을 깨는 조용한 업캐스트를 피하세요.

tensorflow
import tensorflow as tf

# constants are immutable
x = tf.constant([[1, 2], [3, 4]])
y = tf.zeros((3, 3))
z = tf.random.normal((2, 3), mean=0.0, stddev=1.0)

print(x.shape, x.dtype)   # (2, 2) int32
print(tf.reduce_sum(x))   # tf.Tensor(10, shape=(), dtype=int32)

# numpy interop is zero-copy when possible
print(x.numpy())          # array([[1, 2], [3, 4]])

즉시 실행과 기울기

즉시 실행은 TF를 일반 Python처럼 디버깅 가능하게 합니다. print, pdb, 트레이스백이 모두 동작합니다. GradientTape는 감시 대상 텐서(tf.Variable은 자동 감시)의 순전파 연산을 기록해 tape.gradient가 미분을 계산하게 합니다. 커스텀 학습 루프의 기반입니다. tape는 기본적으로 일회용이므로 gradient를 여러 번 호출하려면 persistent=True를 사용하세요.

tensorflow
import tensorflow as tf

a = tf.constant(3.0)
b = tf.constant(4.0)
print(a * b + 1)   # tf.Tensor(13.0, ...)

# GradientTape records ops for automatic differentiation
with tf.GradientTape() as tape:
    tape.watch(a)
    y = a ** 2 + b    # y = a^2 + b, dy/da = 2a
grad = tape.gradient(y, a)
print(grad)   # tf.Tensor(6.0, ...)  (= 2*3)

tf.function과 그래프

@tf.function은 Python 함수를 이식 가능하고 최적화 가능한 TensorFlow 그래프로 변환합니다. GPU에서 훨씬 빠르고 분산에 필요합니다. 함수는 입력 시그니처마다 한 번 추적되므로 Python 부수 효과나 데이터 의존적 Python 제어 흐름을 피하세요(tf.cond / tf.while_loop를 쓰지 않으면 함수가 다시 추적됨). 변수는 함수 밖에서 한 번 만들어야 하며, 아니면 같은 이름으로 tf.Variable을 재사용하세요.

tensorflow
import tensorflow as tf

@tf.function  # traces a graph; runs in graph mode after first call
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = x * w + b
        loss = tf.reduce_mean((preds - y) ** 2)
    grads = tape.gradient(loss, [w, b])
    optimizer.apply_gradients(zip(grads, [w, b]))
    return loss

w = tf.Variable(0.1)
b = tf.Variable(0.0)
optimizer = tf.keras.optimizers.SGD(0.01)

# first call builds the graph (slower); subsequent calls are fast
loss = train_step(tf.constant([1., 2.]), tf.constant([2., 4.]))

혼합 정밀도

혼합 정밀도는 float16으로 계산하되 float32 마스터 복사본을 유지해 Tensor Core GPU(Volta+)에서 2-3배 처리량과 절반 메모리를 얻습니다. 'mixed_float16' 정책은 언더플로를 막기 위해 손실 스케일링을 자동 처리합니다. 수치 안정성을 위해 출력 레이어는 float32로 강제하세요. 컴퓨트 능력 7.0 이상이 필요하며 구형 GPU에서는 더 느릴 수 있습니다.

tensorflow
import tensorflow as tf

# enable mixed precision: compute in float16, store in float32
tf.keras.mixed_precision.set_global_policy('mixed_float16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', dtype='float32'),
    tf.keras.layers.Dense(10, activation='softmax', dtype='float32')
])

# loss scaling is automatic with mixed_float16 policy
print(tf.keras.mixed_precision.global_policy())
02

텐서

tf.constant

tf.constant는 불변 텐서를 만듭니다. 요소에 할당할 수 없습니다. 학습 가능한 텐서에는 tf.Variable을 사용하세요. tf.random.normal/uniform은 재현성을 위해 seed 인자를 받습니다. tf.random.set_seed(42)는 프로그램 전체를 재현 가능하게 합니다. 다차원 생성에는 int가 아닌 shape 튜플을 사용해 예상 밖 동작을 피하세요.

tensorflow
import tensorflow as tf

a = tf.constant([1, 2, 3])
b = tf.constant([[1.0, 2.0], [3.0, 4.0]], dtype=tf.float32)

zeros = tf.zeros((2, 3))
ones = tf.ones((3, 3))
eye = tf.eye(3)
full = tf.fill((2, 3), 7.0)

arange = tf.range(0, 10, 2)       # [0, 2, 4, 6, 8]
linspace = tf.linspace(0.0, 1.0, 5)

rand = tf.random.uniform((2, 3))
randn = tf.random.normal((2, 3))

# constants are immutable: a[0] = 5  -> TypeError

tf.Variable

tf.Variable은 모델 매개변수와 옵티마이저 상태에 쓰는 가변 텐서 래퍼입니다. assign / assign_add / assign_sub는 제자리에서 갱신합니다. 일반 Python 할당(w = w + 1)은 새 텐서를 만들고 변경하지 않습니다. Variable은 GradientTape가 자동 감시하지만 tf.constant는 tape.watch()를 명시해야 합니다. Variable은 이를 사용하는 연산과 같은 장치에 두세요.

tensorflow
import tensorflow as tf

w = tf.Variable(0.1, dtype=tf.float32)
W = tf.Variable(tf.random.normal((3, 4)))
b = tf.Variable(tf.zeros((4,)))

# read value
print(w.numpy())        # 0.1

# update value
w.assign(0.5)
w.assign_add(0.1)       # w += 0.1
w.assign_sub(0.05)

# assign in place on a slice
W[0, 0].assign(99.0)

# watched by GradientTape automatically
with tf.GradientTape() as tape:
    y = w ** 2
grad = tape.gradient(y, w)   # 2w

텐서 연산

대부분의 수학은 NumPy와 같습니다. tf.reduce_sum / reduce_mean / reduce_max는 np.sum/mean/max에 대응합니다. axis=로 특정 차원을 줄이고 keepdims=True로 브로드캐스팅을 위해 rank를 보존하세요. tf.matmul과 @ 연산자는 행렬 곱을 합니다(입력이 3D 이상이면 배치 처리). reshape는 가능하면 뷰를 반환하고 transpose는 TF에서 항상 복사본을 반환합니다.

tensorflow
import tensorflow as tf

a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[5.0, 6.0], [7.0, 8.0]])

a + b; a - b; a * b; a / b      # element-wise
c = tf.matmul(a, b)              # matrix multiply
c = a @ b                        # equivalent

tf.reduce_sum(a)                 # sum of all
tf.reduce_sum(a, axis=0)         # sum along axis 0
tf.reduce_mean(a, axis=1)        # mean along axis 1
tf.reduce_max(a, axis=1)
tf.reduce_sum(a, axis=1, keepdims=True)

x = tf.range(12)
y = tf.reshape(x, (3, 4))
t = tf.transpose(y)              # shape (4, 3)

인덱싱과 슬라이싱

TF는 즉시 실행 모드와 tf.function 안에서 NumPy 스타일 슬라이싱을 지원합니다. tf.boolean_mask는 마스크가 True인 요소를 추출합니다(평탄화). tf.gather는 기본적으로 axis 0을 따라 선택합니다(팬시 인덱싱). tf.where(cond, x, y)는 벡터화된 삼항 연산입니다. cond가 True면 x, 아니면 y를 고릅니다. 할당에는 tf.tensor_scatter_nd_update나 tf.Variable을 사용하세요.

tensorflow
import tensorflow as tf

x = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

x[0]              # first row
x[1, 2]           # element (1,2) -> 6
x[:, 1]           # second column
x[0:2]            # first two rows
x[:, ::2]         # every other column

# boolean mask
mask = x > 4
sel = tf.boolean_mask(x, mask)   # tensor([5, 6, 7, 8, 9])

# gather by indices
idx = tf.constant([0, 2])
rows = tf.gather(x, idx)         # rows 0 and 2

# where: select from two tensors
tf.where(x > 4, x, tf.zeros_like(x))

Ragged와 Sparse 텐서

Ragged 텐서는 패딩 없이 가변 길이 시퀀스를 저장하므로 길이가 다른 NLP 배치에 완벽합니다. Sparse 텐서는 0이 아닌 인덱스와 값만 저장해 매우 희소한 데이터(추천, 그래프)의 메모리를 절약합니다. 대부분의 연산에 희소 인식 변형이 있으므로 연산이 요구할 때만 dense로 변환하세요. tf.RaggedTensor.to_tensor()는 임베딩 조회를 위해 사각형으로 패딩합니다.

tensorflow
import tensorflow as tf

# ragged: variable-length sequences
ragged = tf.ragged.constant([[1, 2, 3], [4], [5, 6]])
print(ragged.shape)           # (3, None)
ragged.to_tensor()            # pad to (3, 3)

# sparse: mostly-zero tensors
indices = [[0, 0], [1, 2], [2, 1]]
values = [1.0, 2.0, 3.0]
sparse = tf.sparse.SparseTensor(
    indices=indices, values=values, dense_shape=[3, 3])
dense = tf.sparse.to_dense(sparse)

sp_sum = tf.sparse.reduce_sum(sparse)
sp_matmul = tf.sparse.sparse_dense_matmul(sparse, tf.eye(3))

브로드캐스팅과 수학

브로드캐스팅은 작은 차원의 텐서를 큰 것과 맞게 요소별로 늘립니다. clip_by_value는 TF의 클램프입니다. tf.maximum/minimum은 요소별이며 차원을 줄이는 tf.reduce_max/min과 다릅니다. cumsum/cumprod는 축을 따라 누적 합/곱을 생성해 누적 지표와 커스텀 레이어의 접두사 합 알고리즘에 유용합니다.

tensorflow
import tensorflow as tf

# broadcasting follows NumPy rules
a = tf.constant([[1.0, 2.0, 3.0]])    # shape (1, 3)
b = tf.constant([[10.0], [20.0]])      # shape (2, 1)
c = a + b                              # shape (2, 3)

tf.abs(x); tf.sqrt(x); tf.exp(x); tf.log(x)
tf.square(x); tf.pow(x, 3)
tf.maximum(a, b); tf.minimum(a, b)
tf.clip_by_value(x, 0.0, 1.0)

tf.norm(x)                  # L2 norm
tf.norm(x, ord=1)           # L1 norm

tf.cumsum(tf.range(5))      # [0, 1, 3, 6, 10]
tf.cumprod(tf.range(1, 5))  # [1, 2, 6, 24]
03

Keras 모델

Sequential API

Sequential은 가장 단순한 Keras 모델입니다. 각 레이어 출력이 다음으로 이어지는 선형 파이프라인입니다. input_shape는 배치 차원을 제외합니다(가변 배치는 None). model.summary()는 레이어 모양과 매개변수 수를 출력합니다. input_shape를 넘기지 않으면 첫 fit/순전파 호출에서 지연 생성되므로 더 일찍 확인하려면 build()를 명시 호출하세요.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.summary()

# build later with input_shape (or first call)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10))
model.build((None, 784))   # None = variable batch

Functional API

Functional API는 레이어가 분기, 병합, 건너뛰기를 할 수 있게 하므로 비선형 구조(ResNet, 다중 입력/출력, 샴 네트워크)에 필요합니다. Input 텐서를 정의하고 레이어를 호출해 연결한 뒤 inputs/outputs를 Model에 넘기세요. 결과 모델은 fit/predict에서 Sequential과 동일하게 동작합니다. 깔끔한 저장과 서빙 시그니처를 위해 입출력에 이름을 붙이세요.

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(784,), name='img')
x = tf.keras.layers.Dense(128, activation='relu')(inputs)
x = tf.keras.layers.Dropout(0.5)(x)
x = tf.keras.layers.Dense(64, activation='relu')(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs, name='mlp')

# multi-input / multi-output
img_in = tf.keras.Input(shape=(224, 224, 3))
meta_in = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Conv2D(32, 3, activation='relu')(img_in)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.concatenate([x, meta_in])
out = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model([img_in, meta_in], out)

모델 서브클래싱

tf.keras.Model을 서브클래싱하면 순전파를 완전히 제어할 수 있습니다(PyTorch처럼). __init__에서 레이어를 정의하고 call(inputs, training=)을 구현하세요. training 플래그는 드롭아웃과 BatchNorm 동작을 토글합니다. 유연하지만 Functional API의 이점 일부를 잃습니다. 검사/시각화가 어렵고 자동 입력 모양 추론이 없으며 직렬화가 까다롭습니다. 대부분의 아키텍처에는 Functional을, 연구 모델에는 서브클래싱을 권장하세요.

tensorflow
import tensorflow as tf

class MLP(tf.keras.Model):
    def __init__(self, hidden=128, num_classes=10):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(hidden, activation='relu')
        self.drop = tf.keras.layers.Dropout(0.5)
        self.dense2 = tf.keras.layers.Dense(hidden, activation='relu')
        self.out = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs, training=False):
        x = self.dense1(inputs)
        x = self.drop(x, training=training)
        x = self.dense2(x)
        return self.out(x)

model = MLP(hidden=64)
model.build((None, 784))
model.summary()

모델 컴파일

compile은 fit 전에 옵티마이저, 손실, 지표를 연결합니다. 문자열('adam', 'mse')은 해당 클래스의 단축이며 사용자 정의 하이퍼파라미터에는 객체를 넘기세요. 다중 출력 모델에는 출력 이름을 손실에 매핑한 딕셔너리를 넘기세요. run_eagerly=True는 tf.function 추적을 꺼서 pdb와 print를 쓸 수 있게 하므로 디버깅에 매우 유용하지만 느립니다.

tensorflow
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
    loss_weights={'cls': 1.0, 'box': 0.5},
)

# explicit objects (more control)
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=[tf.keras.metrics.SparseCategoricalAccuracy(name='acc')],
    run_eagerly=False,   # debug mode: run without graph
)

모델 요약과 플롯

summary()는 레이어별 출력 모양과 매개변수 수 표를 출력하므로 모양 버그를 찾는 가장 빠른 방법입니다. plot_model은 시각적 그래프를 저장합니다(pydot와 Graphviz 필요). get_config는 가중치 없이 아키텍처를 재구성할 수 있는 직렬화 딕셔너리를 반환하며 model.to_json()과 Keras 저장 형식이 사용합니다. Functional 모델은 config가 아키텍처를 완전히 담지만 서브클래싱 모델은 get_config를 직접 구현해야 합니다.

tensorflow
model.summary()
print(model.layers)
print(model.inputs, model.outputs)

# plot architecture (needs pydot + graphviz)
tf.keras.utils.plot_model(
    model, to_file='model.png', show_shapes=True,
    show_layer_names=True, rankdir='TB',
)

print(f"{model.count_params():,} params")

config = model.get_config()
new_model = tf.keras.Model.from_config(config)

모델 내 전처리

전처리를 모델 안에 넣으면(Rescaling, 증강 Keras 레이어) 배포 가능해집니다. 같은 SavedModel이 추론 시 원시 이미지를 받아 별도 전처리 단계가 필요 없습니다. Keras 전처리 레이어는 GPU와 tf.function 안에서 실행되어 빠릅니다. 학습 전용 증강은 fit에서 training=True로 설정해 추론 시 비활성화하세요. Rescaling(1./255)은 uint8 [0,255] 이미지를 float [0,1]로 변환합니다.

tensorflow
import tensorflow as tf

# preprocessing as part of the model (deployable)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # ...
])
# the model now includes preprocessing, so inference needs raw images
04

레이어

Dense 레이어

Dense는 완전 연결 레이어입니다: y = activation(xW + b). 가중치 모양은 (in_features, out_features)로 PyTorch의 전치입니다. kernel_initializer는 기본 Glorot/Xavier uniform이라 tanh/sigmoid에 좋고 ReLU 계열에는 'he_normal'을 사용하세요. kernel_regularizer로 L2 정규화를 추가하세요. GELU는 트랜스포머의 기본 활성화입니다.

tensorflow
import tensorflow as tf

dense = tf.keras.layers.Dense(
    units=64, activation='relu', use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='zeros',
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
)

x = tf.random.normal((4, 128))
y = dense(x)                     # shape (4, 64)

print(dense.kernel.shape)        # (128, 64)
print(dense.bias.shape)          # (64,)

dense = tf.keras.layers.Dense(64, activation=tf.nn.gelu)

Conv2D 레이어

TF/Keras는 PyTorch의 NCHW와 반대로 기본 NHWC(channels-last)를 사용합니다. padding='same'은 출력 공간 크기가 입력 크기 / stride가 되도록 패딩하고 'valid'는 패딩이 없습니다. DepthwiseConv2D는 입력 채널마다 필터 하나를 적용합니다(MobileNet에서 사용). Conv2DTranspose는 업샘플링합니다(분할 디코더에서 사용). 커널 모양은 (kH, kW, in_channels, filters)입니다.

tensorflow
import tensorflow as tf

conv = tf.keras.layers.Conv2D(
    filters=32, kernel_size=3, strides=(1, 1),
    padding='same', activation='relu', use_bias=True,
)

x = tf.random.normal((4, 28, 28, 3))   # NHWC
out = conv(x)
print(out.shape)                        # (4, 28, 28, 32) with padding='same'

dw = tf.keras.layers.DepthwiseConv2D(3, padding='same', activation='relu')
up = tf.keras.layers.Conv2DTranspose(32, 3, strides=2, padding='same')

순환 레이어(LSTM/GRU)

RNN의 입력 모양은 (batch, timesteps, features)입니다. RNN을 쌓거나 시퀀스-투-시퀀스 모델을 만들 때 return_sequences=True가 필요하고 시퀀스-투-벡터에는 False입니다. Bidirectional은 순방향과 역방향 출력을 연결해 출력 크기를 두 배로 만듭니다. recurrent_dropout은 편리하지만 느립니다(cuDNN 가속 없음). 대신 입력에 일반 드롭아웃을 권장하세요.

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(units=128, return_sequences=False)
x = tf.random.normal((4, 10, 64))   # (batch, time, features)
out = lstm(x)                       # (4, 128)

# stacked LSTM needs return_sequences=True
model = tf.keras.Sequential([
    tf.keras.layers.LSTM(128, return_sequences=True, input_shape=(10, 64)),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(10),
])

gru = tf.keras.layers.GRU(128)
bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)   # shape (4, 128) — 64 * 2

드롭아웃과 정규화

Dropout은 학습 중 유닛을 무작위로 0으로 만들어 공동 적응을 막고 추론 시(training=False) 자동 비활성화됩니다. SpatialDropout2D는 특징 맵 전체를 드롭해 합성곱 신경망에 더 좋습니다. L2(가중치 감쇠)는 가장 흔한 정규화입니다. LayerNormalization은 배치 축이 아니라 특징 축(샘플별)으로 정규화하므로 트랜스포머와 RNN에 선호됩니다(BatchNorm과 대조).

tensorflow
import tensorflow as tf

drop = tf.keras.layers.Dropout(0.5)
x = tf.random.normal((4, 10))
y = drop(x, training=True)   # training=True activates dropout

tf.keras.layers.SpatialDropout2D(0.5)   # drop entire feature maps
tf.keras.layers.GaussianDropout(0.5)
tf.keras.layers.AlphaDropout(0.5)

# weight regularization
tf.keras.layers.Dense(64,
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
    activity_regularizer=tf.keras.regularizers.l1(1e-5))

norm = tf.keras.layers.LayerNormalization()

배치 정규화

BatchNormalization은 채널별로 활성화를 정규화하고 추론용 EMA 실행 통계를 유지합니다. NHWC에서 axis=-1은 마지막(채널) 축을 정규화합니다. BN은 합성곱 뒤, 활성화 앞에 두고 BN의 beta가 이동을 처리하므로 합성곱의 bias를 끄세요(use_bias=False). momentum은 실행 통계가 데이터를 얼마나 빨리 따라가는지 제어하며 높은 값(0.99)이 더 안정적입니다. BN은 학습과 추론에서 다르게 동작합니다(training 플래그).

tensorflow
import tensorflow as tf

bn = tf.keras.layers.BatchNormalization(
    axis=-1, momentum=0.99, epsilon=1e-3,
)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, padding='same', use_bias=False),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.ReLU(),
])

print(len(bn.weights))         # 4
print(len(bn.trainable_weights))    # 2

커스텀 레이어

Layer를 서브클래싱해 커스텀 연산을 만드세요. 가중치는 __init__이 아니라 build()(입력 모양과 함께 한 번 호출)에서 정의해 입력 크기에 적응하게 하세요. get_config()를 구현해 레이어를 직렬화하고 다시 로드할 수 있게 하세요. add_weight는 텐서를 Keras 추적에 등록해 weights에 나타나고 저장되며 장치로 이동하게 합니다. 상태 없는 변환은 build()를 생략하고 call()만 재정의할 수 있습니다.

tensorflow
import tensorflow as tf

class Linear(tf.keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer='glorot_uniform', trainable=True, name='w')
        self.b = self.add_weight(
            shape=(self.units,), initializer='zeros', trainable=True, name='b')

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({'units': self.units})
        return config

layer = Linear(64)
out = layer(tf.random.normal((4, 10)))
05

손실

BinaryCrossentropy

BinaryCrossentropy는 이진 작업이나 다중 레이블(각 클래스 독립)에 사용합니다. 모델이 원시 로짓을 출력하면 from_logits=True를 넘기세요. sigmoid + BCE를 따로 적용하는 것보다 수치적으로 안전합니다. pos_weight는 양성 예제의 가중치를 높여 불균형을 처리합니다. C개 클래스의 다중 레이블 문제에서 타깃 모양은 0/1의 (N, C)이고 예측은 (N, C) 확률 또는 로짓입니다.

tensorflow
import tensorflow as tf

bce = tf.keras.losses.BinaryCrossentropy(from_logits=False)
y_true = tf.constant([[1.0], [0.0], [1.0], [0.0]])
y_pred = tf.constant([[0.9], [0.1], [0.8], [0.2]])
loss = bce(y_true, y_pred)

# from_logits=True is more numerically stable
bce_logits = tf.keras.losses.BinaryCrossentropy(from_logits=True)
logits = tf.constant([[2.0], [-2.0], [1.5], [-1.5]])
loss = bce_logits(y_true, logits)

bce = tf.keras.losses.BinaryCrossentropy(
    from_logits=True, pos_weight=tf.constant([5.0]))

CategoricalCrossentropy

CategoricalCrossentropy는 원-핫 타깃을, SparseCategoricalCrossentropy는 정수 클래스 인덱스를 기대합니다(클래스가 많을 때 메모리 효율적). 모델이 softmax로 끝나지 않으면 항상 from_logits=True를 넘기세요. 수치 안정성을 위해 log-sum-exp 기법을 사용합니다. 레이블 스무딩에는 CategoricalCrossentropy(label_smoothing=0.1)를 쓰세요. 분류와 NLP에 강력한 정규화입니다.

tensorflow
import tensorflow as tf

# one-hot labels
cce = tf.keras.losses.CategoricalCrossentropy(from_logits=False)
y_true = tf.constant([[0, 1, 0], [1, 0, 0]], dtype=tf.float32)
y_pred = tf.constant([[0.1, 0.8, 0.1], [0.7, 0.2, 0.1]])
loss = cce(y_true, y_pred)

# integer labels -> use sparse version
scce = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
y_true_int = tf.constant([1, 0])
logits = tf.constant([[1.0, 3.0, 0.5], [2.5, 0.2, 0.1]])
loss = scce(y_true_int, logits)

MSE와 회귀 손실

MSE는 큰 오차를 제곱으로 벌해 이상치에 민감하고 MAE는 선형입니다. Huber는 0 근처에서 MSE처럼, 멀리서 MAE처럼 동작하며 객체 탐지 회귀의 기본입니다. LogCosh는 비슷하지만 모든 곳에서 두 번 미분 가능해 2차 기울기가 필요할 때 유용합니다. 모든 reduction 기본값은 배치 평균이며 샘플별 손실에는 reduction=tf.keras.losses.Reduction.NONE을 사용하세요.

tensorflow
import tensorflow as tf

mse = tf.keras.losses.MeanSquaredError()
y_true = tf.constant([3.0, -0.5, 2.0, 7.0])
y_pred = tf.constant([2.5, 0.0, 2.0, 8.0])
loss = mse(y_true, y_pred)

mae = tf.keras.losses.MeanAbsoluteError()
loss = mae(y_true, y_pred)

huber = tf.keras.losses.Huber(delta=1.0)
loss = huber(y_true, y_pred)

logcosh = tf.keras.losses.LogCosh()
loss = logcosh(y_true, y_pred)

커스텀 손실

커스텀 손실은 (y_true, y_pred)를 받아 스칼라 텐서를 반환하는 호출 가능 객체입니다. 직렬화나 하이퍼파라미터가 필요하면 tf.keras.losses.Loss를 서브클래싱하고 call() + get_config()를 구현하세요. 모든 연산을 미분 가능하게 유지하세요. FocalLoss는 쉬운 예제의 가중치를 낮춰 어려운 것에 집중하므로 객체 탐지에 인기입니다. 마스킹이 동작하려면 call()에서 Reduction.NONE을 쓰고 Keras가 마지막에 줄이게 하세요.

tensorflow
import tensorflow as tf

def weighted_mse(y_true, y_pred):
    weights = tf.cast(y_true != 0, tf.float32)
    return tf.reduce_sum(weights * tf.square(y_true - y_pred)) / tf.reduce_sum(weights)

class FocalLoss(tf.keras.losses.Loss):
    def __init__(self, alpha=0.25, gamma=2.0, **kwargs):
        super().__init__(**kwargs)
        self.alpha = alpha
        self.gamma = gamma

    def call(self, y_true, y_pred):
        bce = tf.keras.losses.binary_crossentropy(y_true, y_pred)
        p = y_pred
        pt = p * y_true + (1 - p) * (1 - y_true)
        return self.alpha * tf.pow(1 - pt, self.gamma) * bce

    def get_config(self):
        config = super().get_config()
        config.update({'alpha': self.alpha, 'gamma': self.gamma})
        return config

loss = FocalLoss(alpha=0.25, gamma=2.0)

로짓에서의 손실

softmax를 계산한 뒤 교차 엔트로피를 따로 계산하면 큰 로짓(e^100)에서 오버플로할 수 있습니다. from_logits=True를 넘기면 TF가 log-sum-exp 기법으로 융합해 수치적으로 안정적입니다. 함수형 tf.nn.*_cross_entropy_with_logits API도 같은 일을 합니다. from_logits=True를 쓸 때 모델이 softmax/sigmoid로 끝나지 않게 하세요. 그렇지 않으면 활성화를 두 번 적용합니다.

tensorflow
import tensorflow as tf

# why logits? numerical stability
logits = tf.constant([[100.0, 0.0, 0.0]])

# BAD: softmax first then CCE (can overflow)
probs = tf.nn.softmax(logits)
loss_bad = tf.keras.losses.CategoricalCrossentropy()(
    tf.constant([[1.0, 0.0, 0.0]]), probs)

# GOOD: from_logits=True uses log-sum-exp internally
loss_good = tf.keras.losses.CategoricalCrossentropy(from_logits=True)(
    tf.constant([[1.0, 0.0, 0.0]]), logits)

loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=z)
loss = tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=z)

다중 출력 손실

다중 출력 모델에는 출력 이름을 손실 함수에 매핑한 딕셔너리와 균형을 맞출 loss_weights 딕셔너리를 넘기세요. 총 손실은 가중 합입니다. 멀티태스크 학습의 표준 패턴이며 각 헤드가 자체 손실과 지표를 가집니다. fit 시 같은 키의 딕셔너리로 학습 타깃을 넘기세요. 단일 작업이 기울기를 지배하지 않도록 loss_weights를 조정하세요.

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss={
        'priority': tf.keras.losses.BinaryCrossentropy(from_logits=True),
        'department': tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    },
    loss_weights={'priority': 1.0, 'department': 0.5},
    metrics={'priority': ['accuracy'], 'department': ['accuracy']},
)

inputs = tf.keras.Input(shape=(64,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
out_a = tf.keras.layers.Dense(1, name='priority')(x)
out_b = tf.keras.layers.Dense(10, name='department')(x)
model = tf.keras.Model(inputs, [out_a, out_b])

model.fit(x_train, {'priority': y_pri, 'department': y_dep}, epochs=5)
06

옵티마이저

Adam

Adam은 대부분 작업의 기본 옵티마이저입니다. 매개변수별 적응 학습률을 쓰고 하이퍼파라미터 선택에 견고합니다. beta_1/beta_2는 1차/2차 모멘트의 EMA 감쇠를 제어합니다. 학습 중 LR을 감쇠하려면 float 대신 LearningRateSchedule 객체를 넘기세요. global_clipnorm은 결합 노름이 임계값을 넘으면 모든 기울기를 재스케일하므로 RNN과 트랜스포머에 중요합니다.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(learning_rate=1e-3)

opt = tf.keras.optimizers.Adam(
    learning_rate=1e-3, beta_1=0.9, beta_2=0.999,
    epsilon=1e-7, amsgrad=False,
)

# schedule as learning_rate
lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000)
opt = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

# gradient clipping
opt = tf.keras.optimizers.Adam(learning_rate=1e-3, global_clipnorm=1.0)

SGD

SGD + 모멘텀은 큰 배치 CNN 학습에서 Adam보다 일반화가 좋은 경우가 많지만 LR 튜닝이 더 필요합니다. momentum=0.9가 표준이고 Nesterov는 약간의 추가 이점을 줍니다. weight_decay는 분리된 L2 정규화를 추가합니다(Keras 3). 구버전에서는 레이어의 kernel_regularizer를 대신 사용합니다. SGD가 Adam과 경쟁하려면 워밍업과 LR 스케줄링이 필요합니다.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.SGD(learning_rate=0.01)
opt = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, nesterov=True)

# with weight decay (Keras 2.13+ / 3.x)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, weight_decay=1e-4)

# clip gradients by value
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, clipvalue=0.5)

AdamW와 기타 옵티마이저

AdamW는 가중치 감쇠를 기울기 갱신에서 분리하며 대규모(트랜스포머, 큰 CNN)에서 중요합니다. RMSprop은 고전적인 RNN 옵티마이저입니다. Adagrad는 매개변수별 적응을 하지만 초기에 멈출 수 있어 희소 특징에는 괜찮습니다. FTRL은 희소 특징이 있는 대규모 온라인 학습(클릭률 예측)용입니다. 새 프로젝트는 AdamW로 시작하세요.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.AdamW(
    learning_rate=3e-4, weight_decay=0.01,
    beta_1=0.9, beta_2=0.999)

opt = tf.keras.optimizers.RMSprop(learning_rate=1e-3, rho=0.9)
opt = tf.keras.optimizers.Adagrad(learning_rate=1e-2)
opt = tf.keras.optimizers.Adadelta(learning_rate=1.0)
opt = tf.keras.optimizers.Nadam(learning_rate=1e-3)
opt = tf.keras.optimizers.Ftrl(learning_rate=0.1)

기울기 적용

커스텀 학습 루프에서는 GradientTape로 기울기를 계산한 뒤 opt.apply_gradients(zip(grads, vars))를 호출합니다. 커스텀 학습 루프의 구성 요소입니다(커스텀 학습 루프 섹션 참고). clip_by_global_norm은 결합 L2 노름이 임계값 아래로 유지되도록 기울기를 재스케일합니다. None 기울기는 변수가 손실에 영향을 주지 않았다는 뜻이며 사용하지 않는 매개변수에서 흔하므로 로깅할 가치가 있습니다.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3)
vars = [w, b]

with tf.GradientTape() as tape:
    preds = model(x)
    loss = loss_fn(y, preds)
grads = tape.gradient(loss, vars)

grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

for v, g in zip(vars, grads):
    print(v.name, g is not None, g.numpy().norm() if g is not None else None)

학습률 스케줄

LearningRateSchedule 객체는 옵티마이저의 스텝 카운터에 대한 함수로 LR을 계산합니다. CosineDecay는 alpha*initial_lr까지 부드럽게 감쇠하는 강력한 기본값입니다. CosineDecayRestarts는 SGDR 스타일 웜 재시작을 구현합니다. 옵티마이저 생성 시 learning_rate로 스케줄을 넘기면 Keras가 매 스텝 자동 호출합니다. 워밍업에는 커스텀 스케줄로 감싸거나 tensorflow/addons의 WarmUp 콜백을 사용하세요.

tensorflow
import tensorflow as tf

sched = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
    boundaries=[500, 1500], values=[1e-3, 1e-4, 1e-5])

sched = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=1e-3, decay_steps=1000, decay_rate=0.96,
    staircase=True)

sched = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000, alpha=0.0)

opt = tf.keras.optimizers.Adam(learning_rate=sched)
print(opt.learning_rate(opt.iterations))

기울기 클리핑과 EMA

global_clipnorm(모든 기울기를 함께 재스케일)은 가장 흔한 선택이며 트랜스포머가 사용합니다. clipvalue는 각 요소를 하드 클램프합니다. 커스텀 클리핑은 tape.gradient와 apply_gradients 사이에서 grads를 수정하세요. 가중치의 지수 이동 평균(EMA)은 추론 시 약간의 정확도 향상을 주는 경우가 많습니다. 매 스텝 후 적용하고 평가에 평균 가중치를 사용하세요. TF Addons에 MovingAverage 옵티마이저 래퍼가 있습니다.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3, global_clipnorm=1.0)
opt = tf.keras.optimizers.Adam(1e-3, clipvalue=0.5)
opt = tf.keras.optimizers.Adam(1e-3, clipnorm=1.0)

# manual clipping (more control)
grads = tape.gradient(loss, vars)
grads = [tf.clip_by_norm(g, 1.0) if g is not None else g for g in grads]
grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

# exponential moving average of weights (improves generalization)
ema = tf.train.ExponentialMovingAverage(decay=0.999)
07

학습

compile과 fit

fit은 고수준 학습 API로 배치, 셔플, 검증, 콜백, 진행 표시를 처리합니다. validation_data=(x, y) 또는 validation_split=0.2(학습에서 분리)를 넘기세요. verbose=2는 에포크당 한 줄(로그에 좋음), 1은 진행 막대를 보여줍니다. 반환된 history 객체는 에포크별 손실과 지표를 저장하므로 과적합을 찾기 위해 플롯하세요.

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
)

history = model.fit(
    x_train, y_train, batch_size=32, epochs=10,
    validation_data=(x_val, y_val),
    validation_split=0.2, shuffle=True, verbose=2,
)

print(history.history['loss'])

검증과 지표

지표는 배치에 걸쳐 누적되어 에포크 끝에 최종 값을 계산하는 상태 객체입니다. 손실과 달리 학습에 영향을 주지 않습니다. 문자열('accuracy')이나 사용자 정의 Metric 객체를 넘기세요. tf.keras.metrics.Metric을 서브클래싱하고 update_state/result/reset_state를 구현하세요. reset_state(TF 2.11+에서 reset_states에서 개명)는 각 에포크 시작에 호출됩니다.

tensorflow
model.compile(
    optimizer='adam', loss='sparse_categorical_crossentropy',
    metrics=[
        'accuracy',
        tf.keras.metrics.SparseTopKCategoricalAccuracy(k=5, name='top5_acc'),
        tf.keras.metrics.Precision(name='precision'),
        tf.keras.metrics.Recall(name='recall'),
    ],
)

class F1Score(tf.keras.metrics.Metric):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.precision = tf.keras.metrics.Precision()
        self.recall = tf.keras.metrics.Recall()
    def update_state(self, y_true, y_pred, sample_weight=None):
        self.precision.update_state(y_true, y_pred, sample_weight)
        self.recall.update_state(y_true, y_pred, sample_weight)
    def result(self):
        p, r = self.precision.result(), self.recall.result()
        return 2 * p * r / (p + r + 1e-8)
    def reset_state(self):
        self.precision.reset_state(); self.recall.reset_state()

에포크, 배치 크기, 스텝

tf.data.Dataset을 쓰면 batch_size를 넘기지 마세요. 데이터셋이 이미 배치되어 있습니다. steps_per_epoch는 데이터셋이 무한 반복될 때 한 에포크를 구성하는 배치 수를 fit에 알려줍니다. validation_steps도 검증에 같은 역할을 합니다. initial_epoch로 체크포인트에서 학습을 재개하세요. fit은 처음 N개 에포크를 건너뛰지만 옵티마이저 상태(LR 스케줄, 모멘텀)는 올바르게 이어집니다.

tensorflow
model.fit(x_train, y_train, batch_size=32, epochs=10)

# with tf.data.Dataset
model.fit(train_dataset, epochs=10, validation_data=val_dataset)

# Dataset of unknown size: use steps_per_epoch
model.fit(
    train_dataset, epochs=10, steps_per_epoch=500,
    validation_data=val_dataset, validation_steps=50,
)

# initial epoch (resume training)
model.fit(train_dataset, initial_epoch=5, epochs=10)

클래스 및 샘플 가중치

class_weight는 클래스별 손실을 스케일해 불균형에 대응하며 추가 계산 없이 오버샘플링하는 것과 같습니다. sample_weight는 예제별 제어를 주므로 어려운 예제 마이닝이나 패딩 위치 마스킹에 유용합니다. tf.data.Dataset을 쓰면 sample_weight를 세 번째 튜플 요소로 넣어 (x, y, w)를 생성하세요. sklearn.utils.class_weight로 균형 가중치를 자동 계산할 수 있습니다.

tensorflow
class_weight = {0: 1.0, 1: 5.0, 2: 1.0}   # class 1 is rare
model.fit(x_train, y_train, class_weight=class_weight, epochs=10)

sample_weight = np.where(y_train == 1, 5.0, 1.0)
model.fit(x_train, y_train, sample_weight=sample_weight, epochs=10)

# with Dataset: yield (x, y, sample_weight) tuples
ds = tf.data.Dataset.from_tensor_slices((x, y, w))
model.fit(ds, epochs=10)

from sklearn.utils import class_weight
cw = class_weight.compute_class_weight('balanced', classes=np.unique(y), y=y)
class_weight = dict(enumerate(cw))

Predict와 Evaluate

predict는 전체 입력에 대한 예측의 NumPy 배열을 반환하며 batch_size로 메모리를 제어하세요. evaluate는 손실과 compile의 지표를 반환합니다. 매우 큰 입력은 predict_on_batch로 배치를 수동 반복하세요. 모델을 직접 호출(model(x))하면 텐서를 반환하고 training=을 존중하지만 predict는 항상 추론 모드로 실행되고 NumPy를 반환합니다. 테스트 시 증강에는 model(x, training=True)를 사용하세요.

tensorflow
preds = model.predict(x_test, batch_size=64)
print(preds.shape)   # (N, num_classes)

pred = model.predict(x_test[:1])

loss, acc = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
test_loss, test_acc, test_prec = model.evaluate(test_dataset)

for batch in test_dataset:
    preds = model.predict_on_batch(batch[0])

preds = model(x_test, training=True)   # callable form, test-time aug

train_step 재정의

train_step을 재정의하면 fit의 에포크 루프, 콜백, 분산을 유지하면서 각 배치에서 일어나는 일을 커스터마이즈할 수 있습니다. 고수준 fit과 완전 커스텀 루프 사이의 다리이며 GAN, 대조 학습, 비표준 목적에 좋습니다. compile()의 손실/지표가 계속 동작하도록 self.compiled_loss와 self.compiled_metrics를 사용하세요. test_step도 같은 방식으로 검증 동작을 재정의합니다.

tensorflow
import tensorflow as tf

class CustomModel(tf.keras.Model):
    def train_step(self, data):
        x, y = data
        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)
            loss = self.compiled_loss(y, y_pred, regularization_losses=self.losses)
        grads = tape.gradient(loss, self.trainable_variables)
        self.optimizer.apply_gradients(zip(grads, self.trainable_variables))
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

    def test_step(self, data):
        x, y = data
        y_pred = self(x, training=False)
        self.compiled_loss(y, y_pred)
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

model = CustomModel(inputs, outputs)
model.compile(optimizer='adam', loss='...', metrics=['accuracy'])
model.fit(dataset, epochs=10)
08

콜백

EarlyStopping

EarlyStopping은 감시 지표가 개선되지 않으면 학습을 멈춰 시간을 절약하고 과적합을 막습니다. patience=N은 개선 없는 N개 에포크를 기다립니다. restore_best_weights=True는 마지막에 최적 에포크로 되돌립니다. 없으면 (더 나쁠 수 있는) 최종 가중치를 유지합니다. 손실에는 mode='min', 정확도에는 'max'를 쓰세요. 항상 넉넉한 최대 에포크를 설정하고 콜백이 결정하게 하세요.

tensorflow
import tensorflow as tf

early = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', min_delta=0.001, patience=5,
    mode='auto', restore_best_weights=True, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[early])

ModelCheckpoint

ModelCheckpoint는 학습 중 모델을 저장해 충돌에서 복구하거나 최적 에포크를 고를 수 있게 합니다. save_best_only=True는 감시 지표 기준 최적 체크포인트만 유지하므로 monitor를 검증 지표로 설정하세요. save_weights_only=True는 더 작고 아키텍처 독립적이지만 다시 로드하려면 모델 클래스가 필요합니다. {epoch:02d} 같은 형식 자리 표시자는 파일 이름에 에포크를 넣습니다. save_freq='epoch'가 기본이고 정수 N은 N배치마다 저장합니다.

tensorflow
import tensorflow as tf

ckpt = tf.keras.callbacks.ModelCheckpoint(
    filepath='checkpoints/epoch-{epoch:02d}-val-{val_loss:.3f}.keras',
    monitor='val_loss', save_best_only=True, save_weights_only=False,
    mode='min', save_freq='epoch', verbose=1,
)

ckpt = tf.keras.callbacks.ModelCheckpoint(
    'weights.{epoch:02d}.h5', save_weights_only=True, save_freq='epoch',
)

model.fit(train_ds, validation_data=val_ds, epochs=50, callbacks=[ckpt])

ReduceLROnPlateau

ReduceLROnPlateau는 감시 지표가 정체되면 LR을 낮춥니다. 적절한 스케줄을 미리 모르를 때 유용합니다. factor는 배수(0.5 = 절반), patience는 기다릴 에포크 수, min_lr은 하한입니다. cooldown은 감소 직후 모니터링을 잠시 멈춰 새 LR이 안정되게 합니다. EarlyStopping과 결합하세요. 먼저 LR을 낮추고 더 개선이 없으면 멈춥니다. verbose=1은 각 감소를 출력합니다.

tensorflow
import tensorflow as tf

reduce = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss', factor=0.5, patience=3, min_lr=1e-7,
    mode='min', min_delta=1e-4, cooldown=0, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[reduce])

TensorBoard 콜백

TensorBoard 콜백은 학습 지표, 가중치 히스토그램, 모델 그래프, 프로파일링 데이터를 로그 디렉터리로 스트리밍합니다. histogram_freq=1은 에포크별 가중치 분포를 기록하고 0이면 공간을 절약합니다. profile_batch=2는 배치 2에서 TF Profiler를 실행해 성능 병목(입력 파이프라인, 연산 지연)을 찾습니다. log_dir를 가리켜 TensorBoard를 실행하세요. 실험마다 별도 하위 디렉터리를 써서 실행을 비교하세요.

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='./logs/fit', histogram_freq=1, write_graph=True,
    write_images=False, update_freq='epoch',
    profile_batch=2, embeddings_freq=0,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])
# launch: tensorboard --logdir=./logs

LearningRateScheduler

LearningRateScheduler는 (epoch, lr) 함수를 받아 각 에포크 시작에 새 LR을 적용합니다. 단순하지만 에포크 단위입니다. 스텝 단위 스케줄에는 옵티마이저에 넘기는 LearningRateSchedule 객체를 권장하세요(옵티마이저 섹션 참고). 매 배치 호출되고 tf.function 안에서 동작합니다. 콜백 형식은 거친 스케줄에 괜찮습니다. 워밍업+감쇠에는 스케줄 객체가 더 깔끔합니다.

tensorflow
import tensorflow as tf

def schedule(epoch, lr):
    if epoch < 10:
        return lr
    return lr * tf.math.exp(-0.1).numpy()

scheduler = tf.keras.callbacks.LearningRateScheduler(schedule, verbose=1)

class StepScheduler(tf.keras.callbacks.Callback):
    def on_train_batch_begin(self, batch, logs=None):
        step = self.model.optimizer.iterations.numpy()
        new_lr = 1e-3 * (0.5 ** (step // 1000))
        self.model.optimizer.learning_rate.assign(new_lr)

scheduler = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: 1e-3 * 0.9 ** epoch)

커스텀 콜백

콜백은 학습 수명 주기에 연결됩니다: on_epoch_begin/end, on_train_batch_begin/end, on_test_*, on_predict_*. self.model로 모델에, self.model.optimizer로 옵티마이저에 접근하세요. logs는 현재 지표 딕셔너리입니다. 커스텀 콜백은 로깅, LR 조작, 조기 종료(self.model.stop_training = True), 외부 시스템(W&B, MLflow) 동기화에 좋습니다. 매 배치 실행되므로 저렴하게 유지하세요.

tensorflow
import tensorflow as tf

class DebugCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        lr = self.model.optimizer.learning_rate
        if hasattr(lr, 'numpy'):
            lr = lr.numpy()
        print(f"Epoch {epoch}: lr={lr}, logs={logs}")

    def on_train_batch_end(self, batch, logs=None):
        if batch % 100 == 0:
            print(f"  batch {batch}: loss={logs.get('loss'):.4f}")

    def on_train_end(self, logs=None):
        print("Training finished!")

model.fit(train_ds, epochs=5, callbacks=[DebugCallback()])
09

tf.data 파이프라인

tf.data.Dataset

tf.data.Dataset은 TF의 스트리밍 데이터 API로 디스크/CPU에서 GPU로 데이터를 효율적으로 파이프라인합니다. from_tensor_slices는 축 0을 따라 텐서를 묶습니다. 표준 체인은 shuffle -> batch -> prefetch입니다. shuffle은 무작위화, batch는 그룹화, prefetch는 다음 배치 준비를 현재 학습과 겹칩니다. AUTOTUNE을 쓰면 TF가 prefetch 버퍼 크기를 자동 선택합니다.

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x_train, y_train))

def gen():
    for i in range(len(x_train)):
        yield x_train[i], y_train[i]
ds = tf.data.Dataset.from_generator(gen, output_signature=(
    tf.TensorSpec(shape=(28, 28), dtype=tf.float32),
    tf.TensorSpec(shape=(), dtype=tf.int32),
))

ds = ds.shuffle(10000).batch(32).prefetch(tf.data.AUTOTUNE)

for x, y in ds:
    print(x.shape, y.shape)
    break

Map, Filter, Cache

map은 각 요소에 함수를 적용합니다(증강, 정규화, 토큰화). num_parallel_calls=AUTOTUNE은 CPU 코어에 걸쳐 병렬화합니다. cache()는 데이터셋을 메모리(또는 파일)에 저장해 이후 에포크가 소스를 건너뛰게 하므로 중소규모 데이터에 큰 속도 향상을 줍니다. 하지만 무작위 연산 전에 캐시해야 매 에포크 같은 증강이 반복되지 않습니다. 표준 순서는 cache -> map(augment) -> shuffle -> batch -> prefetch입니다.

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, 0.2)
    return image, label

ds = tf.data.Dataset.from_tensor_slices((images, labels))
ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)
ds = ds.map(lambda x, y: (tf.cast(x, tf.float32) / 255.0, y))
ds = ds.filter(lambda x, y: y < 10)

ds = ds.cache()                    # in memory
ds = ds.cache('/tmp/data.cache')   # to file

ds = ds.cache().shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)

Batch, Shuffle, Repeat

shuffle은 크기 N 버퍼를 채우고 하나를 샘플한 뒤 다시 채우므로 버퍼가 데이터셋 크기 이상이면 진정한 무작위 순서를 줍니다. shuffle -> repeat -> batch는 매 에포크 다시 섞습니다. steps_per_epoch로 학습하려면 repeat()을 써서 데이터셋이 고갈되지 않게 하세요. drop_remainder=True는 마지막 짧은 배치를 버리며 BatchNorm과 고정 모양 모델에 중요합니다. seed는 같은 seed로 reshuffle_each_iteration=True일 때만 반복 간 셔플을 재현 가능하게 합니다.

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x, y))
ds = ds.batch(32, drop_remainder=False)
ds = ds.shuffle(buffer_size=10000, seed=42, reshuffle_each_iteration=True)
ds = ds.repeat()         # infinite
ds = ds.repeat(5)        # 5 epochs

# recommended order: shuffle -> repeat -> batch
ds = ds.shuffle(10000).repeat().batch(32)

Prefetch와 성능

prefetch(AUTOTUNE)이 가장 큰 단일 이점입니다. GPU가 배치 N을 학습하는 동안 CPU가 배치 N+1을 준비해 서로 기다리지 않습니다. map의 num_parallel_calls=AUTOTUNE은 CPU 바운드 전처리를 병렬화합니다. 최적 파이프라인 순서는 source -> cache -> shuffle -> map(augment) -> batch -> prefetch입니다. tf.data.experimental.AUTOTUNE(tf.data.AUTOTUNE과 같음)을 쓰고 TF가 버퍼 크기를 조정하게 하세요. 최적화 전에 항상 프로파일링하세요. 병목은 종종 다른 곳에 있습니다.

tensorflow
import tensorflow as tf

ds = ds.prefetch(tf.data.AUTOTUNE)
ds = ds.map(parse_fn, num_parallel_calls=tf.data.AUTOTUNE)

# full recommended pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32)
      .prefetch(tf.data.AUTOTUNE))

파일 읽기

TextLineDataset은 텍스트 파일(로그, CSV 행)에서 줄을 스트리밍합니다. make_csv_dataset은 자동 열 타입 추론으로 CSV를 파싱합니다. image_dataset_from_directory는 PyTorch ImageFolder의 Keras 대응으로 하위 디렉터리 이름에서 라벨을 추론하고 (image_batch, label_batch)를 반환합니다. 이미지 로딩을 더 제어하려면 map 함수에서 tf.io.read_file + tf.io.decode_image를 사용하세요. fit에 넘기기 전에 항상 데이터셋을 배치하세요.

tensorflow
import tensorflow as tf

ds = tf.data.TextLineDataset(['file1.txt', 'file2.txt'])

ds = tf.data.experimental.make_csv_dataset(
    'data.csv', batch_size=32, label_name='label',
    num_epochs=1, shuffle_buffer_size=1000,
)

ds = tf.keras.utils.image_dataset_from_directory(
    'data/train', image_size=(224, 224), batch_size=32,
    shuffle=True, seed=42, validation_split=0.2, subset='training',
)

TFRecord

TFRecord는 TF의 바이너리 레코드 형식으로 대규모 데이터셋을 디스크에서 공급하는 가장 빠른 방법입니다. 각 레코드는 직렬화된 tf.train.Example(특징 딕셔너리)입니다. 읽기가 순차 I/O라 클라우드 스토리지(GCS/S3)의 무작위 읽기보다 훨씬 빠릅니다. 이미지는 원시 바이트를 저장하고 map()에서 디코드하세요. 더 작은 파일에는 tf.data.TFRecordDataset에 compression='GZIP'을 사용하세요. 샤딩(여러 .tfrecord-0000N-of-0000M 파일)은 병렬 읽기를 가능하게 합니다.

tensorflow
import tensorflow as tf

def serialize(x, y):
    feature = {
        'x': tf.train.Feature(float_list=tf.train.FloatList(value=x.flatten())),
        'y': tf.train.Feature(int64_list=tf.train.Int64List(value=[y])),
    }
    return tf.train.Example(features=tf.train.Features(feature=feature)).SerializeToString()

with tf.io.TFRecordWriter('data.tfrecord') as w:
    for x, y in dataset:
        w.write(serialize(x, y))

def parse(serialized):
    feature = {'x': tf.io.FixedLenFeature([784], tf.float32),
               'y': tf.io.FixedLenFeature([], tf.int64)}
    parsed = tf.io.parse_single_example(serialized, feature)
    return parsed['x'], parsed['y']

ds = tf.data.TFRecordDataset('data.tfrecord').map(parse).batch(32)
10

저장과 로드

SavedModel 형식

SavedModel은 운영 등급 형식으로 아키텍처, 가중치, 추적된 그래프를 묶어 원본 Python 코드 없이 TF Serving, TFLite, TF.js, C++에서 로드할 수 있습니다. tf.keras.models.load_model로 Python에 다시 로드하세요. 서빙 시그니처를 명시하려면 input_signature를 넘기세요(TF Serving에 필요). SavedModel은 단일 파일이 아니라 디렉터리입니다.

tensorflow
import tensorflow as tf

model.save('saved_model')   # SavedModel directory
loaded = tf.keras.models.load_model('saved_model')
loaded.evaluate(x_test, y_test)

# export for serving (explicit signature)
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def serve(x):
    return {'outputs': model(x)}

tf.saved_model.save(model, 'serving_model', signatures=serve)

Keras 형식(.keras)

.keras 형식(Keras 3 기본)은 아키텍처 config, 가중치, 옵티마이저 상태를 담은 단일 압축 파일이라 공유와 버전 관리가 쉽습니다. .h5는 레거시 HDF5 형식으로 여전히 지원되지만 새 프로젝트에는 권장되지 않습니다. 배포(TFLite, TF Serving)에는 SavedModel(디렉터리)이 필요합니다. 커스텀 레이어는 .keras가 config를 저장해 다시 만들 수 있으므로 get_config()가 정확한지 확인하세요.

tensorflow
import tensorflow as tf

model.save('model.keras')   # Keras 3 default
loaded = tf.keras.models.load_model('model.keras')

# legacy HDF5 format
model.save('model.h5')
loaded = tf.keras.models.load_model('model.h5')

# .keras  — Keras 3 default, supports custom layers via config
# .h5     — legacy, weights + architecture but limited custom layer support
# SavedModel — directory, best for deployment/serving

가중치만 저장/로드

save_weights는 매개변수 텐서만 저장하므로 전체 모델보다 훨씬 작고 아키텍처와 분리됩니다. 로드 전에 같은 구조로 모델을 재구성해야 합니다. skip_mismatch=True(Keras 3)는 일치하는 레이어만 로드하므로 전이 학습에 유용합니다. 체크포인트 형식('ckpt' 접두사)은 checkpoint/weights-of-ckpt-1.index 파일을 만들며 fit 콜백이 내부적으로 쓰는 TF 네이티브 체크포인트 형식입니다.

tensorflow
import tensorflow as tf

model.save_weights('weights.keras')

model = build_model()   # must match the saved architecture
model.load_weights('weights.keras')

model.save_weights('weights.h5')
model.load_weights('weights.h5')

# load weights from one model into another (partial)
model.load_weights('weights.keras', skip_mismatch=True, by_name=True)

model.save_weights('ckpt')
model.load_weights('ckpt')

Checkpoint Manager

Checkpoint + CheckpointManager는 커스텀 학습 루프에서 저장을 완전히 제어합니다. 마지막 N개 체크포인트 유지, 최신 자동 복원, 스텝별 버전 관리가 가능합니다. expect_partial()은 복원되지 않은 슬롯(새 변수의 옵티마이저 모멘텀 등) 경고를 조용히 합니다. 체크포인트는 클래스 정의가 아니라 객체 그래프를 저장하므로 복원에 모델 코드가 필요합니다. CheckpointManager.max_to_keep=3은 오래된 체크포인트를 자동 삭제합니다.

tensorflow
import tensorflow as tf

ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer, step=optimizer.iterations)
manager = tf.train.CheckpointManager(
    ckpt, directory='./ckpts', max_to_keep=3,
    checkpoint_name='step-{step}',
)

manager.save()
ckpt.restore(manager.latest_checkpoint).expect_partial()

# in a custom loop: save every N steps
if step % 1000 == 0:
    manager.save()

커스텀 객체로 로드

커스텀 레이어, 손실, 지표를 쓰는 모델을 로드할 때 Keras는 재구성 방법을 알아야 합니다. 이름을 클래스/함수에 매핑한 custom_objects 딕셔너리를 넘기세요. 더 깔끔한 코드에는 클래스에 @register_keras_serializable을 붙여 전역 등록해 custom_objects가 필요 없게 하세요. get_config가 모든 생성자 인자를 반환해 객체를 정확히 재구성할 수 있게 하세요. Keras는 내부적으로 from_config(config)를 호출합니다.

tensorflow
import tensorflow as tf

class MyLayer(tf.keras.layers.Layer):
    ...

custom_objects = {'MyLayer': MyLayer, 'focal_loss': FocalLoss}

loaded = tf.keras.models.load_model(
    'model.keras', custom_objects=custom_objects,
)

# or register globally
@tf.keras.utils.register_keras_serializable(package='my_pkg')
class MyLayer(tf.keras.layers.Layer):
    ...

서빙용 내보내기

TF Serving은 버전 디렉터리(serving/1/, serving/2/)를 기대해 모델을 핫 스왑합니다. 서빙 시그니처는 클라이언트가 쓰는 입출력 텐서 이름과 모양을 정의합니다. model.export()(Keras 3)가 이를 자동으로 감쌉니다. 커스텀 전처리는 모델을 tf.Module로 감싸고 원시 입력(uint8 이미지 등)을 포함하는 input_signature와 최종 출력을 반환하는 __call__을 정의하세요. 클라이언트가 접근할 수 있도록 텐서에 이름을 붙이세요.

tensorflow
import tensorflow as tf

# Keras 3 export API (recommended)
model.export('serving/1')

class ServingModule(tf.Module):
    def __init__(self, model):
        self.model = model
    @tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32, name='inputs')])
    def __call__(self, x):
        return {'outputs': self.model(x)}

module = ServingModule(model)
tf.saved_model.save(module, 'serving/1',
                    signatures={'serving_default': module.__call__})

loaded = tf.saved_model.load('serving/1')
print(list(loaded.signatures.keys()))   # ['serving_default']
11

CNN

Conv2D와 풀링

Keras의 표준 CNN 블록: Conv2D -> BatchNormalization -> ReLU -> MaxPooling. padding='same'은 stride 1에서 공간 크기를 유지합니다. GlobalAveragePooling2D는 공간 차원을 벡터로 축약해 Flatten + Dense보다 매개변수 효율이 좋고 과적합이 적습니다. Keras는 기본적으로 NHWC(channels-last)를 쓰므로 Input 모양은 배치 차원 없는 (H, W, C)입니다. 스트라이드 합성곱은 학습 가능한 다운샘플링으로 풀링을 대체할 수 있습니다.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 28 -> 14
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 14 -> 7
    tf.keras.layers.Conv2D(128, 3, padding='same', activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),      # (7,7,128) -> (128,)
    tf.keras.layers.Dense(10, activation='softmax'),
])
model.summary()

CNN 구성하기

각 단계마다 필터를 두 배로(32 -> 64 -> 128) 늘리고 MaxPooling으로 공간 크기를 절반으로 줄이는 VGG 스타일 CNN. 단계당 합성곱 두 개(VGG 블록)가 하나보다 풍부한 특징을 추출합니다. 모델 내 Rescaling은 원시 uint8 이미지를 바로 받아 배포 가능하게 합니다. GlobalAveragePooling + Dropout이 헤드를 정규화합니다. 라벨이 정수 클래스 인덱스이므로 sparse_categorical_crossentropy로 컴파일하세요.

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(32, 32, 3))
x = tf.keras.layers.Rescaling(1./255)(inputs)

for filters in [32, 64, 128]:
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.MaxPooling2D()(x)
    x = tf.keras.layers.Dropout(0.25)(x)

x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

특징 맵과 시각화

같은 입력에 여러 출력(합성곱 레이어 활성화)을 가진 Model을 만들어 각 레이어가 무엇을 학습하는지 검사하세요. 초기 레이어는 가장자리/색을, 깊은 레이어는 질감/부분을 감지합니다. 디버깅에 매우 유용합니다. 죽은 특징 맵(모두 0)은 깨진 ReLU나 학습률 문제를 뜻합니다. Grad-CAM(클래스 활성화 맵)에는 tf-keras-vis를 쓰거나 기울기 가중 클래스 활성화를 구현해 예측을 이끈 영역을 확인하세요.

tensorflow
import tensorflow as tf
import matplotlib.pyplot as plt

feature_model = tf.keras.Model(
    inputs=model.inputs,
    outputs=[layer.output for layer in model.layers if 'conv2d' in layer.name],
)

img = x_test[0:1]
features = feature_model.predict(img)
print([f.shape for f in features])

fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
    if i < features[0].shape[-1]:
        ax.imshow(features[0][0, :, :, i], cmap='viridis')
    ax.axis('off')

사전 학습 CNN 백본

keras.applications는 ImageNet 가중치와 함께 ResNet, EfficientNet, MobileNet, ViT 등을 제공합니다. include_top=False는 1000 클래스 헤드를 제거해 자체 헤드를 붙이게 합니다. preprocess_input은 백본이 학습된 정확한 정규화를 적용하므로 배포를 위해 모델 안에서 호출하세요. 백본을 동결(trainable=False)하고 호출 시 training=False로 설정해 BatchNorm이 추론 통계를 쓰게 하세요. 작은 데이터셋의 전이 학습에 중요합니다.

tensorflow
import tensorflow as tf

backbone = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
backbone.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = backbone(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

잔차 연결

잔차(스킵) 연결은 블록의 입력을 출력에 더해 기울기가 이전 레이어로 직접 흐르게 하며, 이것이 매우 깊은 네트워크(ResNet) 학습을 가능하게 합니다. 숏컷은 출력의 채널과 공간 크기와 맞아야 하며 다를 때는 stride가 있는 1x1 합성곱으로 조정하세요. Add()가 두 경로를 병합합니다. 스킵 연결이 있는 아키텍처에는 Sequential이 아닌 Functional API를 사용하세요. ResNet-50은 이런 블록을 많이 쌓습니다.

tensorflow
import tensorflow as tf

def residual_block(x, filters, stride=1):
    shortcut = x
    x = tf.keras.layers.Conv2D(filters, 3, strides=stride, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.ReLU()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    if stride != 1 or shortcut.shape[-1] != filters:
        shortcut = tf.keras.layers.Conv2D(filters, 1, strides=stride, use_bias=False)(shortcut)
        shortcut = tf.keras.layers.BatchNormalization()(shortcut)
    x = tf.keras.layers.Add()([x, shortcut])
    return tf.keras.layers.ReLU()(x)

inputs = tf.keras.Input(shape=(32, 32, 3))
x = residual_block(inputs, 64)
x = residual_block(x, 128, stride=2)
model = tf.keras.Model(inputs, x)

탐지 헤드

탐지 헤드는 앵커별 또는 픽셀별 박스와 클래스 확률을 예측합니다. Functional API는 다중 출력 모델을 쉽게 만듭니다. 이름 있는 텐서 딕셔너리를 반환하세요. 실제 프로젝트에는 TensorFlow Object Detection API나 KerasCV(탐지, 분할)를 사용하세요. 앵커 매칭, NMS, 평가를 처리합니다. 완전한 탐지기를 처음부터 작성하는 것은 고급 연습입니다. 박스 인코딩, IoU 손실, focal 손실을 신중히 다루세요.

tensorflow
import tensorflow as tf

# YOLO-style detection head: conv to (grid * grid * (5 + num_classes))
def detection_head(x, num_classes, num_anchors=3):
    out = tf.keras.layers.Conv2D(
        num_anchors * (5 + num_classes), 1, activation='linear')(x)
    return out

# anchor-free alternative: predict (cx, cy, w, h, obj, class_logits)
def center_net_head(features, num_classes):
    cls = tf.keras.layers.Conv2D(num_classes, 1, activation='sigmoid', name='cls')(features)
    wh = tf.keras.layers.Conv2D(2, 1, name='wh')(features)
    offset = tf.keras.layers.Conv2D(2, 1, name='offset')(features)
    return {'cls': cls, 'wh': wh, 'offset': offset}
12

RNN과 LSTM

LSTM과 GRU 레이어

LSTM/GRU 입력 모양은 (batch, timesteps, features)입니다. return_sequences=False는 마지막 출력(분류용)을, True는 전체 시퀀스(스태킹이나 seq2seq용)를 반환합니다. Bidirectional은 순방향과 역방향 출력을 연결해 특징 크기를 두 배로 만듭니다. stateful=True는 배치 간 은닉 상태를 유지하므로 청크로 나눈 매우 긴 시퀀스에 유용하지만 고정 batch_size와 에포크 간 수동 상태 초기화가 필요합니다.

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(128, return_sequences=False)
x = tf.random.normal((4, 10, 64))
out = lstm(x)                       # (4, 128)

gru = tf.keras.layers.GRU(128)
out = gru(x)                        # (4, 128)

lstm = tf.keras.layers.LSTM(128, return_sequences=True)
out = lstm(x)                       # (4, 10, 128)

bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)                         # (4, 128) — 64*2

lstm = tf.keras.layers.LSTM(64, stateful=True)

RNN 스태킹

마지막 LSTM/GRU를 제외한 모든 레이어에 return_sequences=True를 설정해 RNN을 쌓으세요. Embedding 레이어의 mask_zero=True는 RNN이 존중하는 마스크를 생성해 패딩 위치를 건너뛰므로 가변 길이 시퀀스를 은닉 상태에 영향 없이 배치할 수 있습니다. RNN 레이어 사이 드롭아웃은 정규화를 주고 RNN 내부 recurrent_dropout은 느리므로(cuDNN 없음) 입력 드롭아웃을 권장합니다. 텍스트 분류에서 이 biLSTM은 강력한 기준선입니다.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 128, input_length=100, mask_zero=True),
    tf.keras.layers.LSTM(128, return_sequences=True),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

RNN 텍스트 분류

표준 텍스트 분류기: Embedding -> biLSTM -> biLSTM -> Dense -> sigmoid. mask_zero=True가 중요합니다. 없으면 LSTM이 패딩 토큰을 처리해 은닉 상태가 편향됩니다. Bidirectional은 시퀀스를 양방향으로 읽어 표현력을 두 배로 만듭니다. 이진 분류에는 sigmoid + binary_crossentropy를 사용하세요. 긴 시퀀스(500 토큰 초과)에서는 트랜스포머가 LSTM을 능가하지만 더 많은 데이터와 계산이 필요합니다.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(200,)),
    tf.keras.layers.Embedding(10000, 128, mask_zero=True),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64, return_sequences=True)),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(1, activation='sigmoid'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

인코더-디코더 Seq2Seq

seq2seq(번역, 요약)용 인코더-디코더 LSTM. 인코더의 최종 은닉 상태가 디코더를 초기화하고 디코더가 타깃 시퀀스를 토큰별로 생성합니다. teacher forcing으로 학습하세요. 이동된 타깃 시퀀스를 디코더 입력으로 넣습니다. 추론에는 각 예측 토큰을 다음 입력으로 되먹이는 별도 루프를 작성하세요. 어텐션(Bahdanau/Luong)은 seq2seq를 크게 개선하며 트랜스포머의 개념적 조상입니다.

tensorflow
import tensorflow as tf

encoder_input = tf.keras.Input(shape=(None,), name='enc_in')
enc_emb = tf.keras.layers.Embedding(vocab_src, 128)(encoder_input)
encoder = tf.keras.layers.LSTM(256, return_state=True)
enc_out, state_h, state_c = encoder(enc_emb)

decoder_input = tf.keras.Input(shape=(None,), name='dec_in')
dec_emb = tf.keras.layers.Embedding(vocab_tgt, 128)(decoder_input)
decoder_lstm = tf.keras.layers.LSTM(256, return_sequences=True, return_state=True)
dec_out, _, _ = decoder_lstm(dec_emb, initial_state=[state_h, state_c])
decoder_dense = tf.keras.layers.Dense(vocab_tgt, activation='softmax')
outputs = decoder_dense(dec_out)

model = tf.keras.Model([encoder_input, decoder_input], outputs)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

시계열 예측

시계열에는 윈도우 (입력, 타깃) 쌍을 만드세요. 각 윈도우의 마지막 값이 타깃이고 나머지가 입력입니다. window(shift=1)은 겹치는 윈도우를 만들고 drop_remainder는 크기를 같게 유지합니다. LSTM이 시간 패턴을 학습하고 마지막 Dense(1)이 다음 값을 예측합니다. 다단계 예측에는 지평 벡터를 예측하거나 seq2seq 아키텍처를 사용하세요. 항상 학습 통계만으로 시계열을 표준화하세요.

tensorflow
import tensorflow as tf

def make_dataset(series, window=20, batch=32):
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window + 1, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window + 1))
    ds = ds.map(lambda w: (w[:-1][..., tf.newaxis], w[-1:]))
    return ds.shuffle(1000).batch(batch).prefetch(tf.data.AUTOTUNE)

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(20, 1)),
    tf.keras.layers.LSTM(32, return_sequences=False),
    tf.keras.layers.Dense(1),
])
model.compile(optimizer='adam', loss='mse')
model.fit(make_dataset(train_series), epochs=10)

어텐션 메커니즘

어텐션은 디코더가 단일 고정 벡터에 의존하지 않고 관련 인코더 상태에 집중하게 하며 긴 시퀀스에서 큰 개선을 줍니다. Bahdanau(가산)와 Luong(승산)이 두 고전 변형입니다. Keras는 tf.keras.layers.AdditiveAttention과 Attention을 준비된 레이어로 제공합니다. 어텐션은 트랜스포머로 가는 개념적 다리입니다. 다중 헤드 셀프 어텐션은 같은 시퀀스에 어텐션을 적용한 것일 뿐입니다.

tensorflow
import tensorflow as tf

class BahdanauAttention(tf.keras.layers.Layer):
    def __init__(self, units):
        super().__init__()
        self.W1 = tf.keras.layers.Dense(units)
        self.W2 = tf.keras.layers.Dense(units)
        self.V = tf.keras.layers.Dense(1)
    def call(self, query, values):
        q = tf.expand_dims(query, 1)
        scores = self.V(tf.nn.tanh(self.W1(values) + self.W2(q)))
        attn = tf.nn.softmax(scores, axis=1)
        context = tf.reduce_sum(attn * values, axis=1)
        return context, attn

attn = tf.keras.layers.AdditiveAttention()
context = attn([query, value])
13

트랜스포머

MultiHeadAttention

MultiHeadAttention은 트랜스포머의 핵심 레이어로 q/k/v를 여러 헤드로 투영하고 병렬로 어텐션한 뒤 재결합합니다. 셀프 어텐션에는 같은 텐서를 query, key, value로 넘기세요. attention_mask는 디코딩용 인과 마스크(하삼각)나 패딩 마스크(True = 무시)가 될 수 있습니다. return_attention_scores=True는 시각화용 어텐션 행렬을 반환합니다. 출력 차원이 입력 차원과 같아 블록을 쌓을 수 있습니다.

tensorflow
import tensorflow as tf

mha = tf.keras.layers.MultiHeadAttention(
    num_heads=8, key_dim=64, dropout=0.1, use_bias=True)

x = tf.random.normal((4, 10, 512))
out, attn_weights = mha(query=x, value=x, key=x,
                        return_attention_scores=True)
print(out.shape)          # (4, 10, 512)
print(attn_weights.shape) # (4, 8, 10, 10)

# causal mask (decoder self-attention)
mask = tf.linalg.band_part(tf.ones((10, 10)), -1, 0)
out = mha(query=x, value=x, key=x, attention_mask=mask)

# key padding mask (ignore pad positions)
padding = tf.cast(tokens == 0, tf.bool)[:, tf.newaxis, tf.newaxis, :]
out = mha(query=x, value=x, key=x, attention_mask=padding)

트랜스포머 인코더 블록

트랜스포머 인코더 블록은 다중 헤드 셀프 어텐션 + add & norm + 피드포워드(MLP) + add & norm입니다. Pre-LN(서브레이어 앞 정규화)은 처음부터 학습할 때 더 안정적이고 post-LN은 워밍업이 필요합니다. FFN은 GELU를 쓰는 2층 MLP로 'ff' 은닉 유닛으로 확장했다가 'dim'으로 돌아옵니다. 이를 N개 쌓으면 완전한 인코더입니다. LayerNorm의 epsilon=1e-6은 작은 분산에서 0 나눗셈을 막습니다.

tensorflow
import tensorflow as tf

class TransformerBlock(tf.keras.layers.Layer):
    def __init__(self, dim=512, heads=8, ff=2048, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.att = tf.keras.layers.MultiHeadAttention(num_heads=heads, key_dim=dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop1 = tf.keras.layers.Dropout(dropout)
        self.drop2 = tf.keras.layers.Dropout(dropout)

    def call(self, x, training=False, mask=None):
        attn = self.att(x, x, x, attention_mask=mask)
        x = self.norm1(x + self.drop1(attn, training=training))
        ffn = self.ffn(x)
        return self.norm2(x + self.drop2(ffn, training=training))

위치 인코딩

트랜스포머는 순열 불변이라 토큰 순서를 알려면 위치 정보가 필요합니다. 사인 곡선 인코딩은 위치와 차원에 기반한 고정 패턴을 더하며 학습 때보다 긴 시퀀스에도 일반화됩니다. 임베딩 출력에 위치 인코딩을 더하세요. 또는 학습된 위치 임베딩(위치로 인덱싱하는 Embedding 레이어)이나 상대 위치 인코딩(T5 같은 최신 트랜스포머에서 사용)을 쓸 수 있습니다. 이미지(ViT)에는 패치마다 학습 가능한 위치 임베딩을 더하세요.

tensorflow
import tensorflow as tf
import numpy as np

class PositionalEncoding(tf.keras.layers.Layer):
    def __init__(self, max_len=5000, dim=512, **kwargs):
        super().__init__(**kwargs)
        pos = np.arange(max_len)[:, np.newaxis]
        i = np.arange(dim)[np.newaxis, :]
        angle = pos / np.power(10000, (2 * (i // 2)) / np.float32(dim))
        angle[:, 0::2] = np.sin(angle[:, 0::2])
        angle[:, 1::2] = np.cos(angle[:, 1::2])
        self.pos = tf.constant(angle[np.newaxis, ...], dtype=tf.float32)

    def call(self, x):
        return x + self.pos[:, :tf.shape(x)[1], :]

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 512),
    PositionalEncoding(max_len=200, dim=512),
    tf.keras.layers.Dropout(0.1),
])

텍스트 분류 트랜스포머

처음부터 만드는 트랜스포머 텍스트 분류기: 임베딩 + 위치 인코딩 + N개 인코더 블록 + 전역 평균 풀 + Dense 헤드. GlobalAveragePooling1D는 시퀀스 차원을 축약합니다(학습 가능한 집계에는 CLS 토큰 사용). mask_zero=True는 MultiHeadAttention이 존중하는 마스크를 전파하며 필요하면 수동으로 전달하세요. 실제 NLP에는 HuggingFace의 사전 학습 트랜스포머(BERT, T5)를 사용하세요. 처음부터 학습하려면 막대한 데이터가 필요합니다.

tensorflow
import tensorflow as tf

class TransformerEncoder(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, num_layers, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.blocks = [TransformerBlock(dim, heads, ff, dropout)
                       for _ in range(num_layers)]
    def call(self, x, training=False, mask=None):
        for block in self.blocks:
            x = block(x, training=training, mask=mask)
        return x

inputs = tf.keras.Input(shape=(200,))
x = tf.keras.layers.Embedding(10000, 128, mask_zero=True)(inputs)
x = PositionalEncoding(200, 128)(x)
x = TransformerEncoder(128, 4, 512, 4)(x)
x = tf.keras.layers.GlobalAveragePooling1D()(x)
x = tf.keras.layers.Dropout(0.3)(x)
outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model(inputs, outputs)

비전 트랜스포머(ViT)

비전 트랜스포머는 스트라이드 Conv2d(kernel=stride=patch_size)로 이미지를 패치화하고 패치를 토큰으로 취급하며 CLS 토큰을 앞에 붙이고 위치 임베딩을 더한 뒤 트랜스포머 인코더 블록을 실행합니다. CLS 토큰의 최종 은닉 상태가 분류용 전역 이미지 표현입니다. 실제 사용에는 keras.applications나 HuggingFace의 사전 학습 ViT를 로드하세요. 잘 동작하려면 ImageNet-21k 사전 학습이 필요합니다. 패치 크기 16과 dim 768이 ViT-Base 기본값입니다.

tensorflow
import tensorflow as tf

class ViTPatchEmbed(tf.keras.layers.Layer):
    def __init__(self, patch_size=16, dim=768, **kwargs):
        super().__init__(**kwargs)
        self.proj = tf.keras.layers.Conv2D(dim, patch_size, strides=patch_size)
    def call(self, x):
        x = self.proj(x)
        shape = tf.shape(x)
        x = tf.reshape(x, [shape[0], -1, x.shape[-1]])
        return x

inputs = tf.keras.Input(shape=(224, 224, 3))
x = ViTPatchEmbed(16, 768)(inputs)
x = x + tf.Variable(tf.random.normal((1, 196, 768)))
cls = tf.Variable(tf.random.normal((1, 1, 768)))
x = tf.keras.layers.Concatenate(axis=1)([cls, x])
for _ in range(6):
    x = TransformerBlock(768, 12, 3072, 0.1)(x)
x = tf.keras.layers.Lambda(lambda t: t[:, 0])(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

트랜스포머 디코더

디코더 블록에는 세 서브레이어가 있습니다: 마스킹된 셀프 어텐션(위치 t가 미래를 볼 수 없게 하는 인과 마스크), 교차 어텐션(디코더의 query, 인코더 출력의 key/value), FFN. 각 서브레이어에는 잔차 + LayerNorm이 있습니다. 교차 어텐션이 디코더가 소스 시퀀스를 '되돌아보게' 합니다. 디코더 전용 모델(GPT)은 교차 어텐션 서브레이어를 제거하세요. N개 블록을 쌓으면 완전한 디코더입니다. 추론에는 예측 토큰을 되먹이는 자기회귀 루프가 필요합니다.

tensorflow
import tensorflow as tf

class DecoderBlock(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.self_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.cross_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = self.norm2 = self.norm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop = tf.keras.layers.Dropout(dropout)

    def call(self, x, enc_out, training=False, causal_mask=None, padding_mask=None):
        attn = self.self_att(x, x, x, attention_mask=causal_mask)
        x = self.norm1(x + self.drop(attn, training=training))
        cross = self.cross_att(query=x, value=enc_out, key=enc_out, attention_mask=padding_mask)
        x = self.norm2(x + self.drop(cross, training=training))
        x = self.norm3(x + self.drop(self.ffn(x), training=training))
        return x
14

TensorBoard

설정과 콜백

TensorBoard 콜백은 fit 중 지표, 그래프, 프로파일링 데이터를 log_dir로 스트리밍합니다. histogram_freq=1은 에포크별 가중치 분포를 기록하고 0이면 공간을 절약합니다. profile_batch=2는 해당 배치에서 TF Profiler를 실행해 병목(입력 파이프라인, 연산 지연, 메모리)을 찾습니다. 실험마다 별도 하위 디렉터리(logs/exp1, logs/exp2)를 써서 TensorBoard가 겹쳐 보여주게 하세요. 하이퍼파라미터 스윕에 완벽합니다. `tensorboard --logdir=logs`로 실행하세요.

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/experiment_1', histogram_freq=1,
    write_graph=True, profile_batch=2,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])

# launch tensorboard
# tensorboard --logdir=logs

import datetime
log_dir = 'logs/fit/' + datetime.datetime.now().strftime('%Y%m%d-%H%M%S')

커스텀 스칼라(Summary Writer)

tf.summary.create_file_writer는 커스텀 학습 루프에서 커스텀 스칼라를 로깅하는 저수준 핸들을 줍니다. writer.as_default()와 tf.summary.scalar(name, value, step=step)로 기록하세요. step은 정수(보통 옵티마이저의 반복 카운터)여야 합니다. 이벤트가 디스크에 도달하도록 주기적으로 flush하세요. 네임스페이스(train/loss, val/loss)로 TensorBoard UI의 차트를 정리하세요. LR, 기울기 노름, 관심 있는 커스텀 지표를 로깅하세요.

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/custom')

with writer.as_default():
    tf.summary.scalar('train/loss', loss, step=step)
    tf.summary.scalar('train/lr', lr, step=step)
    tf.summary.scalar('val/accuracy', acc, step=step)
    tf.summary.text('config', 'lr=1e-3, batch=32', step=0)
    writer.flush()

# in a custom training loop
for step, (x, y) in enumerate(train_ds):
    # ... train step ...
    if step % 100 == 0:
        with writer.as_default():
            tf.summary.scalar('loss', loss, step=step)

이미지와 히스토그램

tf.summary.image는 시각적 QA용 이미지를 로깅합니다. (B, H, W, C) 모양을 넘기고 B는 max_outputs까지 가능합니다. 히스토그램은 시간에 따른 가중치와 기울기 분포를 보여주며 갑작스러운 급증은 불안정을 암시합니다. 스칼라 지표뿐 아니라 질적 진행을 보려면 에포크마다 검증 샘플 몇 개를 로깅하세요. 오디오는 음성 모델에 유용합니다. 모든 summary는 TensorBoard의 x축이 되는 step 인자를 받습니다. N스텝마다 샘플링해 로깅을 저렴하게 유지하세요.

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/viz')

with writer.as_default():
    tf.summary.image('sample', img[None, ...], step=step)
    tf.summary.image('batch', images[:8], step=step, max_outputs=8)
    for var in model.trainable_variables:
        tf.summary.histogram('weights/' + var.name, var, step=step)
    tf.summary.audio('waveform', audio[None, ...], sample_rate=16000, step=step)
    writer.flush()

하이퍼파라미터 튜닝

HParams 플러그인은 TensorBoard에서 하이퍼파라미터 스윕을 정리합니다. 표 뷰에서 실행을 필터링하고 최적 구성을 찾을 수 있습니다. 범위/이산 값을 가진 HParam 객체를 정의하고 hp.hparams_config로 구성을 한 번 로깅한 뒤 실행마다 hp.hparams(hparams)와 최종 지표를 로깅하세요. 본격적인 스윕에는 KerasTuner(RandomSearch, Hyperband, BayesianOptimization)를 사용하세요. 검색을 자동화하고 TensorBoard와 통합됩니다.

tensorflow
import tensorflow as tf
# from tensorboard.plugins.hparams import api as hp
# (run: pip install tensorboard-plugin-hparams)

HP_LR = hp.HParam('lr', hp.RealInterval(1e-4, 1e-2))
HP_DROPOUT = hp.HParam('dropout', hp.Discrete([0.1, 0.3, 0.5]))
METRIC_ACC = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
    hp.hparams_config(hparams=[HP_LR, HP_DROPOUT], metrics=[hp.Metric(METRIC_ACC)])

for lr in [1e-3, 5e-3]:
    for dropout in [0.1, 0.3]:
        hparams = {HP_LR: lr, HP_DROPOUT: dropout}
        run_name = f"lr-{lr}-drop-{dropout}"
        with tf.summary.create_file_writer('logs/hparam_tuning/' + run_name).as_default():
            hp.hparams(hparams)
            acc = train(hparams)
            tf.summary.scalar(METRIC_ACC, acc, step=1)

성능 프로파일링

TF Profiler는 시간이 어디에 쓰이는지 보여줍니다. 연산별, 장치별, 입력 파이프라인별입니다. profile_batch='10,20'은 배치 10-20을 프로파일링합니다(워밍업이 끝나도록 처음 몇 개는 건너뜀). Overview 페이지는 실행 가능한 권장 사항(예: '입력 파이프라인이 병목')을 줍니다. Memory Viewer는 최대 메모리와 지배적인 텐서를 보여줍니다. Trace Viewer는 깊은 분석용 Chrome 스타일 타임라인입니다. 항상 대상 하드웨어에서 프로파일링하세요. CPU와 GPU 병목은 다릅니다.

tensorflow
import tensorflow as tf

# profile via callback
tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/profile', profile_batch='10,20',
)

# or use the Profiler API directly
tf.profiler.experimental.start('logs/profile')
# ... run a few batches ...
tf.profiler.experimental.stop()

# in TensorBoard, open the Profile tab to see:
# - op-level time breakdown
# - input pipeline analysis (tf.data bottleneck)
# - memory viewer
# - overview page with recommendations
15

GPU / TPU 학습

GPU 감지와 메모리

기본적으로 TF는 시작 시 모든 GPU 메모리를 잡아 다른 프로세스를 막습니다. set_memory_growth(True)는 필요한 만큼만 할당하므로 GPU 공유에 필수입니다. set_logical_device_configuration은 메모리를 제한하거나 GPU 하나를 여러 논리 장치로 분할합니다(한 GPU에서 다중 GPU 코드 테스트에 유용). tf.device('/GPU:1')은 연산을 특정 장치에 배치합니다. CPU 연산은 '/CPU:0'에서 실행됩니다. 장치 배치가 맞지 않으면 성능을 해치는 암시적 복사가 생깁니다.

tensorflow
import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
print('GPUs:', gpus)

# set memory growth (don't grab all GPU memory at start)
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

# or limit GPU memory explicitly
tf.config.set_logical_device_configuration(
    gpus[0],
    [tf.config.LogicalDeviceConfiguration(memory_limit=4096)],
)

with tf.device('/GPU:1'):
    x = tf.random.normal((1000, 1000))
    y = tf.matmul(x, x)

분산 전략

분산 전략은 장치 토폴로지를 추상화합니다. MirroredStrategy는 단일 머신 다중 GPU용으로 변수를 GPU에 미러링하고 기울기를 all-reduce합니다. 가장 쉬운 다중 GPU 경로입니다. MultiWorkerMirroredStrategy는 여러 머신으로 확장합니다. TPUStrategy는 Google TPU(Colab/Cloud)에서 실행합니다. 변수가 올바르게 미러링되도록 항상 strategy.scope() 안에서 모델을 만드세요. 같은 fit/predict 코드가 전략 전반에서 동작합니다.

tensorflow
import tensorflow as tf

strategy = tf.distribute.OneDeviceStrategy(device='/gpu:0')
strategy = tf.distribute.MirroredStrategy()
print('num replicas:', strategy.num_replicas_in_sync)

# TPU
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='...', metrics=['accuracy'])

model.fit(train_ds, epochs=10)

다중 GPU 학습

MirroredStrategy는 모델 변수를 각 GPU에 미러링하고 각 배치를 레플리카에 나눕니다. 유효 배치 크기는 global_batch입니다(예: GPU당 64 * GPU 4개 = 256). 데이터셋에 전역 배치를 넘기면 TF가 샤드를 자동 분배합니다. fit()이 내부에서 기울기 all-reduce를 처리합니다. 커스텀 학습 루프에는 strategy.experimental_distribute_dataset과 strategy.run(train_step)을 사용하세요.

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()
print(f'using {strategy.num_replicas_in_sync} GPUs')

global_batch = 64 * strategy.num_replicas_in_sync
train_ds = make_dataset().batch(global_batch)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

model.fit(train_ds, epochs=10, validation_data=val_ds)

TPU 학습(Colab)

TPU는 Google Colab(런타임 유형 변경 -> TPU)과 Google Cloud에서 사용할 수 있습니다. TPU 시스템을 한 번 초기화한 뒤 모델 생성을 strategy.scope()로 감싸세요. TPU는 큰 배치 크기(1024+)와 고정 모양에서 가장 빠르므로 배치에 drop_remainder=True를 사용하세요. TPU는 로컬 파일을 직접 읽지 못하므로 데이터를 메모리에 로드하거나 tf.data로 GCS에서 스트리밍하세요. 혼합 정밀도(bfloat16)는 TPU에서 큰 속도 향상을 주며 손실 스케일링이 필요 없습니다.

tensorflow
import tensorflow as tf

try:
    resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
    tf.config.experimental_connect_to_cluster(resolver)
    tf.tpu.experimental.initialize_tpu_system(resolver)
    strategy = tf.distribute.TPUStrategy(resolver)
    print('TPUs:', strategy.num_replicas_in_sync)
except ValueError:
    print('No TPU found')
    strategy = tf.distribute.get_strategy()

with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

model.fit(x_train, y_train, batch_size=1024, epochs=5)

혼합 정밀도

혼합 정밀도는 float16으로 계산하되 float32 마스터 복사본을 유지해 Tensor Core GPU(Volta+)에서 2-3배 처리량과 절반 메모리를 얻습니다. 'mixed_float16'은 손실 스케일링이 필요하며 Keras가 LossScaleOptimizer로 자동 처리합니다. 'mixed_bfloat16'은 float32와 같은 범위라 스케일링이 필요 없지만 Ampere+ GPU와 TPU만 지원합니다. 수치 안정성을 위해 최종 레이어를 float32(softmax/로짓)로 강제하세요. 혼합 정밀도는 가장 쉬운 단일 성능 향상입니다.

tensorflow
import tensorflow as tf

tf.keras.mixed_precision.set_global_policy('mixed_float16')
# or bfloat16 on Ampere+ / TPU (no loss scaling needed)
tf.keras.mixed_precision.set_global_policy('mixed_bfloat16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(512, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, dtype='float32'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
print(model.layers[0].dtype_policy)   # <Policy "mixed_float16">
16

데이터 증강

Keras 전처리 레이어

Keras 전처리 레이어(RandomFlip, RandomRotation 등)는 GPU와 tf.function 안에서 실행되어 PIL/numpy 증강보다 훨씬 빠릅니다. 모델 안에 넣으면 추론 시(training=False) 자동 비활성화됩니다. 또는 더 제어하려면 tf.data map에서 적용하세요. 이 레이어들은 상태가 없고 JIT 컴파일되어 추론을 느리게 하지 않습니다. 상태 있는 전처리(적합된 스케일러 등)에는 Adapt API를 사용하세요.

tensorflow
import tensorflow as tf

augment = tf.keras.Sequential([
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.RandomZoom(0.1),
    tf.keras.layers.RandomContrast(0.2),
    tf.keras.layers.RandomTranslation(0.1, 0.1),
])

# put augmentation INSIDE the model (training-only, inactive at inference)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    augment,
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
])

# or apply via dataset.map
ds = ds.map(lambda x, y: (augment(x, training=True), y))

ImageDataGenerator(레거시)

ImageDataGenerator는 레거시 증강 API입니다. 동작하지만 CPU에서 실행되어 Keras 전처리 레이어보다 느립니다. 디렉터리 반복 편의나 레거시 코드가 필요할 때만 사용하세요. 새 프로젝트에는 keras.utils.image_dataset_from_directory + Keras 전처리 레이어(RandomFlip 등)를 권장합니다. GPU 가속되고 tf.data와 통합됩니다. flow_from_directory는 ImageFolder처럼 하위 디렉터리 이름에서 클래스 라벨을 추론합니다.

tensorflow
from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(
    rescale=1./255, rotation_range=20,
    width_shift_range=0.2, height_shift_range=0.2,
    shear_range=0.2, zoom_range=0.2,
    horizontal_flip=True, fill_mode='nearest',
    validation_split=0.2,
)

train_gen = train_datagen.flow_from_directory(
    'data/train', target_size=(224, 224), batch_size=32,
    class_mode='binary', subset='training',
)

model.fit(train_gen, epochs=10)

이미지 증강 연산

tf.image.* 연산은 커스텀 증강에 세밀한 제어를 줍니다. random_brightness/contrast/saturation/hue는 기하 변환 없이 색을 바꿉니다. Cutout과 Mixup은 정규화를 개선하는 고급 증강이며 tf.image 연산 + tf.tensor_scatter_nd_update로 구현하세요. num_parallel_calls=AUTOTUNE가 있는 tf.data map에서 증강을 적용해 CPU 워커에서 실행되고 GPU를 막지 않게 하세요. 색 지터 후에는 항상 유효한 픽셀 범위로 클립하세요.

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.2)
    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)
    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)
    image = tf.image.random_hue(image, max_delta=0.1)
    image = tf.clip_by_value(image, 0.0, 1.0)
    return image, label

ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

Mixup과 CutMix

Mixup은 두 이미지와 라벨을 선형 혼합해 클래스 사이의 가상 예제를 만들며 과적합을 줄이고 보정을 개선하는 강력한 정규화입니다. CutMix는 한 이미지의 사각 패치를 다른 이미지에 붙여 Mixup보다 지역 구조를 잘 보존합니다. 둘 다 손실이 소프트(혼합) 라벨을 받아야 하므로 sparse가 아닌 categorical_crossentropy를 사용하세요. 배치 후 배치별로 적용하세요. 최상의 결과를 위해 표준 기하 증강과 결합하세요.

tensorflow
import tensorflow as tf

def mixup(images, labels, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    batch_size = tf.shape(images)[0]
    idx = tf.random.shuffle(tf.range(batch_size))
    mixed_images = lam * images + (1 - lam) * tf.gather(images, idx)
    mixed_labels = lam * labels + (1 - lam) * tf.gather(labels, idx)
    return mixed_images, mixed_labels

ds = ds.batch(32).map(mixup, num_parallel_calls=tf.data.AUTOTUNE)

텍스트 및 표 데이터 증강

텍스트에는 간단한 단어 수준 증강(동의어 교체, 무작위 삭제/교환)이 저렴하고 효과적입니다. 본격적인 NLP에는 역번역이나 EDA/AugBERT 같은 모델을 사용하세요. 표 데이터에는 mixup이 행을 혼합하고 수치 특징의 가우시안 노이즈가 정규화를 줍니다. 증강은 항상 학습 데이터에만 적용하고 검증/테스트에는 절대 적용하지 마세요. 라벨을 보존(또는 mixup처럼 라벨 혼합)하세요. 라벨을 훼손하면 도움이 되기보다 해롭습니다.

tensorflow
import tensorflow as tf
import random

def text_augment(text):
    words = text.split()
    if random.random() < 0.2:
        words = [w for w in words if random.random() > 0.2]
    if len(words) > 1 and random.random() < 0.2:
        i, j = random.sample(range(len(words)), 2)
        words[i], words[j] = words[j], words[i]
    return ' '.join(words)

def tabular_mixup(x, y, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    idx = tf.random.shuffle(tf.range(tf.shape(x)[0]))
    return lam * x + (1 - lam) * tf.gather(x, idx), lam * y + (1 - lam) * tf.gather(y, idx)

def add_noise(x, std=0.01):
    return x + tf.random.normal(tf.shape(x), stddev=std)
17

전이 학습

사전 학습 모델

keras.applications는 ImageNet 가중치와 함께 ResNet, EfficientNet, MobileNet, ViT 등을 제공합니다. include_top=False는 1000 클래스 헤드를 제거해 자체 헤드를 붙이게 합니다. preprocess_input은 백본이 기대하는 정확한 정규화를 적용하므로 배포를 위해 모델 안에서 호출하세요. 백본을 동결(trainable=False)하고 base(x, training=False)로 호출해 BatchNorm이 추론 통계를 쓰게 하세요. BN 통계가 시끄러울 수 있는 작은 데이터셋에 중요합니다.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = base(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

특징 추출

특징 추출은 전체 백본을 동결하고 새 헤드만 학습하는 가장 빠른 전이 학습 기준선입니다. 백본이 고정되므로 특징을 한 번 미리 계산(base.predict(train_ds))한 뒤 작은 분류기를 학습해 막대한 계산을 절약할 수 있습니다. 백본 호출 시 training=False로 설정해 BatchNorm이 실행 통계를 쓰게 하세요. 그렇지 않으면 작은 배치가 통계를 망칩니다. 미세 조정이 과적합될 작은 데이터셋(수백 이미지)에 좋습니다.

tensorflow
import tensorflow as tf

base = tf.keras.applications.MobileNetV2(
    include_top=False, weights='imagenet', pooling='avg')
base.trainable = False

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.applications.mobilenet_v2.preprocess_input,
    base,
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(num_classes, activation='softmax'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

미세 조정

미세 조정은 일부 백본 레이어를 해제하고 작은 LR로 학습해 사전 학습 특징이 작업에 적응하게 합니다. 항상 특징 추출(헤드만)을 몇 에포크 먼저 한 뒤 해제하세요. 그렇지 않으면 무작위 헤드의 큰 기울기가 사전 학습 특징을 망칩니다. 훨씬 작은 LR(헤드 1e-3 대비 1e-5)을 사용하세요. 위에서 아래로 해제하세요(뒤 레이어가 더 작업 특화, 앞 레이어는 일반적). BatchNorm 레이어는 실행 통계를 보존하도록 동결 유지하세요.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet', pooling='avg')
base.trainable = True

# freeze everything except the last few blocks
for layer in base.layers[:-20]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-5),   # 10x smaller than head
    loss='sparse_categorical_crossentropy', metrics=['accuracy'],
)
model.fit(train_ds, validation_data=val_ds, epochs=5)

동결과 해제

layer.trainable=False로 동결합니다. trainable 변경 후에는 옵티마이저가 새 학습 대상 집합을 인식하도록 모델을 반드시 다시 컴파일하세요. 미세 조정 중 BatchNorm 레이어는 동결 유지하세요. 실행 통계가 소중하고 작은 미세 조정 배치가 이를 망칠 수 있습니다. trainable_weights와 weights를 검사해 무엇이 갱신될지 확인하세요. 학습 가능한 매개변수 수를 로깅해 실수로 전부 동결하거나 해제하는 흔한 조용한 버그를 피하세요.

tensorflow
import tensorflow as tf

base = tf.keras.applications.EfficientNetB0(
    include_top=False, weights='imagenet', pooling='avg')

base.trainable = False
for layer in base.layers:
    layer.trainable = 'block7' in layer.name

# freeze BatchNorm specifically (recommended during fine-tuning)
for layer in base.layers:
    if isinstance(layer, tf.keras.layers.BatchNormalization):
        layer.trainable = False

n_train = sum(tf.keras.backend.count_params(w) for w in model.trainable_weights)
n_total = sum(tf.keras.backend.count_params(w) for w in model.weights)
print(f"trainable: {n_train:,} / {n_total:,}")

멀티태스크 전이

멀티태스크 학습은 관련 작업 간에 백본을 공유해 표현을 정규화하고 계산을 절약합니다. 각 헤드는 공유 특징에서 나온 작은 분기입니다. compile에서 출력별 손실과 loss_weights를 넘겨 작업 기울기의 균형을 맞추세요(한 작업이 지배하지 않게 조정). fit 시 출력 이름과 일치하는 딕셔너리로 타깃을 넘기세요. 데이터가 많은 작업과 적은 작업이 있을 때 강력하며 공유 백본이 둘 다에 도움이 됩니다.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet')
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
features = base(x, training=False)
features = tf.keras.layers.GlobalAveragePooling2D()(features)

cls_out = tf.keras.layers.Dense(num_classes, activation='softmax', name='cls')(features)
box_out = tf.keras.layers.Dense(4, name='box')(features)
attr_out = tf.keras.layers.Dense(num_attr, activation='sigmoid', name='attr')(features)

model = tf.keras.Model(inputs, [cls_out, box_out, attr_out])
model.compile(
    optimizer='adam',
    loss={'cls': 'sparse_categorical_crossentropy', 'box': 'mse',
          'attr': 'binary_crossentropy'},
    loss_weights={'cls': 1.0, 'box': 5.0, 'attr': 0.5},
)
18

모델 배포

TFLite 변환기

TFLite는 TF 모델을 모바일, 임베디드, 엣지 장치용 플랫바퍼 형식으로 변환합니다. Optimize.DEFAULT는 학습 후 양자화를 자동 적용하고 완전 int8 양자화는 활성화 범위 보정을 위한 대표 데이터셋이 필요하며 Edge TPU/마이크로컨트롤러에서 실행되는 모델을 만듭니다. float16은 GPU 호환성을 유지하고 int8이 정확도를 해칠 때 더 안전합니다. 변환기는 모델에서 입력 모양을 추론하며 동적 모양은 구체 함수로 고정하세요.

tensorflow
import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

# with quantization (8-bit, ~4x smaller, faster on CPU)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# float16 quantization (GPU-friendly, 2x smaller)
converter.target_spec.supported_types = [tf.float16]
# full integer quantization (needs representative dataset)
converter.representative_dataset = rep_data
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
tflite_quant = converter.convert()

TFLite 인터프리터

TFLite 인터프리터는 .tflite 모델을 CPU, GPU, Edge TPU, 마이크로컨트롤러에서 실행합니다. allocate_tensors는 고정 입력 모양에 따라 메모리를 준비하며 동적 모양에는 resize_tensor_input으로 크기를 조정하세요. set_tensor / invoke / get_tensor가 추론 루프입니다. 배치 추론에는 모델을 고정 배치 크기로 변환하거나 resize_tensor_input을 사용하세요. TFLite는 Python, C++, Java, Swift, JavaScript 바인딩이 있어 같은 .tflite 파일이 어디서나 실행됩니다.

tensorflow
import tensorflow as tf
import numpy as np

interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print(input_details)
# [{'name': 'input', 'shape': (1, 224, 224, 3), 'dtype': tf.float32, ...}]

input_data = np.expand_dims(img, axis=0).astype(np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])
print(output.shape, output.argmax())

TF Serving

TF Serving은 SavedModel을 버전 관리, 배치, GPU 지원과 함께 gRPC/REST API 뒤에 호스팅합니다. serving/1/, serving/2/ 디렉터리 구조가 핫 모델 스왑을 가능하게 합니다. Docker 이미지가 가장 쉬운 로컬 배포이며 운영에는 Vertex AI, SageMaker, KServe를 사용하세요. TF Serving은 GPU 활용을 극대화하도록 요청을 자동 배치합니다. REST API는 입력에 {instances: [...]}를 쓰고 {predictions: [...]}를 반환하며 이름 있는 입출력에는 signature_name 매개변수를 사용하세요.

tensorflow
# save model in SavedModel format with versioning
# model.export('serving/1')  # Keras 3
tf.saved_model.save(model, 'serving/1')

# run TF Serving via Docker
# docker run -p 8501:8501 --name tfserving \
#   -v $(pwd)/serving:/models/my_model \
#   -e MODEL_NAME=my_model \
#   tensorflow/serving

# query via REST
import json, requests
data = json.dumps({'instances': x_test[:3].tolist()})
resp = requests.post(
    'http://localhost:8501/v1/models/my_model:predict',
    data=data, headers={'content-type': 'application/json'})
print(resp.json()['predictions'])

양자화 인식 학습

양자화 인식 학습(QAT)은 학습 중 가짜 양자화 연산을 삽입해 모델이 int8 추론의 반올림 노이즈에 적응하게 하며 보통 학습 후 양자화로 잃은 정확도를 대부분 회복합니다. tfmot(tensorflow-model-optimization)로 학습된 모델을 감싸고 몇 에포크 미세 조정한 뒤 TFLite로 변환하세요. int8 학습 후 양자화가 정확도를 임계값 아래로 떨어뜨릴 때(EfficientNet, 객체 탐지기 등) QAT가 필수입니다. 결과 TFLite 모델은 Edge TPU에서 실행됩니다.

tensorflow
import tensorflow as tf
# (requires: pip install tensorflow-model-optimization)
import tensorflow_model_optimization as tfmot

model = tf.keras.applications.MobileNetV2(weights='imagenet')
annot_model = tfmot.quantization.keras.quantize_model(model)
annot_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
annot_model.fit(train_ds, epochs=3)

converter = tf.lite.TFLiteConverter.from_keras_model(annot_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_qat = converter.convert()

TF.js와 엣지 배포

TF.js는 브라우저나 Node.js에서 모델을 실행합니다. 변환기는 SavedModel/.keras/.h5를 model.json + 바이너리 가중치 디렉터리로 바꿉니다. Layers 모델은 Keras API(fit, predict, 심지어 즉석 학습)를 지원하고 graph 모델은 호환성이 높지만 유연성이 낮습니다. 브라우저 추론은 WebGL/WASM을, Node.js는 CUDA를 사용할 수 있습니다. TF.js는 클라이언트 측 ML(서버 왕복 없음, 프라이버시, 오프라인)에 좋습니다. 모바일에는 더 작고 빠르며 하드웨어 가속되는 TFLite를 권장하세요.

tensorflow
# convert to TF.js format
# pip install tensorflowjs
# tensorflowjs_converter --input_format=keras model.keras tfjs_model/

# in JavaScript:
# import * as tf from '@tensorflow/tfjs';
# const model = await tf.loadLayersModel('tfjs_model/model.json');
# const out = model.predict(tf.tensor4d(img, [1, 224, 224, 3]));

# OR convert SavedModel -> TF.js
# tensorflowjs_converter \
#   --input_format=tf_saved_model \
#   --output_format=tfjs_graph_model \
#   saved_model/ tfjs_model/

# TF.js layers model: full Keras-like API in the browser
# TF.js graph model: lower-level, supports more ops

추론 최적화

저지연 배포에는 최적화를 쌓으세요: 프루닝(작은 가중치를 0으로 만들고 압축), 지식 증류(작은 학생이 큰 교사의 로짓을 모방하도록 학습), 양자화(int8/float16), XLA 컴파일(연산 융합). 각 단계에는 트레이드오프가 있으므로 항상 대상 하드웨어에서 벤치마크하세요. 증류는 보통 정확도를 가장 잘 보존하고 프루닝+양자화는 크기를 가장 크게 줄입니다. XLA(jit_compile=True)는 연산을 융합해 GPU/TPU에서 1.2-2배의 무료 속도 향상을 줍니다.

tensorflow
import tensorflow as tf

# knowledge distillation: train a small student to mimic a large teacher
def distill_loss(teacher_logits, student_logits, temperature=3.0):
    soft_targets = tf.nn.softmax(teacher_logits / temperature)
    soft_probs = tf.nn.log_softmax(student_logits / temperature)
    return tf.reduce_mean(
        tf.keras.losses.categorical_crossentropy(soft_targets, soft_probs, from_logits=True))

# XLA compilation (faster inference)
@tf.function(jit_compile=True)
def predict(x):
    return model(x)

# stack optimizations: prune + quantize + distill + XLA
# always benchmark latency and accuracy before/after each step
19

커스텀 학습 루프

기본 커스텀 루프

커스텀 루프는 기울기 조작, 다중 모델, 커스텀 목적을 완전히 제어합니다. 패턴은 GradientTape -> 손실 -> 기울기 -> apply_gradients이며 속도를 위해 @tf.function으로 감쌉니다. model.losses를 잊지 마세요. kernel_regularizer가 추가한 정규화 손실이며 주 손실에 더해야 합니다. 상태 있는 Metric 객체로 지표를 추적하고 각 에포크에 reset_state()하세요. fit보다 장황하지만 무엇이든 가능하게 합니다.

tensorflow
import tensorflow as tf

optimizer = tf.keras.optimizers.Adam(1e-3)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='train_acc')

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits)
        loss += sum(model.losses)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_loss.update_state(loss)
    train_acc.update_state(y, logits)
    return loss

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    print(f"epoch {epoch}: loss={train_loss.result():.4f} acc={train_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()

커스텀 루프의 검증

검증은 학습과 같지만 training=False(드롭아웃 꺼짐, BatchNorm은 실행 통계 사용)이고 기울기 tape나 옵티마이저가 없습니다. 학습과 검증이 섞이지 않도록 검증용 Metric 객체를 따로 쓰세요. 속도를 위해 test_step을 @tf.function으로 감싸세요. 각 에포크 로깅 후 모든 지표를 리셋하세요. 최적 모델을 저장하려면 val_acc.result()를 실행 중 최고값과 비교하고 개선 시 model.save()를 호출하세요.

tensorflow
import tensorflow as tf

val_loss = tf.keras.metrics.Mean(name='val_loss')
val_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='val_acc')

@tf.function
def test_step(x, y):
    logits = model(x, training=False)
    loss = loss_fn(y, logits)
    val_loss.update_state(loss)
    val_acc.update_state(y, logits)

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    for x, y in val_ds:
        test_step(x, y)
    print(f"epoch {epoch}: val_loss={val_loss.result():.4f} val_acc={val_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()
    val_loss.reset_state(); val_acc.reset_state()

분산 커스텀 루프

분산 커스텀 루프는 strategy.run으로 각 GPU에서 레플리카별 스텝을 실행하고 strategy.reduce로 손실을 집계합니다. 레플리카별 손실을 num_replicas_in_sync로 나눠 합산 기울기가 전역 배치 기울기와 일치하게 하세요. 그렇지 않으면 유효 LR이 GPU 수만큼 스케일됩니다. 기울기는 평소처럼 적용하세요. 전략이 내부에서 all-reduce를 처리합니다. 같은 패턴이 MultiWorkerMirroredStrategy와 TPUStrategy에도 동작합니다.

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():
    model = build_model()
    optimizer = tf.keras.optimizers.Adam(1e-3)
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_ds_dist = strategy.experimental_distribute_dataset(train_ds)

@tf.function
def distributed_train_step(x, y):
    def step_fn(x, y):
        with tf.GradientTape() as tape:
            logits = model(x, training=True)
            loss = loss_fn(y, logits)
            loss += sum(model.losses)
            loss /= strategy.num_replicas_in_sync
        grads = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        return loss
    per_replica_loss = strategy.run(step_fn, args=(x, y))
    return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_loss, axis=None)

for epoch in range(epochs):
    for x, y in train_ds_dist:
        distributed_train_step(x, y)

GAN 학습 루프

GAN은 두 모델을 적대적으로 학습합니다. 생성자는 판별자를 속이려 하고 판별자는 가짜를 탐지하려 합니다. GradientTape 두 개(모델당 하나)와 옵티마이저 두 개를 사용하세요. beta_1=0.5(기본보다 낮음)가 GAN 학습을 안정화합니다. 매 스텝 판별자와 생성자를 학습하세요(또는 비율 교대). GAN은 악명 높게 불안정합니다. d_loss와 g_loss를 모니터링하고 스펙트럴 정규화를 사용하며 모드 붕괴가 생기면 기울기 페널티가 있는 Wasserstein GAN을 고려하세요.

tensorflow
import tensorflow as tf

generator = build_generator()
discriminator = build_discriminator()
g_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
d_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)

@tf.function
def train_gan_step(real_images):
    batch = tf.shape(real_images)[0]
    noise = tf.random.normal((batch, 100))
    with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
        fake = generator(noise, training=True)
        real_logits = discriminator(real_images, training=True)
        fake_logits = discriminator(fake, training=True)
        d_loss = bce(tf.ones_like(real_logits), real_logits) + \
                 bce(tf.zeros_like(fake_logits), fake_logits)
        g_loss = bce(tf.ones_like(fake_logits), fake_logits)
    g_grads = g_tape.gradient(g_loss, generator.trainable_variables)
    d_grads = d_tape.gradient(d_loss, discriminator.trainable_variables)
    g_opt.apply_gradients(zip(g_grads, generator.trainable_variables))
    d_opt.apply_gradients(zip(d_grads, discriminator.trainable_variables))
    return g_loss, d_loss

기울기 누적

TF에서 진정한 기울기 누적은 까다롭습니다. GradientTape가 호출 간 기울기 합산을 쉽게 지원하지 않으므로 tf.Variable에 수동 누적해야 합니다. 위의 단순 근사는 손실을 스케일하고 매 스텝 기울기를 적용해 SGD에는 비슷한 효과를 주지만 Adam에는 동일하지 않습니다(옵티마이저가 더 작고 시끄러운 기울기를 봄). 정확한 누적은 지속 Variable에 기울기를 모아 N스텝마다 적용하세요. GPU 메모리가 배치 크기를 제한할 때 주로 유용합니다.

tensorflow
import tensorflow as tf

accum_steps = 4
optimizer = tf.keras.optimizers.Adam(1e-3)

@tf.function
def accumulated_train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits) / accum_steps
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# simple accumulation via averaging
for batch_idx, (x, y) in enumerate(train_ds):
    accumulated_train_step(x, y)
    # equivalent effective batch = accum_steps * batch_size
    # (Adam moments are updated every step, so this is an approximation)
20

성능 최적화

tf.function

@tf.function은 Python 함수를 정적 그래프로 추적합니다. GPU에서 빠르고 분산에 필요합니다. 입력 시그니처마다 첫 호출이 추적되어 느리고 이후 호출은 그래프를 재사용합니다. tf.function 안에서 텐서 값에 의존하는 Python 제어 흐름(if tensor > 0: ...)을 피하세요. 재추적을 강제합니다. tf.cond / tf.while_loop나 모양/Python 리터럴에만 의존하는 Python 제어 흐름을 사용하세요. input_signature는 모양을 고정해 재추적을 아예 막습니다. reduce_retracing=True는 캐시를 넓힙니다.

tensorflow
import tensorflow as tf

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = model(x, training=True)
        loss = loss_fn(y, preds)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# first call traces the graph (slow), subsequent calls reuse it (fast)
train_step(x_batch, y_batch)

# experimental_relax_shapes allows retracing only when needed
@tf.function(reduce_retracing=True)
def fn(x): return model(x)

# input_signature pins the signature so no retracing
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def predict(x): return model(x)

XLA 컴파일

XLA(Accelerated Linear Algebra)는 서브그래프를 융합 커널로 컴파일해 실행 오버헤드를 줄이고 연산 간 최적화를 가능하게 합니다. tf.function의 jit_compile=True가 해당 함수에 XLA를 트리거합니다. 계산이 많은 모델(트랜스포머, 어텐션)에 가장 효과적이고 I/O 바운드 모델에는 덜 유용합니다. XLA는 컴파일 영역 안에서 정적 모양을 요구하므로 가변 모양은 재컴파일을 유발합니다. 모양 문제가 생기면 고정 모양으로 패딩하세요. 항상 벤치마크하세요. XLA가 작은 모델에서 더 느릴 수 있습니다.

tensorflow
import tensorflow as tf

# JIT-compile a function with XLA (fuses ops for speed)
@tf.function(jit_compile=True)
def train_step(x, y):
    with tf.GradientTape() as tape:
        loss = loss_fn(y, model(x, training=True))
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# enable XLA globally
tf.config.optimizer.set_jit(True)

# XLA fuses element-wise ops, reduces kernel launches,
# and can give 1.5-3x speedup on GPU/TPU
# especially effective for transformer / attention heavy models

입력 파이프라인 최적화

GPU 학습의 병목은 보통 모델이 아니라 입력 파이프라인입니다. 표준 파이프라인은 로드 후 캐시하고 셔플하며 증강을 병렬 매핑하고 배치한 뒤 프리페치합니다. interleave는 디스크 바운드 워크로드에서 여러 TFRecord 파일을 병렬로 읽습니다. drop_remainder=True는 그래프 재추적을 강제하는 가변 모양 마지막 배치를 피합니다. TF Profiler의 Input Pipeline Analyzer로 특정 병목을 찾으세요. AUTOTUNE은 TF가 병렬성과 프리페치 크기를 자동 선택하게 합니다.

tensorflow
import tensorflow as tf

# the canonical high-performance pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()                                      # cache after loading
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32, drop_remainder=True)
      .prefetch(tf.data.AUTOTUNE))

# parallel file reading for TFRecord
files = tf.data.Dataset.list_files('data-*.tfrecord')
ds = files.interleave(
    tf.data.TFRecordDataset,
    cycle_length=4, num_parallel_calls=tf.data.AUTOTUNE)

# options for autotuning
options = tf.data.Options()
options.autotune.enabled = True
ds = ds.with_options(options)

혼합 정밀도와 TF32

혼합 정밀도(float16/bfloat16)는 Tensor Core GPU에서 2-3배 처리량을 줍니다. TF32는 더 쉽습니다. Ampere+(A100, H100)의 matmul에 투명하게 쓰이는 19비트 가수 형식으로 약 3배 속도 향상과 최소 정확도 손실을 주며 코드 변경이나 손실 스케일링이 필요 없습니다. 최대 속도를 위해 둘 다 켜세요. TF32는 CUDA 11+에서 기본 켜짐이지만 TF가 명시적 제어 플래그를 노출합니다. 엄격한 fp32 재현성(과학 계산)에는 TF32를 끄세요.

tensorflow
import tensorflow as tf

# mixed precision (float16 compute, float32 master)
tf.keras.mixed_precision.set_global_policy('mixed_float16')

# enable TF32 on Ampere+ (big matmul speedup, slight precision loss)
tf.config.experimental.enable_tensor_float_32_execution(True)

# TF32 uses 19-bit mantissa for matmul on A100/H100
# it's transparent — no code changes, no loss scaling
# gives ~3x matmul speedup with minimal accuracy impact

# check policy
print(tf.keras.mixed_precision.global_policy())
print('TF32:', tf.config.experimental.tensor_float_32_execution_enabled())

그래프 최적화

Grappler는 실행 전에 자동으로 돌아가는 TF의 그래프 최적화기입니다. 상수 폴딩, 레이아웃 최적화(cuDNN용 NCHW vs NHWC), 연산 융합(리매핑), 죽은 코드 제거 등이 있습니다. 모두 기본 켜짐이므로 디버깅을 위해 특정 최적화를 끌 때만 건드리면 됩니다. debug_stripper는 운영 속도를 위해 Assert/CheckNumerics를 제거합니다. 레이아웃 최적화기는 모델이 NHWC를 지정해도 GPU의 cuDNN 합성곱에 NCHW를 자동 선택합니다.

tensorflow
import tensorflow as tf

# enable grappler (default graph optimizer)
tf.config.optimizer.set_jit(True)       # XLA
tf.config.optimizer.set_experimental_options({
    'disable_model_pruning': False,
    'disable_meta_optimizer': False,
    'layout_optimizer': True,           # optimize data layout (NCHW vs NHWC)
    'constant_folding': True,           # fold constants at build time
    'shape_optimization': True,
    'remapping': True,                  # fuse compatible ops
    'arithmetic_optimization': True,
    'loop_optimization': True,
    'dependency_optimization': True,
    'function_optimization': True,
    'debug_stripper': True,             # remove Assert/CheckNumerics
})

# all on by default — only set explicitly to disable specific ones

AutoGraph와 제어 흐름

AutoGraph는 tf.function 안의 Python if/for/while을 TF 그래프 연산(tf.cond / tf.while_loop)으로 변환해 GPU에서 효율적으로 실행합니다. tf.data.Dataset에 대한 Python 'for' 루프는 추적 시점에 반복되므로 괜찮습니다. 텐서 값(모양이 아님)에 의존하는 if/for는 값이 바뀔 때마다 재추적을 강제하므로 피하세요. 텐서 값에 대한 런타임 제어 흐름에는 tf.cond와 tf.while_loop를 명시적으로 쓰거나 AutoGraph가 처리하게 하세요(처리하지만 변환이 미묘할 수 있음).

tensorflow
import tensorflow as tf

# AutoGraph converts Python if/for/while into tf.cond / tf.while_loop
@tf.function
def fn(x):
    if x > 0:          # AutoGraph converts this
        return x * 2
    else:
        return x

@tf.function
def sum_loop(n):
    total = tf.constant(0)
    for i in tf.range(n):    # AutoGraph converts to tf.while_loop
        total += i
    return total

# Python-side (compile-time) loop vs TF-side (runtime) loop
@tf.function
def train_epoch(dataset):
    for x, y in dataset:   # Python iteration over dataset (fine)
        train_step(x, y)

# avoid data-dependent Python control flow
# if x.shape[0] > 10: ...  # OK (static shape)
# if tf.reduce_sum(x) > 0: ...  # forces retracing

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.