Keras

1. Что такое Keras

Keras — это способ строить модели: Sequential (друг за другом), Functional API (разветвлённые графы) и Model Subclassing (полный контроль логики). Что отличает от чистого TensorFlow — простота и декларативность.

2. Установка

pip install keras
# или вместе с TensorFlow:
pip install tensorflow

from tensorflow import keras
from tensorflow.keras import layers

3. Sequential — стек слоёв

model = keras.Sequential([
    layers.Input(shape=(4,)),
    layers.Dense(16, activation='relu'),
    layers.Dense(8, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])
model.summary()

Sigmoid на выходе — вероятность для бинарной классификации; softmax — для многих классов.

4. Слои: что выбрать

5. Компиляция

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

Оптимизаторы: Adam (всегда хорош), SGD (нужна настройка lr), RMSprop. Функции потерь — в соответствии с задачей.

6. Обучение

history = model.fit(
    X_train, y_train,
    batch_size=32,
    epochs=20,
    validation_split=0.2,
    verbose=1
)

Результат history.history — словарь списков лосса и метрик по эпохам.

7. Колбэки

callbacks = [
    keras.callbacks.EarlyStopping(monitor='val_loss', patience=3),
    keras.callbacks.ModelCheckpoint('best.keras',
        save_best_only=True, monitor='val_accuracy'),
    keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=2)
]
model.fit(X_train, y_train, epochs=50,
          validation_split=0.2, callbacks=callbacks)

8. Оценка и предсказание

model.evaluate(X_test, y_test)      # loss, метрики
prob = model.predict(X_test)        # вероятности
y_pred = (prob > 0.5).astype('int32')

9. Functional API

inputs = keras.Input(shape=(28, 28, 1))
x = layers.Conv2D(32, 3, activation='relu')(inputs)
x = layers.MaxPooling2D(2)(x)
x = layers.Flatten()(x)
out = layers.Dense(10, activation='softmax')(x)

model = keras.Model(inputs, out)

Functional позволяет ветвить и объединять пути — многоуровневые входы, множественные выходы, residual-связи.

10. Лучшие практики

• Нормализуй признаки (стандартизация, как в Scikit-Learn).
• Следи за разрывом train vs val лосса — сигнал переобучения.
• Маленькие данные → начинай с простой сети, увеличивай только при необходимости.

11. Регуляризация против переобучения

Сложная сеть легко запоминает обучающий шум. Стандартные приёмы — Dropout, регуляризация весов и нормализация слоёв:

model = keras.Sequential([
    keras.layers.Dense(64, activation='relu',
                       kernel_regularizer='l2'),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(1)
])

• Dropout случайно «выключает» нейроны и заставляет сеть обобщать.
• L1/L2 штрафуют большие веса — L1 разреживает, L2 сглаживает.
• BatchNormalization стабилизирует градиенты и часто ускоряет сходимость.

12. Подача данных: tf.data и аугментация

Для больших выборок данные подают через tf.data.Dataset — потоковые пайплайны без загрузки всего в память:

dataset = tf.data.Dataset.from_tensor_slices((X, y))
dataset = dataset.shuffle(1024).batch(32).prefetch(1)
model.fit(dataset, epochs=10)

Аугментация расширяет обучающую выборку изображений случайными сдвигами, поворотами и отражениями, снижая переобучение «бесплатно»:

aug = keras.Sequential([
    keras.layers.RandomFlip("horizontal"),
    keras.layers.RandomRotation(0.1),
    keras.layers.RandomZoom(0.1)
])
model = keras.Sequential([aug, base_model, head])

13. Сохранение и загрузка моделей

Формат .keras сохраняет веса, архитектуру и оптимизатор — модель можно дообучать после восстановления:

model.save("model.keras")
restored = keras.models.load_model("model.keras")
model.export("saved_model")   # SavedModel для TF Serving

14. Трансферное обучение

Вместо обучения с нуля переносят признаки предобученной сети (ImageNet) и дообучают только голову:

base = keras.applications.ResNet50(
    weights='imagenet', include_top=False, input_shape=(224, 224, 3))
base.trainable = False
model = keras.Sequential([base, keras.layers.GlobalAveragePooling2D(),
                          keras.layers.Dense(10, activation='softmax')])

Сначала фиксируют базу и учат голову, затем размораживают верхние слои и дообучают на малой скорости для тонкой настройки.

15. Пользовательские слои и модели

Стандартный стек не покрывает всех задач. Keras позволяет написать собственный слой через наследование от keras.layers.Layer — удобно для кастомного внимания, нормализаций или уникальных активаций:

class Scaling(Layer):
    def __init__(self, factor=2.0):
        super().__init__()
        self.factor = factor
    def call(self, inputs):
        return inputs * self.factor

• build() создаёт веса по размерам входа, call() — само преобразование, trainable_variables — параметры обучения.
• Субклассированные модели (наследование от Model) гибче Sequential, но хуже сериализуются — вернись к нему при сложной архитектуре.
• Пользовательские слои можно комбинировать в Functional API и сохранять через model.save() с регистрацией класса.

16. KerasCV и KerasNLP: готовые пайплайны

Для типовых задач — классификация изображений, детекция объектов, тексты — не обязательно строить сеть из атомов. Отдельные библиотеки дают претрейн-модели и аугментацию «из коробки»:

pip install keras-cv keras-nlp

import keras_nlp
classifier = keras_nlp.models.BertClassifier.from_preset("bert_base_uncased")

• KerasCV: модели YOLOv8, RetinaNet, трансформеры для изображений, датасеты и RandomAugment.
• KerasNLP: предобученные трансформеры, токенизаторы, задачи классификации и генерации текста в пару строк.
• Пресеты автоматически качают веса и конфигурацию: остаётся смешать с обычными слоями Sequential.

17. Подбор гиперпараметров: Keras Tuner

Качество модели зависит от скорости обучения, числа нейронов, dropout. Перебирать руками долго, поэтому подключи keras-tuner и опиши пространство параметров:

def build_model(hp):
    units = hp.Int("units", 32, 256, step=32)
    return Sequential([Dense(units, activation="relu"), Dense(1)])

tuner = keras_tuner.RandomSearch(build_model, objective="val_loss", max_trials=30)

• hp.Int, hp.Float, hp.Choice задают диапазоны; tuner.search() запускает перебор.
• Режимы RandomSearch, Hyperband, BayesianOptimization отличаются стратегией и скоростью сходимости.
• Перебор даёт метрики по каждой конфигурации: видно не только лучшее, но и тренды параметров.

18. Экспорт в продакшен и квантование

Обученная модель живёт в разных окружениях: сервер, браузер, мобильное приложение. Экспорт начинается с model.save() в формат SavedModel, а дальше — трансформации:

model.save("app_model")                # SavedModel
converter = tf.lite.TFLiteConverter.from_saved_model("app_model")
model.tflite = converter.convert()
quantized = converter.quantize("int8") # 8-битное квантование

• TFLite — для мобильных и Edge: сжимает модель, но требует калибровочных данных для квантования.
• TensorRT и ONNX — для серверного инференса: оптимизация графа под GPU и совместимость с другими фреймворками.
• В проде следи за лог-схемой версионирования: ModelVersion в TensorFlow Serving или тегами в реестре моделей.

19. Кастомные циклы обучения

Иногда fit недостаточно: нужны собственные шаги, перемешивание, EMA-обновления весов или нестандартные градиенты. Keras позволяет переопределить внутренний цикл.

class MyModel(Model):
    def train_step(self, data):
        x, y = data
        with tf.GradientTape() as tape:
            loss = self.compiled_loss(y, self(x, training=True))
        self.optimizer.apply_gradients(
            zip(tape.gradient(loss, self.trainable_variables),
                self.trainable_variables))
        return {"loss": loss}

• Переопределяйте train_step/test_step — так fit останется совместимым с колбэками.
• Всегда передавайте корректные флаги training=True/False для batch-norm и dropout.
• Дополнительные действия (например, EMA-обновления) добавляйте в on_batch_end.

20. Несбалансированные классы

Дисбаланс классов заставляет модель «заучивать» большинство с нулевым recall по редкому классу. Лечится на трёх уровнях: данные, веса, функция потерь.

model.fit(x, y, class_weight={0: 1.0, 1: 9.0})

• Апсемплинг меньшинства и аугментация — простой и надёжный способ.
• class_weight работает встроенно и не меняет архитектуру.
• Focal loss уменьшает вклад уверенно распознанных примеров — взвешивание становится адаптивным.
• Оценивайте не accuracy, а precision/recall/F1 по редкому классу.

21. Оценка и анализ ошибок

Метрики на тесте — лишь среднее. Чтобы понять, где модель ошибается, нужны матрица ошибок, калибровка и подбор порога.

from sklearn.metrics import classification_report, confusion_matrix
print(classification_report(y_test, (pred > 0.5).astype(int)))
print(confusion_matrix(y_test, (pred > 0.5).astype(int)))

• Матрица ошибок показывает системные подмены классов.
• Калибровочная кривая (reliability) выявляет переоценку уверенности в вероятностях.
• Порог не обязан быть 0.5: подбирайте его по кривой precision-recall под бизнес-метрику.

22. MLOps: эксперименты и мониторинг

Разработка модели — половина дела. Вторая — управление версиями, реестром моделей и дрейфом данных.

• MLflow или W&B фиксируют гиперпараметры, метрики и артефакты — каждый запуск воспроизводим.
• Реестр моделей хранит версии и статусы: staging, production, архивы.
• Сравнивайте распределение предсказаний и признаков на проде против обучающего набора.

Что дальше

Keras живёт внутри TensorFlow, поэтому полноценный пайплайн — в курсе TensorFlow. Гипотезам и динамике — PyTorch.

← Вернуться к курсам