Начало работы
Установка и основы
TensorFlow 2.x по умолчанию работает eagerly (операции выполняются сразу, как обычный Python). Проверяйте доступность CUDA-графических процессоров через tf.config.list_physical_devices('GPU'). Для поддержки GPU ставьте extra [and-cuda] на Linux/Windows или tensorflow-metal на Apple Silicon. TF 2.x включил Keras как tf.keras — высокоуровневый API для большинства задач.
# 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 это может вызвать синхронную копию. Указывайте dtype явно (float32 — стандарт для ML), чтобы избежать незаметных приведений, ломающих производительность.
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]])Eager execution и градиенты
Eager execution делает TF отлаживаемым как обычный Python — print, pdb и трассировки работают. GradientTape записывает операции прямого прохода по отслеживаемым тензорам (tf.Variable отслеживается автоматически), чтобы tape.gradient мог вычислить производные. Это основа собственных циклов обучения. Ленты по умолчанию одноразовые; используйте persistent=True, чтобы вызывать gradient несколько раз.
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 control flow внутри (используйте tf.cond / tf.while_loop, иначе функция будет ретрассироваться). Переменные должны создаваться один раз, вне функции, либо переиспользуйте tf.Variable с тем же именем.
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.]))Смешанная точность
Mixed precision вычисляет в float16, но хранит мастер-копии float32, давая ускорение в 2–3 раза и вдвое меньше памяти на GPU с Tensor Core (Volta+). Политика 'mixed_float16' автоматически управляет масштабированием лосса, предотвращая underflow. Принудительно оставляйте выходной слой float32 ради численной стабильности. Нужна compute capability >= 7.0; на старых GPU может быть медленнее.
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())Тензоры
tf.constant
tf.constant создаёт неизменяемый тензор — нельзя п рисвоить элементу. Для обучаемых тензоров используйте tf.Variable. tf.random.normal/uniform принимают аргумент seed для воспроизводимости; tf.random.set_seed(42) делает воспроизводимой всю программу. Для многомерного создания используйте кортежи shape (не int), чтобы избежать сюрпризов.
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 -> TypeErrortf.Variable
tf.Variable — изменяемая обёртка тензора для параметров модели и состояния оптимизатора. assign / assign_add / assign_sub обновляют его на месте — обычное присваивание в Python (w = w + 1) создаёт новый тензор и не мутирует. Переменные отслеживаются GradientTape автоматически, в отличие от tf.constant, который нужно явно watch(). Держите переменные на том же устройстве, что и операции с ними.
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, чтобы сохранить ранг для бродкастинга. tf.matmul и оператор @ делают умнож ение матриц (батчево при 3D+). reshape возвращает представление, когда возможно; transpose в TF всегда возвращает копию.
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 поддерживает нарезку в стиле NumPy в eager-режиме и внутри tf.function. tf.boolean_mask извлекает элементы, где маска True (в плоском виде). tf.gather выбирает по оси 0 по умолчанию (как fancy indexing). tf.where(cond, x, y) — векторизованный тернарный оператор: если cond True, берётся из x, иначе из y. Для присваивания используйте tf.tensor_scatter_nd_update или tf.Variable.
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-тензоры хранят только ненулевые индексы и значения, экономя память для сильно разреженных данных (рекомендации, графы). У большинства операций есть sparse-варианты; п ереводите в dense только когда операция требует. tf.RaggedTensor.to_tensor() паддит до прямоугольника для embedding-поиска.
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 — это clamp в TF. tf.maximum/minimum поэлементны (в отличие от tf.reduce_max/min, которые сводят размерность). cumsum/cumprod дают накопительные суммы и произведения по оси — полезно для кумулятивных метрик и алгоритмов префиксных сумм в своих слоях.
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]Модели Keras
Sequential API
Sequential — простейшая модель Keras: линейный пайплайн, где выход каждого слоя идёт на вход следующему. input_shape не включает размерность батча (испо льзуйте None для переменного батча). model.summary() печатает формы слоёв и число параметров. Если не передать input_shape, модель строится лениво при первом fit/forward — вызовите build() явно, чтобы посмотреть раньше.
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 batchFunctional API
Functional API позволяет слоям ветвиться, сливаться и пропускать связи — необходимо для всего нелинейного (ResNet, несколько входов и выходов, сиамские сети). Определите входные тензоры Input, связывайте слои вызовами, затем передайте входы и выходы в Model. Полученная модель ведёт себя как Sequential для fit/predict. Именуйте входы и выходы для чистого сохранения и сигнатур сервинга.
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)Наследование Model
Наследование tf.keras.Model даёт полный контроль над forward (как в PyTorch). Определяйте слои в __init__, реализуйте call(inputs, training=). Флаг training переключает поведение dropout и BatchNorm. Наследование гибче, но теряет часть преимуществ Functional API: сложнее исследовать и рисовать, нет автоматического вывода формы входа, сериализация сложнее. Для большинства архитектур предпочитайте Functional; наследование — для исследовательских моделей.
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, — бесценно для отладки, но медленно.
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 и график модели
summary() печатает таблицу по слоям с формами выходов и числом параметров — самый быстрый способ найти ошибки форм. plot_model сохраняет визуальный граф (нужны pydot и Graphviz). get_config возвращает сериализуемый словарь, чтобы архитектуру можно было пересобрать без весов, — используется model.to_json() и форматом сохранения Keras. Для Functional-моделей конфиг полностью описывает архитектуру; для наследуемых get_config нужно реализовать самому.
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, поэтому быстры. Для аугментации только при обучении задайте training=True в fit, чтобы при инференсе слои были неактивны. Rescaling(1./255) переводит uint8 [0,255] в float [0,1].
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Слои
Dense
Dense — полносвязный слой: y = activation(xW + b). Форма веса (in_features, out_features) — транспонированная относительно PyTorch. kernel_initializer по умолчанию Glorot/Xavier uniform, хорошо для tanh/sigmoid; для семейства ReLU используйте 'he_normal'. L2-регуляризация задаётся через kernel_regularizer. GELU — стандартная активация в трансформерах.
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 по умолчанию использует NHWC (channels-last), в отличие от NCHW в PyTorch. padding='same' дополняет так, что пространственный размер выхода равен входу, делённому на stride; 'valid' без дополнения. DepthwiseConv2D применяет один фильтр на входной канал (используется в MobileNet). Conv2DTranspose делает апсемплинг (в декодерах сегментации). Форма ядра — (kH, kW, in_channels, filters).
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). return_sequences=True нужен при стеке RNN или для seq2seq; False — для sequence-to-vector. Bidirectional удваивает размер выхода, конкатенируя прямое и обратное направления. recurrent_dropout удобен, но медленный (нет ускорения cuDNN) — предпочитайте обычный dropout на входах.
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 * 2Dropout и регуляризация
Dropout случайно зануляет юниты во время обучения, предотвращая коадаптацию, — при инференсе автоматически отключается (training=False). SpatialDropout2D зануляет целые карты признаков, лучше для свёрточных сетей. L2 (weight decay) — самый частый регуляризатор. LayerNormalization нормализует по оси признаков (на каждый сэмпл), в отличие от BatchNorm, который нормализует по батчу, — предпочтительна для трансформеров и RNN.
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()Batch Normalization
BatchNormalization нормализует активации по каналам, сохраняя EMA running stats для инференса. axis=-1 нормализует последнюю (канальную) ось для NHWC. Ставьте BN после свёртки и до активации, отключайте bias у свёртки (use_bias=False), так как сдвиг делает beta в BN. momentum управляет скоростью подстройки running stats — большие значения (0.99) стабильнее. BN ведёт себя по-разному в train и inference (флаг training).
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 для своих операций. Определяйте веса в build() (вызывается один раз с формой входа), а не в __init__, чтобы слой адаптировался под размер входа. Реализуйте get_config(), чтобы слой сериализовался и загружался. add_weight регистрирует тензор в учёте Keras (он появляется в weights, сохраняется и переносится на устройство). Для stateless-преобразований можно не делать build() и просто переопределить call().
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)))Функции потерь
BinaryCrossentropy
BinaryCrossentropy — для бинарных задач или multi-label (каждый класс независим). Передавайте from_logits=True, если модель выдаёт сырые логиты, — это численно безопаснее, чем sigmoid + BCE по отдельности. pos_weight повышает вес положительных примеров при дисбалансе. Для multi-label с C классами форма цели (N, C) из 0/1, предсказания — (N, C) вероятностей или логитов.
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 ожидает one-hot цели; SparseCategoricalCrossentropy — целочисленные индексы классов (экономнее по памяти при многих классах). Всегда передавайте from_logits=True, когда модель не заканчивается softmax, — используется трюк log-sum-exp для численной стабильности. Для label smoothing используйте CategoricalCrossentropy(label_smoothing=0.1), сильный регуляризатор для классификации и NLP.
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 ведёт себя как MSE около нуля и как MAE вдали — стандарт для регрессии в детекции объектов. LogCosh похож, но дважды дифференцируем везде, полезен, когда нужны производные второго порядка. Все reduction по умолчанию усредняют по батчу; переопределите через reduction=tf.keras.losses.Reduction.NONE для лоссов по сэмплам.
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 снижает вес лёгких примеров, фокусируясь на сложных, — популярен в детекции объектов. Используйте Reduction.NONE в call() и позвольте Keras усреднить в конце, если хотите, чтобы работало маскирование.
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, а затем cross-entropy по отдельности может переполниться при больших логитах (e^100). from_logits=True позволяет TF объединить их трюком log-sum-exp, что численно стабильно. Функциональные API tf.nn.*_cross_entropy_with_logits делают то же. Убедитесь, что модель НЕ заканчивается softmax/sigmoid при from_logits=True, иначе активация применится дважды.
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 так, чтобы ни одна задача не доминировала в градиенте.
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)Оптимизаторы
Adam
Adam — оптимизатор по умолчанию для большинства задач: адаптивные скорости обучения по параметрам, устойчив к выбору гиперпараметров. beta_1/beta_2 управляют затуханием EMA первого и второго моментов. Передавайте объект LearningRateSchedule вместо float, чтобы затухать LR во время обучения. global_clipnorm масштабирует все градиенты, если их общая норма превышает порог, — важно для RNN и трансформеров.
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 + momentum часто обобщает лучше Adam при обучении CNN на больших батчах, ценой более тонкой настройки LR. momentum=0.9 — стандарт; Nesterov даёт небольшой прирост. weight_decay добавляет развязанную L2-регуляризацию (Keras 3) — старые версии используют kernel_regularizer на слоях. SGD нужны warmup и расписание LR, чтобы конкурировать с Adam из коробки.
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 развязывает weight decay и обновление по градиенту, что важно в больших масштабах (трансформеры, крупные CNN). RMSprop — классический оптимизатор для RNN. Adagrad адаптируется по параметрам, но может застрять на старте — годится для разреженных признаков. FTRL создан для крупномасштабного онлайн-обучения с разреженными признаками (предсказание кликов). Для новых проектов начинайте с AdamW.
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-градиенты означают, что переменная не влияла на лосс, — частая ситуация для неиспол ьзуемых параметров, стоит логировать.
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)Расписания learning rate
Объекты LearningRateSchedule вычисляют LR как функцию от счётчика шагов оптимизатора. CosineDecay плавно затухает до alpha*initial_lr — сильный выбор по умолчанию. CosineDecayRestarts реализует warm restarts в стиле SGDR. Передавайте расписание как learning_rate при создании оптимизатора; Keras вызывает его автоматически каждый шаг. Для warmup оберните в своё расписание или используйте WarmUp-колбэк из tensorflow/addons.
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 жёстко ограничивает каждый элемент. Для своего клиппинга меняйте grads между tape.gradient и apply_gradients. Экспоненциальное скользящее среднее (EMA) весов часто даёт небольшой прирост точности на инференсе — применяйте после каждого шага и используйте усреднённые веса для оценки. В TF Addons есть обёртка оптимизатора MovingAverage.
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)Обучение
compile и fit
fit — высокоуровневый API обучения: он берёт на себя батчи, перемешивание, валидацию, колбэки и прогресс. Передайте либо validation_data=(x, y), либо validation_split=0.2 (откладывается от обучающих данных). verbose=2 печатает строку на эпоху (удобно для логов); 1 показывает прогресс-бар. Возвращаемый объект history хранит лосс и метрики по эпохам — постройте график, чтобы заметить переобучение.
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'])Валидация и метрики
Метрики — stateful-объекты, которые накапливаются по батчам и вычисляют итог в конце эпохи; в отличие от лоссов они не влияют на обучение. Передавайте строки ('accuracy') или объекты Metric для своих метрик. Наследуйте tf.keras.metrics.Metric и реализуйте update_state/result/reset_state. reset_state (переименован из reset_states в TF 2.11+) вызывается в начале каждой эпохи.
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, momentum) продолжится корректно.
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 даёт контроль на уровне примеров, полезен для mining сложных примеров или маскирования паддинга. При использовании tf.data.Dataset включайте sample_weight третьим элементом кортежа, чтобы датасет выдавал (x, y, w). Используйте sklearn.utils.class_weight для автоматического расчёта сбалансированных весов.
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) для аугментации на тесте.
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. Это мост между высокоуровневым fit и полностью своим циклом — отлично для GAN, контрастивного обучения и любых нестандартных целей. Используйте self.compiled_loss и self.compiled_metrics, чтобы лосс и метрики из compile() продолжали работать. test_step так же переопределяет поведение валидации.
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)Колбэки
EarlyStopping
EarlyStopping останавливает обучение, когда отслеживаемая метрика перестаёт улучшаться, экономя время и предотвращая переобучение. patience=N ждёт N эпох без улучшения перед остановкой. restore_best_weights=True возвращает веса лучшей эпохи в конце — без этого останутся (возможно, худшие) финальные веса. mode='min' для лоссов, 'max' для accuracy. Всегда задавайте щедрый максимум эпох и позволяйте колбэку решать.
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) — задайте monitor вашу val-метрику. save_weights_only=True меньше и не зависит от архитектуры, но для загрузки нужен класс модели. Плейсхолдеры вроде {epoch:02d} вставляют номер эпохи в и мя файла. save_freq='epoch' по умолчанию; целое N сохраняет каждые N батчей.
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 печатает каждое снижение.
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 запускает TF Profiler на батче 2, чтобы найти узкие места (входной пайплайн, задержки операций). Запустите TensorBoard с указанием log_dir для просмотра графиков. Используйте отдельные подкаталоги для экспериментов, чтобы с равнивать запуски.
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=./logsLearningRateScheduler
LearningRateScheduler принимает функцию от (epoch, lr) и применяет новый LR в начале каждой эпохи — просто, но только по эпохам. Для пошаговых расписаний предпочитайте объект LearningRateSchedule, переданный оптимизатору (см. раздел оптимизаторов): он вызывается каждый батч и работает внутри tf.function. Форма колбэка годится для грубых расписаний. Для warmup и затухания объект расписания чище.
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). Держите их дешёвыми — они работают на каждом батче.
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()])Пайплайн tf.data
tf.data.Dataset
tf.data.Dataset — потоковый API данных TF: он эффективно ведёт данные с диска и CPU к GPU. from_tensor_slices соединяет тензоры по оси 0. Каноническая цепочка: shuffle -> batch -> prefetch: shuffle перемешивает, batch группирует, prefetch перекрывает подготовку следующего батча с текущим обучением. Используйте AUTOTUNE, чтобы TF сам подобрал размеры буферов prefetch.
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)
breakMap, filter и cache
map применяет функцию к каждому элементу — аугментация, нормализация, токенизация. num_parallel_calls=AUTOTUNE распараллеливает по ядрам CPU. cache() сохраняет датасет в памяти (или файле), чтобы последующие эпохи не читали источник, — огромное ускорение для небольших и средних данных, но кэшируйте ДО случайных операций, иначе будете повторять одни и те же аугментации каждую эпоху. Канонический порядок: cache -> map(augment) -> shuffle -> batch -> prefetch.
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 делает перемешивание воспроизводимым между итерациями, только если reshuffle_each_iteration=True с тем же seed.
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) — самый большой выигрыш: CPU готовит батч N+1, пока GPU обучается на батче N, и никто не ждёт. num_parallel_calls=AUTOTUNE на map распараллеливает предобработку на CPU. Оптимальный порядок пайп лайна: источник -> cache -> shuffle -> map(augment) -> batch -> prefetch. Используйте tf.data.experimental.AUTOTUNE (то же, что tf.data.AUTOTUNE) и позвольте TF подобрать размеры буферов. Всегда профилируйте перед оптимизацией — узкое место часто в другом месте.
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 — аналог ImageFolder из PyTorch в Keras: он выводит метки из имён подкаталогов и возвращает (image_batch, label_batch). Для большего контроля над загрузкой изображений используйте tf.io.read_file + tf.io.decode_image внутри map. Всегда батчируйте датасет до передачи в fit.
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 (словарь признаков). Чтение последовательное, что намного быстрее случайных чтений в облачном хранилище (GCS/S3). Для изображений храните сырые байты и декодируйте в map(). Используйте tf.data.TFRecordDataset с compression='GZIP' для меньших файлов. Шардирование (несколько файлов .tfrecord-0000N-of-0000M) позволяет параллельное чтение.
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)Сохранение и загрузка
Формат SavedModel
SavedModel — продакшен-формат: он объединяет архитектуру, веса и трассированный граф, поэтому модель можно загрузить в TF Serving, TFLite, TF.js или C++ без исходного Python-кода. Для загрузки в Python используйте tf.keras.models.load_model. Передайте input_signature, чтобы явно задать сигнатуру сервинга, — требуется для TF Serving. SavedModel — это каталог, а не один файл.
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) — один zip-файл с конфигом архитектуры, весами и состоянием оптимизатора: легко делиться и версионировать. .h5 — устаревший формат HDF5, всё ещё поддерживается, но не рекомендуется для новых проектов. SavedModel (каталог) нужен для деплоя (TFLite, TF Serving). Для своих слоёв .keras сохраняет конфиг, чтобы слой можно было пересобрать, — убедитесь, что get_config() корректен.
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) загружает только совпадающие слои — полезно в transfer learning. Формат чекпоинта (префикс 'ckpt') создаёт файлы checkpoint/weights-of-ckpt-1.index — нативный формат чекпоинтов TF, используемый внутри колбэков fit.
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')CheckpointManager
Checkpoint + CheckpointManager дают полный контроль над сохранением в своих циклах обучения: хранить последние N чекпоинтов, автоматически восстанавливать последний и версионировать по шагу. expect_partial() заглушает предупреждения о невосстановленных слотах (например, momentum оптимизатора для новых переменных). Чекпоинты хр анят граф объектов, а не определения классов, — код модели всё равно нужен для восстановления. CheckpointManager.max_to_keep=3 автоматически удаляет старые чекпоинты.
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) внутри.
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 и определите __call__ с input_signature, включающей сырой вход (например, uint8-изображение) и возвращающей финальный выход. Называйте тензоры, чтобы клиенты могли к ним обращаться.
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']CNN
Conv2D и пулинг
Канонический блок CNN в Keras: Conv2D -> BatchNormalization -> ReLU -> MaxPooling. padding='same' сохраняет пространственный размер при stride 1. GlobalAveragePooling2D схлопывает пространственные оси в вектор — эффективнее по параметрам, чем Flatten + Dense, и меньше склонен к переобучению. Keras по умолчанию использует NHWC (channels-last), поэтому форма Input — (H, W, C) без размерности батча. Свёртки со stride могут заменить пулинг для обучаемого даунсэмплинга.
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
CNN в стиле VGG с удвоением фильтров на каждой стадии (32 -> 64 -> 128) и уменьшением пространственного размера вдвое через MaxPooling. Две свёртки на стадию (блок VGG) извлекают более богатые признаки, чем одна. Rescaling внутри модели делает её готовой к деплою — сырые uint8-изображения идут прямо на вход. GlobalAveragePooling + Dropout регуляризуют голову. Компилируйте со sparse_categorical_crossentropy, потому что метки — целочисленные индексы классов.
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 с тем же входом, но несколькими выходами (активации свёрточных слоёв), чтобы посмотреть, что учит каждый слой. Ранние слои детектируют края и цвета, глубокие — текстуры и части. Это бесценно для отладки: мёртвые карты признаков (все нули) указывают на сломанные ReLU или проблемы с learning rate. Для Grad-CAM (карт активации классов) используйте tf-keras-vis или реализуйте взвешенные по градиенту активации классов, чтобы увидеть, какие области повлияли на предсказание.
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')Предобученные backbone CNN
keras.applications предоставляет ResNet, EfficientNet, MobileNet, ViT и другие с весами ImageNet. include_top=False убирает голову на 1000 классов, чтобы прикрепить свою. preprocess_input применяет точную нормализацию, с которой обучался backbone, — вызывайте её внутри модели для деплоя. Заморо зьте backbone (trainable=False) и вызывайте base(x, training=False), чтобы BatchNorm использовал статистики инференса, — критично для transfer learning на небольших датасетах.
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)Residual-связи
Residual (skip) связи добавляют вход к выходу блока, позволяя градиентам течь напрямую к ранним слоям, — именно это позволяет обучать очень глубокие сети (ResNet). Shortcut должен совпадать по каналам и пространственному размеру с выходом; используйте свёртку 1x1 со stride для выравнивания, когда не совпадают. Add() сливает два пути. Используйте Functional API (не Sequential) для любой архитектуры со skip-связями. ResNet-50 стек многих таких блоков.
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 loss.
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}RNN и LSTM
Слои LSTM и GRU
Форма входа LSTM/GRU — (batch, timesteps, features). return_sequences=False возвращает последний выход (для классификации); True возвращает всю последовательность (для стека или seq2seq). Bidirectional конкатенирует прямой и обратный выходы, удваивая размер признаков. stateful=True переносит скрытое состояние между батчами — полезно для очень длинных последовательностей, разбитых на куски, но требует фиксированного batch_size и ручного сброса состояния между эпохами.
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
Стек RNN задаётся return_sequences=True у всех LSTM/GRU, кроме последнего. mask_zero=True в слое Embedding порождает маску, которую RNN учитывают — они пропускают паддинг-позиции, поэтому можно батчировать последовательности разной длины без искажения скрытого состояния. Dropout между слоями RNN регуляризует; recurrent_dropout внутри RNN медленнее (нет cuDNN), предпочитайте dropout на входе. Для классификации текста такой biLSTM — сильный baseline.
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, но требуют больше данных и вычислений.
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)Encoder-Decoder Seq2Seq
Encoder-decoder LSTM для seq2seq (перево д, суммаризация). Финальное скрытое состояние энкодера инициализирует декодер, который генерирует целевую последовательность токен за токеном. Обучение с teacher forcing: подавайте сдвинутую целевую последовательность как вход декодера. Для инференса напишите отдельный цикл, который подаёт каждый предсказанный токен обратно как следующий вход. Внимание (Bahdanau/Luong) резко улучшает seq2seq и является концептуальным предком трансформеров.
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. Всегда стандартизируйте ряд только статистиками обучающего набора.
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 как готовые слои. Внимание — концептуальный мост к трансформерам: multi-head self-attention это просто внимание, применённое к той же последовательности.
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])Трансформер
MultiHeadAttention
MultiHeadAttention — ключевой слой трансформера: он проецирует q/k/v в несколько голов, считает внимание параллельно и объединяет. Для self-attention передайте один и тот же тензор как query, key и value. attention_mask может быть каузальной маской (нижнетреугольной) для декодирования или маской паддинга (True = игнорировать). return_attention_scores=True возвращает матрицу внимания для визуализации. Размерность выхода равна входной, чтобы блоки можно было стекать.
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)Блок энкодера трансформера
Блок энкодера трансформера: multi-head self-attention + add & norm + feed-forward (MLP) + add & norm. Pre-LN (норма до подслоя) устойчивее при обучении с нуля; post-LN требует warmup. FFN — двухслойный MLP с GELU, расширяющийся до 'ff' скрытых юнитов и обратно к 'dim'. Стек N таких блоков даёт полный энкодер. epsilon=1e-6 в LayerNorm предотвращает деление на ноль при малых дисперсиях.
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) добавляйте обучаемый позиционный эмбеддинг на каждый патч.
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 блоков энкодера + global average pool + голова Dense. GlobalAveragePooling1D схлопывает размерность последовательности (используйте CLS-токен для обучаемой агрегации). mask_zero=True распространяет маску, которую учитывает MultiHeadAttention, — при необходимости передавайте её вручную. Для реального NLP используйте предобученный трансформер (BERT, T5) из HuggingFace — обучение с нуля требует огромных данных.
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)Vision Transformer (ViT)
Vision Transformer нарезает изображение на патчи свёрткой со stride (kernel=stride=patch_size), трактует патчи как токены, добавляет CLS-токен в начало, добавляет позиционные эмбеддинги и прогоняет блоки энкодера трансформера. Финальное скрытое состояние CLS-токена — глобальное представление изображения для классификации. Для реального использования загрузите предобученный ViT из keras.applications или HuggingFace — им нужно предобучение на ImageNet-21k, чтобы работать хорошо. Размер патча 16 и dim 768 — значения по умолчанию для ViT-Base.
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)Декодер трансформера
Блок декодера имеет три подслоя: маскированное self-attention (каузальная маска, чтобы позиция t не видела будущее), cross-attention (query из декодера, key/value из выхода энкодера) и FFN. У каждого подслоя residual + LayerNorm. Cross-attention позволяет декодеру «оглядываться» на исходную последовательность. Для decoder-only моделей (GPT) уберите подслой cross-attention. Стек N блоков даёт полный декодер. Инференс требует авторегрессивного цикла, подающего предсказанные токены обратно.
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 xTensorBoard
Настройка и колбэк
Колбэк TensorBoard передаёт метрики, графы и данные профилирования в log_dir во время fit. histogram_freq=1 логирует распределения весов каждую эпоху — 0 экономит место. profile_batch=2 запускает TF Profiler на этом батче, чтобы найти узкие места (входной пайплайн, задержки операций, память). Используйте отдельные подкаталоги для экспериментов (logs/exp1, logs/exp2), чтобы TensorBoard накладывал их, — идеально для перебора гиперпараметров. Запуск: tensorboard --logdir=logs.
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. Логируйте LR, нормы градиентов и любые нужные метрики.
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 логирует изображения для визуальной проверки — передавайте форму (B, H, W, C), где B до max_outputs. Гистограммы показывают распределения весов и градиентов во времени; резкие всплески намекают на нестабильность. Логируйте несколько примеров валидации за эпоху, чтобы видеть качественный прогресс, а не только скалярные метрики. Аудио полезно для речевых моделей. Все summary принимают аргумент step, который становится осью X в TensorBoard. Держите логирование дешёвым, сэмплируя каждый N-й шаг.
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.
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 различаются.
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Обучение на GPU и TPU
Определение GPU и память
По умолчанию TF захватывает всю память GPU при старте, блокируя другие процессы. set_memory_growth(True) выделяет только нужное — необходимо для совместного использования GPU. set_logical_device_configuration ограничивает память или делит одну GPU на несколько логических устройств (полезно для тестирования multi-GPU кода на одной GPU). tf.device('/GPU:1') размещает операции на конкретном устройстве. Операции CPU выполняются на '/CPU:0'. Несовпадение размещения устройств вызывает неявные копии, вредящие производительности.
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 градиентов) — самый простой путь к multi-GPU. MultiWorkerMirroredStrategy расширяется на несколько машин. TPUStrategy работает на Google TPU (Colab/Cloud). Всегда создавайте модель внутри strategy.scope(), чтобы переменные зеркалировались правильно. Тот же код fit/predict работает с разными стратегиями.
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 (например, 64 на GPU * 4 GPU = 256). Передавайте глобальный батч датасету; TF распределяет шарды автоматически. fit() выполняет all-reduce градиентов под капотом. Для своих циклов используйте strategy.experimental_distribute_dataset и strategy.run(train_step).
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 не может читать локальные файлы напрямую; загружайте данные в память или потоково читайте из GCS через tf.data. Mixed precision (bfloat16) даёт большой прирост на TPU и не требует масштабирования лосса.
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)Смешанная точность
Mixed precision вычисляет в float16, но хранит мастер-копии float32, давая ускорение в 2–3 раза на GPU с Tensor Core (Volta+) и вдвое меньше памяти. 'mixed_float16' требует масштабирования лосса (Keras делает это автоматически через LossScaleOptimizer). 'mixed_bfloat16' имеет тот же диапазон, что float32, поэтому масштабирование не нужно, но поддерживается только на GPU Ampere+ и TPU. Принудительно приводите последний слой к float32 ради численной стабильности (softmax/логиты). Mixed precision — самый простой способ ускорить обучение.
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">Аугментация данных
Слои предобработки Keras
Слои предобработки Keras (RandomFlip, RandomRotation и т. д.) работают на GPU и внутри tf.function — намного быстрее аугментации на PIL/numpy. Если поместить их внутрь модели, они автоматически отключаются при инференсе (training=False). Альтернативно применяйте их в map tf.data для большего контроля. Эти слои stateless и JIT-компилируются, поэтому не замедляют инференс. Для stateful-предобработки (например, обученных scaler'ов) используйте Adapt API.
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.
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. Применяйте аугментацию в map tf.data с num_parallel_calls=AUTOTUNE, чтобы она работала в воркерах CPU и не блокировала GPU. Всегда ограничивайте обратно допустимым диапазоном пикселей после цветовых искажений.
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. Оба требуют, чтобы лосс принимал мягкие (смешанные) метки, — используйте categorical_crossentropy, а не sparse. Применяйте на батче после батчирования. Комбинируйте со стандартной геометрической аугментацией для лучших результатов.
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) — порча меток вредит больше, чем помогает.
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)Transfer learning
Предобученные модели
keras.applications предоставляет ResNet, EfficientNet, MobileNet, ViT и другие с весами ImageNet. include_top=False убирает голову на 1000 классов, чтобы прикрепить свою. preprocess_input применяет точную нормализацию, которую ожидает backbone, — вызывайте её внутри модели для деплоя. Заморозьте backbone (trainable=False) и вызывайте base(x, training=False), чтобы BatchNorm использовал статистики инференса, — критично для небольших датасетов, где статистики BN иначе были бы шумными.
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)Извлечение признаков
Извлечение признаков замораживает весь backbone и обучает только новую голову — самый быстрый baseline в transfer learning. Поскольку backbone фиксирован, признаки можно вычислить один раз (base.predict(train_ds)) и обучить на них крошечный классификатор, экономя огромные вычисления. Задавайте training=False при вызове backbone, чтобы BatchNorm использовал running stats, иначе небольшие батчи их испортят. Хорошо для небольших датасетов (сотни изображений), где файнтюнинг переобучился бы.
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)Файнтюнинг
Файнтюнинг размораживает часть слоёв backbone и обучает их с малым LR, чтобы предобученные признаки адаптировались к задаче. Всегда сначала делайте извлечение признаков (только голова) несколько эпох, ЗАТЕМ размораживайте, иначе большие градиенты случайной головы испортят предобученные признаки. Используйте намного меньший LR (1e-5 против 1e-3 для головы). Размораживайте сверху вниз (поздние слои более специфичны для задачи, ранние — общие). Держите слои BatchNorm замороженными, чтобы сохранить их running stats.
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 замороженными во время файнтюнинга: их running stats ценны, и небольшие батчи файнтюнинга их испортят. Сравнивайте trainable_weights и weights, чтобы подтвердить, что будет обновляться. Логируйте число обучаемых параметров, чтобы случайно не заморозить или не разморозить всё (частая тихая ошибка).
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:,}")Многозадачный transfer
Многозадачное обучение делит backbone между связанными задачами, регуляризуя представление и экономя вычисления. Каждая голова — небольшая ветка от общих признаков. Передавайте лоссы по выходам и loss_weights в compile, чтобы сбалансировать гр адиенты задач (подбирайте веса так, чтобы ни одна задача не доминировала). При fit передавайте цели словарём, соответствующим именам выходов. Многозадачный transfer мощен, когда одна задача имеет много данных, а другая мало, — общий backbone помогает обеим.
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},
)Деплой моделей
Конвертер TFLite
TFLite конвертирует модели TF в flatbuffer-формат для мобильных, встраиваемых и edge-устройств. Optimize.DEFAULT автоматически применяет посттренировочную квантизацию; полная int8-квантизация требует репрезентативного датасета для калибровки диапазонов активаций и даёт модель, работающую на Edge TPU и микроконтроллерах. float16 сохраняет совместимость с GPU и безопаснее, если int8 ухудшает точность. Конвертер выводит формы входа из модели; для динамических форм зафиксируйте их конкретными функциями.
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 работает везде.
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 за gRPC/REST API с версионированием, батчированием и поддержкой GPU. Структура каталогов serving/1/, serving/2/ позволяет горячо подменять модели. Docker-образ — простейший локальный деплой; для продакшена используйте Vertex AI, SageMaker или KServe. TF Serving автоматически батчирует запросы для максимальной загрузки GPU. REST API использует {instances: [...]} для входов и возвращает {predictions: [...]}; для именованных входов и выходов используйте параметр signature_name.
# 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)
Quantization-Aware Training (QAT) вставляет операции фальшивой квантизации во время обучения, чтобы модель адаптировалась к шуму округления, который увидит при int8-инференсе, — обычно восстанавливает большую часть точности, потерянной при посттренировочной квантизации. Используйте tfmot (tensorflow-model-optimization), чтобы обернуть обученную модель, дообучить несколько эпох, затем сконвертировать в TFLite. QAT необходима, когда int8-посттренировочная квантизация роняет точность ниже порога (например, EfficientNet, детекторы объектов). Полученная TFLite-модель работает на Edge TPU.
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 и edge-деплой
TF.js запускает модели в браузере или Node.js. Конвертер превращает SavedModel/.keras/.h5 в model.json + каталог бинарных весов. Layers-модели поддерживают API Keras (fit, predict, даже обучение на лету); graph-модели совместимее, но менее гибкие. Инференс в браузере использует WebGL/WASM; Node.js может использовать CUDA. TF.js отлично подходит для клиентского ML (без обращения к серверу, приватность, офлайн). Для мобильных предпочитайте TFLite (меньше, быстрее, аппаратное ускорение).
# 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Оптимизация инференса
Для низкой задержки складывайте оптимизации: pruning (обнуление малых весов, сжатие), дистилляция знаний (обучение маленького студента под логиты большого учителя), квантизация (int8/float16) и компиляция XLA (слияние операций). У каждого шага есть компромиссы — всегда замеряйте на целевом железе. Дистилляция обычно лучше сохраняет точность; pruning + квантизация дают наибольшее сокращение размера. XLA (jit_compile=True) сливает операции ради бесплатного ускорения в 1.2–2 раза на GPU/TPU.
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Свой цикл обучения
Базовый свой цикл
Свой цикл даёт полный контроль: работа с градиентами, несколько моделей, свои цели. Паттерн: GradientTape -> лосс -> градиенты -> apply_gradients, обёрнутый в @tf.function для скорости. Не забудьте model.losses — это регуляризационные лоссы, добавленные kernel_regularizer, их нужно прибавить к основному лоссу. Отслеживайте метрики stateful-объектами Metric и вызывайте reset_state() каждую эпоху. Это многословнее fit, но открывает всё.
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 (dropout выключен, BatchNorm использует running stats) и без градиентной ленты и оптимизатора. Используйте отдельные объекты Metric для валидации, чтобы train и val не смешивались. Оборачивайте test_step в @tf.function для скорости. Сбрасывайте все метрики после логирования каждой эпохи. Чтобы сохранить лучшую модель, сравнивайте val_acc.result() с текущим лучшим и вызывайте model.save() при улучшении.
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.
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 с штрафом на градиент при mode collapse.
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 (оптимизатор видит меньшие, более шумные градиенты). Для точного накопления складывайте градиенты в persistent-переменные и применяйте каждые N шагов. В основном полезно, когда память GPU ограничивает размер батча.
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)Оптимизация производительности
tf.function
@tf.function трассирует Python-функцию в статический граф — быстрее на GPU и необходимо для распределённого обучения. Первый вызов на каждую сигнатуру входа трассирует (медленно); последующие переиспользуют граф. Избегайте Python control flow, зависящего от ЗНАЧЕНИЙ тензоров (if tensor > 0: ...) внутри tf.function — это вызывает ретрассировку. Используйте tf.cond / tf.while_loop или Python control flow, зависящий только от форм и литералов. input_signature фиксирует формы, полностью предотвращая ретрассировку. reduce_retracing=True расширяет кэш.
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) компилирует подграфы в слитые ядра, снижая накладные расходы на запуск и включая межоперационные оптимизации. jit_compile=True на tf.function включает XLA для этой функции. Наиболее эффективно для вычислительно тяжёлых моделей (трансформеры, внимание) и менее полезно для I/O-зависимых. XLA требует статических форм внутри скомпилированной области — переменные формы вызывают перекомпиляцию. При проблемах с формами паддите до фиксированных. Всегда замеряйте: для небольших моделей XLA иногда медленнее.
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 обычно входной пайплайн, а не модель. Канонический пайплайн кэширует после загрузки, перемешивает, параллельно применяет аугментацию, батчирует и делает prefetch. interleave параллельно читает несколько TFRecord-файлов для дисковых нагрузок. drop_remainder=True избегает последнего батча переменной формы, который вызывает ретрассировку графа. Используйте Input Pipeline Analyzer в TF Profiler, чтобы найти конкретное узкое место. AUTOTUNE позволяет TF самому выбрать параллелизм и размеры prefetch.
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
Mixed precision (float16/bfloat16) даёт ускорение в 2–3 раза на GPU с Tensor Core. TF32 ещё проще: это формат с 19-битной мантиссой, прозрачно используемый для matmul на Ampere+ (A100, H100), дающий ускорение примерно в 3 раза с минимальной потерей точности и БЕЗ изменений кода и масштабирования лосса. Включайте оба для максимальной скорости. TF32 включён по умолчанию в CUDA 11+, но TF выставляет флаг для явного контроля. Для строгой воспроизводимости fp32 (научные расчёты) отключайте TF32.
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, работающий автоматически перед выполнением: свёртка констант, оптимизация раскладки (NCHW против NHWC для cuDNN), слияние операций (remapping), удаление мёртвого кода и другое. Всё включено по умолчанию — трогать нужно только чтобы отключить конкретные оптимизации для отладки. debug_stripper убирает Assert/CheckNumerics ради скорости в продакшене. Оптимизатор раскладки автоматически выбирает NCHW для свёрток cuDNN на GPU, даже если модель задаёт NHWC.
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 onesAutoGraph и control flow
AutoGraph превращает Python if/for/while внутри tf.function в операции графа TF (tf.cond / tf.while_loop), чтобы они эффективно выполнялись на GPU. Циклы по tf.data.Dataset через Python 'for' нормальны — они итерируются во время трассировки. Избегайте if/for, зависящих от ЗНАЧЕНИЙ тензоров (не форм), — это вызывает ретрассировку каждый раз при изменении значения. Для control flow по значениям тензоров во время выполнения используйте tf.cond и tf.while_loop явно или позвольте AutoGraph сделать это (он сделает, но преобразование может быть неочевидным).
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Связанные сниппеты TensorFlow
Copy-paste ready code for common tasks.
Tensor Basics
Create and operate on TensorFlow tensors.
Keras Model
Build models with Sequential and the functional API.
Layers
Use core layers and build a custom one.
Compile and Train
Compile, fit, and evaluate a Keras model.
Custom Training Loop
Step through batches with GradientTape.
Callbacks
Monitor and control training with callbacks.
Save and Load
Persist models in SavedModel and Keras formats.
Data Pipeline
Build efficient input pipelines with tf.data.
Was this helpful?