Install keras windows pip

Keras 3: Deep Learning for Humans

Keras 3 is a multi-backend deep learning framework, with support for JAX, TensorFlow, PyTorch, and OpenVINO (for inference-only).
Effortlessly build and train models for computer vision, natural language processing, audio processing,
timeseries forecasting, recommender systems, etc.

• Accelerated model development: Ship deep learning solutions faster thanks to the high-level UX of Keras
  and the availability of easy-to-debug runtimes like PyTorch or JAX eager execution.
• State-of-the-art performance: By picking the backend that is the fastest for your model architecture (often JAX!),
  leverage speedups ranging from 20% to 350% compared to other frameworks. Benchmark here.
• Datacenter-scale training: Scale confidently from your laptop to large clusters of GPUs or TPUs.

Join nearly three million developers, from burgeoning startups to global enterprises, in harnessing the power of Keras 3.

Installation

Install with pip

Keras 3 is available on PyPI as keras. Note that Keras 2 remains available as the tf-keras package.

1. Install keras:

pip install keras --upgrade

1. Install backend package(s).

To use keras, you should also install the backend of choice: tensorflow, jax, or torch.
Note that tensorflow is required for using certain Keras 3 features: certain preprocessing layers
as well as tf.data pipelines.

Local installation

Minimal installation

Keras 3 is compatible with Linux and MacOS systems. For Windows users, we recommend using WSL2 to run Keras.
To install a local development version:

1. Install dependencies:

pip install -r requirements.txt

1. Run installation command from the root directory.

python pip_build.py --install

1. Run API generation script when creating PRs that update keras_export public APIs:

./shell/api_gen.sh

Adding GPU support

The requirements.txt file will install a CPU-only version of TensorFlow, JAX, and PyTorch. For GPU support, we also
provide a separate requirements-{backend}-cuda.txt for TensorFlow, JAX, and PyTorch. These install all CUDA
dependencies via pip and expect a NVIDIA driver to be pre-installed. We recommend a clean python environment for each
backend to avoid CUDA version mismatches. As an example, here is how to create a Jax GPU environment with conda:

conda create -y -n keras-jax python=3.10
conda activate keras-jax
pip install -r requirements-jax-cuda.txt
python pip_build.py --install

Configuring your backend

You can export the environment variable KERAS_BACKEND or you can edit your local config file at ~/.keras/keras.json
to configure your backend. Available backend options are: "tensorflow", "jax", "torch", "openvino". Example:

export KERAS_BACKEND="jax"

In Colab, you can do:

import os
os.environ["KERAS_BACKEND"] = "jax"

import keras

Note: The backend must be configured before importing keras, and the backend cannot be changed after
the package has been imported.

Note: The OpenVINO backend is an inference-only backend, meaning it is designed only for running model
predictions using model.predict() method.
To use openvino backend, install the required dependencies from the requirements-openvino.txt file.

Backwards compatibility

Keras 3 is intended to work as a drop-in replacement for tf.keras (when using the TensorFlow backend). Just take your
existing tf.keras code, make sure that your calls to model.save() are using the up-to-date .keras format, and you’re
done.

If your tf.keras model does not include custom components, you can start running it on top of JAX or PyTorch immediately.

If it does include custom components (e.g. custom layers or a custom train_step()), it is usually possible to convert it
to a backend-agnostic implementation in just a few minutes.

In addition, Keras models can consume datasets in any format, regardless of the backend you’re using:
you can train your models with your existing tf.data.Dataset pipelines or PyTorch DataLoaders.

Why use Keras 3?

• Run your high-level Keras workflows on top of any framework — benefiting at will from the advantages of each framework,
  e.g. the scalability and performance of JAX or the production ecosystem options of TensorFlow.
• Write custom components (e.g. layers, models, metrics) that you can use in low-level workflows in any framework.
  • You can take a Keras model and train it in a training loop written from scratch in native TF, JAX, or PyTorch.
  • You can take a Keras model and use it as part of a PyTorch-native Module or as part of a JAX-native model function.
• Make your ML code future-proof by avoiding framework lock-in.
• As a PyTorch user: get access to power and usability of Keras, at last!
• As a JAX user: get access to a fully-featured, battle-tested, well-documented modeling and training library.

Read more in the Keras 3 release announcement.

Last Updated :
21 Sep, 2021

Keras is a neural Network python library primarily used for image classification. In this article we will look into the process of installing Keras on a Windows machine.

Pre-requisites:

The only thing that you need for installing Numpy on Windows are:

• Python 
• PIP or Conda (depending upon user preference)

Keras Dependencies:

The Keras library has the following dependencies:

• Numpy
• Pandas
• Scikit-learn
• Matplotlib
• Scipy
• Seaborn

Note: All these dependencies can be manually installed. But if you are missing one or all of these dependencies, they get installed when you run the command to install Keras automatically.

Installing Keras Library on Windows using Conda:

If you want the installation to be done through conda,  open up the Anaconda Powershell Prompt and use the below command:

conda install -c conda-forge keras

Type y for yes when prompted.

You will get a similar message once the installation is complete:

Картинка с сайта: www.geeksforgeeks.org

Make sure you follow the best practices for installation using conda as:

• Use an environment for installation rather than in the base environment using the below command:

conda create -n my-env
conda activate my-env

Note: If your preferred method of installation is conda-forge, use the below command:

conda config --env --add channels conda-forge

Verifying Keras Installation on Windows using Conda:

To verify if Keras library has been successfully installed in your system run the below command in Anaconda Powershell Prompt:

conda list keras

You’ll get the below message if the installation is complete:

Картинка с сайта: www.geeksforgeeks.org

Installing Keras Library on Windows using PIP:

Users who prefer to use pip can use the below command to install the Keras library on Windows:

pip install keras

You will get a similar message once the installation is complete:

Картинка с сайта: www.geeksforgeeks.org

Verifying Keras Installation on Windows using PIP:

To verify if Keras library has been successfully installed in your system run the below command in your command prompt:

python -m pip show keras

You’ll get the below message if the installation is complete:

Картинка с сайта: www.geeksforgeeks.org

Введение

Keras — это популярная высокоуровневая библиотека для создания и обучения нейронных сетей на языке программирования Python. Она предоставляет удобный интерфейс для работы с TensorFlow, Theano и другими бэкэндами. Благодаря своей простоте и гибкости, Keras стала выбором многих исследователей и разработчиков в области машинного обучения и глубокого обучения. В этой статье мы рассмотрим, как установить Keras на Python, чтобы вы могли начать создавать свои модели машинного обучения. Мы подробно разберем все этапы установки и дадим полезные советы для начинающих.

Картинка с сайта: sky.pro

Предварительные требования

Перед тем как приступить к установке Keras, убедитесь, что у вас установлены следующие компоненты:

1. Python: Рекомендуется использовать Python версии 3.6 или выше. Вы можете скачать Python с официального сайта python.org. Python является основным языком программирования для многих библиотек машинного обучения, включая Keras.
2. pip: Это пакетный менеджер для Python, который позволяет устанавливать и управлять библиотеками. Обычно он устанавливается вместе с Python, но вы можете проверить его наличие, выполнив команду pip --version в командной строке. Если pip не установлен, вы можете установить его, следуя инструкциям на официальном сайте Python.

Если у вас еще не установлен Python, следуйте инструкциям на официальном сайте для его установки. После этого убедитесь, что pip также установлен. Это важный шаг, так как pip будет использоваться для установки Keras и других необходимых библиотек.

Установка Keras с помощью pip

Теперь, когда у вас есть все необходимые компоненты, мы можем приступить к установке Keras. Для этого выполните следующие шаги:

1. Откройте командную строку: В Windows это можно сделать, нажав клавиши Win + R, введя cmd и нажав Enter. В macOS и Linux откройте терминал. Командная строка или терминал — это интерфейс, через который вы будете вводить команды для установки библиотек.

2. Установите Keras: Введите следующую команду и нажмите Enter:

   Эта команда загрузит и установит последнюю версию Keras и все необходимые зависимости. Убедитесь, что у вас есть подключение к интернету, так как pip будет загружать пакеты из репозитория PyPI.

3. Установите TensorFlow: Keras использует TensorFlow в качестве бэкэнда. Если у вас еще не установлен TensorFlow, выполните следующую команду:

   TensorFlow — это мощная библиотека для машинного обучения, которая предоставляет множество инструментов для создания и обучения моделей. Если вы хотите использовать GPU для ускорения вычислений, установите версию TensorFlow с поддержкой GPU:Использование GPU может значительно ускорить обучение моделей, особенно если вы работаете с большими наборами данных или сложными архитектурами нейронных сетей.

Проверка установки

После завершения установки Keras и TensorFlow, важно убедиться, что все работает корректно. Для этого выполните следующие шаги:

1. Откройте Python интерпретатор: В командной строке введите python и нажмите Enter. Это запустит интерактивную среду Python, где вы сможете вводить команды и проверять работу библиотек.

2. Импортируйте Keras: Введите следующий код и нажмите Enter:

   Если установка прошла успешно, вы не увидите никаких ошибок. В противном случае, проверьте сообщения об ошибках и убедитесь, что все зависимости установлены правильно. Ошибки могут возникнуть из-за несовместимости версий или отсутствия необходимых библиотек.

3. Проверьте версию Keras: Введите следующий код, чтобы узнать установленную версию Keras:

   Это поможет убедиться, что у вас установлена последняя версия библиотеки. Знание версии Keras может быть полезным, если вы столкнетесь с проблемами совместимости или будете следовать учебным материалам, которые требуют определенной версии библиотеки.

Заключение и полезные ресурсы

Теперь вы знаете, как установить Keras на Python и проверить корректность установки. Это первый шаг к созданию мощных моделей машинного обучения. Keras предоставляет удобный и интуитивно понятный интерфейс для создания нейронных сетей, что делает его отличным выбором для начинающих. Вот несколько полезных ресурсов, которые помогут вам в дальнейшем изучении Keras:

• Официальная документация Keras: Здесь вы найдете подробные руководства и примеры использования Keras.
• Руководство по TensorFlow: TensorFlow является основным бэкэндом для Keras, и знание его возможностей поможет вам лучше понимать, как работает Keras.
• Курс по глубокому обучению от Coursera: Этот курс охватывает основные концепции глубокого обучения и использование Keras для создания моделей.

Эти ресурсы помогут вам углубить свои знания и начать создавать собственные проекты с использованием Keras и TensorFlow. Изучение Keras и TensorFlow откроет перед вами множество возможностей в области машинного обучения и глубокого обучения. Удачи в изучении!

Читайте также

Привет, Хабр! Мы уже говорили про Theano и Tensorflow (а также много про что еще), а сегодня сегодня пришло время поговорить про Keras.

Изначально Keras вырос как удобная надстройка над Theano. Отсюда и его греческое имя — κέρας, что значит «рог» по-гречески, что, в свою очередь, является отсылкой к Одиссее Гомера. Хотя, с тех пор утекло много воды, и Keras стал сначала поддерживать Tensorflow, а потом и вовсе стал его частью. Впрочем, наш рассказ будет посвящен не сложной судьбе этого фреймворка, а его возможностям. Если вам интересно, добро пожаловать под кат.

Начать стоит от печки, то есть с оглавления.

• [Установка]
• [Бэкенды]
• [Практический пример]
  • [Данные]
  • [Модель]
    • [Sequential API]
    • [Functional API]
  • [Подготовка модели к работе]
  • [Custom loss]
  • [Обучение и тестирование]
  • [Callbacks]
    • [Tensorboard]
• [Продвинутые графы]
• [Заключение]

Установка

Установка Keras чрезвычайно проста, т.к. он является обычным питоновским пакетом:

pip install keras

Теперь мы можем приступить к его разбору, но сначала поговорим про бэкенды.

ВНИМАНИЕ: Чтобы работать с Keras, у вас уже должен быть установлен хотя бы один из фреймворков — Theano или Tensorflow.

Бэкенды

Бэкенды — это то, из-за чего Keras стал известен и популярен (помимо прочих достоинств, которые мы разберем ниже). Keras позволяет использовать в качестве бэкенда разные другие фреймворки. При этом написанный вами код будет исполняться независимо от используемого бэкенда. Начиналась разработка, как мы уже говорили, с Theano, но со временем добавился Tensorflow. Сейчас Keras по умолчанию работает именно с ним, но если вы хотите использовать Theano, то есть два варианта, как это сделать:

1. Отредактировать файл конфигурации keras.json, который лежит по пути $HOME/.keras/keras.json (или %USERPROFILE%\.keras\keras.json в случае операционных систем семейства Windows). Нам нужно поле backend:

   {
   "image_data_format": "channels_last",
   "epsilon": 1e-07,
   "floatx": "float32",
   "backend": "theano"
   }

2. Второй путь — это задать переменную окружения KERAS_BACKEND, например, так:

   KERAS_BACKEND=theano python -c "from keras import backend"
   Using Theano backend.

Стоит отметить, что сейчас ведется работа по написанию биндингов для CNTK от Microsoft, так что через некоторое время появится еще один доступный бэкенд. Следить за этим можно здесь.

Также существует MXNet Keras backend, который пока не обладает всей функциональностью, но если вы используете MXNet, вы можете обратить внимание на такую возможность.

Еще существует интересный проект Keras.js, дающий возможность запускать натренированные модели Keras из браузера на машинах, где есть GPU.

Так что бэкенды Keras ширятся и со временем захватят мир! (Но это неточно.)

Практический пример

В прошлых статьях много внимания было уделено описанию работы классических моделей машинного обучения на описываемых фреймворках. Кажется, теперь мы можем взять в качестве примера [не очень] глубокую нейронную сеть.

Данные

Обучение любой модели в машинном обучении начинается с данных. Keras содержит внутри несколько обучающих датасетов, но они уже приведены в удобную для работы форму и не позволяют показать всю мощь Keras. Поэтому мы возьмем более сырой датасет. Это будет датасет 20 newsgroups — 20 тысяч новостных сообщений из групп Usenet (это такая система обмена почтой родом из 1990-х, родственная FIDO, который, может быть, чуть лучше знаком читателю) примерно поровну распределенных по 20 категориям. Мы будем учить нашу сеть правильно распределять сообщения по этим новостным группам.

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
newsgroups_test = fetch_20newsgroups(subset='test')

Вот пример содержания документа из обучающей выборки:

Препроцессинг

Keras содержит в себе инструменты для удобного препроцессинга текстов, картинок и временных рядов, иными словами, самых распространенных типов данных. Сегодня мы работаем с текстами, поэтому нам нужно разбить их на токены и привести в матричную форму.

tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(newsgroups_train["data"])  # теперь токенизатор знает словарь для этого корпуса текстов

x_train = tokenizer.texts_to_matrix(newsgroups_train["data"], mode='binary')
x_test = tokenizer.texts_to_matrix(newsgroups_test["data"], mode='binary')

На выходе у нас получились бинарные матрицы вот таких размеров:

x_train shape: (11314, 1000)
x_test shape: (7532, 1000)

Первое число — количество документов в выборке, а второе — размер нашего словаря (одна тысяча в этом примере).

Еще нам понадобится преобразовать метки классов к матричному виду для обучения с помощью кросс-энтропии. Для этого мы переведем номер класса в так называемый one-hot вектор, т.е. вектор, состоящий из нулей и одной единицы:

y_train = keras.utils.to_categorical(newsgroups_train["target"], num_classes)
y_test = keras.utils.to_categorical(newsgroups_test["target"], num_classes)

На выходе получим также бинарные матрицы вот таких размеров:

y_train shape: (11314, 20)
y_test shape: (7532, 20)

Как мы видим, размеры этих матриц частично совпадают с матрицами данных (по первой координате — числу документов в обучающей и тестовой выборках), а частично — нет. По второй координате у нас стоит число классов (20, как следует из названия датасета).

Все, теперь мы готовы учить нашу сеть классифицировать новости!

Модель

Модель в Keras можно описать двумя основными способами:

Sequential API

Первый — последовательное описание модели, например, вот так:

model = Sequential()
model.add(Dense(512, input_shape=(max_words,)))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))

или вот так:

model = Sequential([
          Dense(512, input_shape=(max_words,)),
          Activation('relu'),
          Dropout(0.5),
          Dense(num_classes),
          Activation('softmax')
        ])

Functional API

Некоторое время назад появилась возможность использовать функциональное API для создания модели — второй способ:

a = Input(shape=(max_words,))
b = Dense(512)(a)
b = Activation('relu')(b)
b = Dropout(0.5)(b)
b = Dense(num_classes)(b)
b = Activation('softmax')(b)
model = Model(inputs=a, outputs=b)

Принципиального отличия между способами нет, выбирайте, какой вам больше по душе.
Класс Model (и унаследованный от него Sequential) имеет удобный интерфейс, позволяющий посмотреть, какие слои входят в модель — model.layers, входы — model.inputs, и выходы — model.outputs.

Также очень удобный метод отображения и сохранения модели — model.to_yaml.

backend: tensorflow
class_name: Model
config:
  input_layers:
  - [input_4, 0, 0]
  layers:
  - class_name: InputLayer
    config:
      batch_input_shape: !!python/tuple [null, 1000]
      dtype: float32
      name: input_4
      sparse: false
    inbound_nodes: []
    name: input_4
  - class_name: Dense
    config:
      activation: linear
      activity_regularizer: null
      bias_constraint: null
      bias_initializer:
        class_name: Zeros
        config: {}
      bias_regularizer: null
      kernel_constraint: null
      kernel_initializer:
        class_name: VarianceScaling
        config: {distribution: uniform, mode: fan_avg, scale: 1.0, seed: null}
      kernel_regularizer: null
      name: dense_10
      trainable: true
      units: 512
      use_bias: true
    inbound_nodes:
    - - - input_4
        - 0
        - 0
        - {}
    name: dense_10
  - class_name: Activation
    config: {activation: relu, name: activation_9, trainable: true}
    inbound_nodes:
    - - - dense_10
        - 0
        - 0
        - {}
    name: activation_9
  - class_name: Dropout
    config: {name: dropout_5, rate: 0.5, trainable: true}
    inbound_nodes:
    - - - activation_9
        - 0
        - 0
        - {}
    name: dropout_5
  - class_name: Dense
    config:
      activation: linear
      activity_regularizer: null
      bias_constraint: null
      bias_initializer:
        class_name: Zeros
        config: {}
      bias_regularizer: null
      kernel_constraint: null
      kernel_initializer:
        class_name: VarianceScaling
        config: {distribution: uniform, mode: fan_avg, scale: 1.0, seed: null}
      kernel_regularizer: null
      name: dense_11
      trainable: true
      units: !!python/object/apply:numpy.core.multiarray.scalar
      - !!python/object/apply:numpy.dtype
        args: [i8, 0, 1]
        state: !!python/tuple [3, <, null, null, null, -1, -1, 0]
      - !!binary |
        FAAAAAAAAAA=
      use_bias: true
    inbound_nodes:
    - - - dropout_5
        - 0
        - 0
        - {}
    name: dense_11
  - class_name: Activation
    config: {activation: softmax, name: activation_10, trainable: true}
    inbound_nodes:
    - - - dense_11
        - 0
        - 0
        - {}
    name: activation_10
  name: model_1
  output_layers:
  - [activation_10, 0, 0]
keras_version: 2.0.2

Это позволяет сохранять модели в человеко-читаемом виде, а также инстанциировать модели из такого описания:

from keras.models import model_from_yaml

yaml_string = model.to_yaml()
model = model_from_yaml(yaml_string)

Важно отметить, что модель, сохраненная в текстовом виде (кстати, возможно сохранение также и в JSON) не содержит весов. Для сохранения и загрузки весов используйте функции save_weights и load_weights соответственно.

Визуализация модели

Нельзя обойти стороной визуализацию. Keras имеет встроенную визуализацию для моделей:

from keras.utils import plot_model
plot_model(model, to_file='model.png', show_shapes=True)

Этот код сохранит под именем model.png вот такую картинку:

Здесь мы дополнительно отобразили размеры входов и выходов для слоев. None, идущий первым в кортеже размеров — это размерность батча. Т.к. стоит None, то батч может быть произвольным.

Если вы захотите отобразить ее в jupyter-ноутбуке, вам нужен немного другой код:

from IPython.display import SVG
from keras.utils.vis_utils import model_to_dot

SVG(model_to_dot(model, show_shapes=True).create(prog='dot', format='svg'))

Важно отметить, что для визуализации нужен пакет graphviz, а также питоновский пакет pydot. Есть тонкий момент, что для корректной работы визуализации пакет pydot из репозитория не пойдет, нужно взять его обновленную версию pydot-ng.

pip install pydot-ng

Пакет graphviz в Ubuntu ставится так (в других дистрибутивах Linux аналогично):

apt install graphviz

На MacOS (используя систему пакетов HomeBrew):

brew install graphviz

Инструкцию установки на Windows можно посмотреть здесь.

Подготовка модели к работе

Итак, мы сформировали нашу модель. Теперь нужно подготовить ее к работе:

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

Что означают параметры функции compile? loss — это функция ошибки, в нашем случае — это перекрестная энтропия, именно для нее мы подготавливали наши метки в виде матриц; optimizer — используемый оптимизатор, здесь мог бы быть обычный стохастический градиентный спуск, но Adam показывает лучшую сходимость на этой задаче; metrics — метрики, по которым считается качество модели, в нашем случае — это точность (accuracy), то есть доля верно угаданных ответов.

Custom loss

Несмотря на то, что Keras содержит большинство популярных функций ошибки, для вашей задачи может потребоваться что-то уникальное. Чтобы сделать свой собственный loss, нужно немного: просто определить функцию, принимающую векторы правильных и предсказанных ответов и выдающую одно число на выход. Для тренировки сделаем свою функцию расчета перекрестной энтропии. Чтобы она чем-то отличалась, введем так называемый clipping — обрезание значений вектора сверху и снизу. Да, еще важное замечание: нестандартный loss может быть необходимо описывать в терминах нижележащего фреймворка, но мы можем обойтись средствами Keras.

from keras import backend as K

epsilon = 1.0e-9
def custom_objective(y_true, y_pred):
    '''Yet another cross-entropy'''
    y_pred = K.clip(y_pred, epsilon, 1.0 - epsilon)
    y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
    cce = categorical_crossentropy(y_pred, y_true)
    return cce

Здесь y_true и y_pred — тензоры из Tensorflow, поэтому для их обработки используются функции Tensorflow.

Для использования другой функции потерь достаточно изменить значения параметра loss функции compile, передав туда объект нашей функции потерь (в питоне функции — тоже объекты, хотя это уже совсем другая история):

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

Обучение и тестирование

Наконец, пришло время для обучения модели:

history = model.fit(x_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_split=0.1)

Метод fit делает именно это. Он принимает на вход обучающую выборку вместе с метками — x_train и y_train, размером батча batch_size, который ограничивает количество примеров, подаваемых за раз, количеством эпох для обучения epochs (одна эпоха — это один раз полностью пройденная моделью обучающая выборка), а также тем, какую долю обучающей выборки отдать под валидацию — validation_split.

Возвращает этот метод history — это история ошибок на каждом шаге обучения.

И наконец, тестирование. Метод evaluate получает на вход тестовую выборку вместе с метками для нее. Метрика была задана еще при подготовке к работе, так что больше ничего не нужно. (Но мы укажем еще размер батча).

score = model.evaluate(x_test, y_test, batch_size=batch_size)

Callbacks

Нужно также сказать несколько слов о такой важной особенности Keras, как колбеки. Через них реализовано много полезной функциональности. Например, если вы тренируете сеть в течение очень долгого времени, вам нужно понять, когда пора остановиться, если ошибка на вашем датасете перестала уменьшаться. По-английски описываемая функциональность называется «early stopping» («ранняя остановка»). Посмотрим, как мы можем применить его при обучении нашей сети:

from keras.callbacks import EarlyStopping  
early_stopping=EarlyStopping(monitor='value_loss')  

history = model.fit(x_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_split=0.1,
                    callbacks=[early_stopping])

Проведите эксперимент и проверьте, как быстро сработает early stopping в нашем примере?

Tensorboard

Еще в качестве колбека можно использовать сохранение логов в формате, удобном для Tensorboard (о нем разговор был в статье про Tensorflow, вкратце — это специальная утилита для обработки и визуализации информации из логов Tensorflow).

from keras.callbacks import TensorBoard  
tensorboard=TensorBoard(log_dir='./logs', write_graph=True)

history = model.fit(x_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_split=0.1,
                    callbacks=[tensorboard])

После того, как обучение закончится (или даже в процессе!), вы можете запустить Tensorboard, указав абсолютный путь к директории с логами:

tensorboard --logdir=/path/to/logs

Там можно посмотреть, например, как менялась целевая метрика на валидационной выборке:

Картинка с сайта: habr.com

(Кстати, тут можно заметить, что наша сеть переобучается.)

Продвинутые графы

Теперь рассмотрим построение чуть более сложного графа вычислений. У нейросети может быть множество входов и выходов, входные данные могут преобразовываться разнообразными отображениями. Для переиспользования частей сложных графов (в частности, для transfer learning) имеет смысл описывать модель в модульном стиле, позволяющем удобным образом извлекать, сохранять и применять к новым входным данным куски модели.

Наиболее удобно описывать модель, смешивая оба способа — Functional API и Sequential API, описанные ранее.

Рассмотрим этот подход на примере модели Siamese Network. Схожие модели активно используются на практике для получения векторных представлений, обладающих полезными свойствами. Например, подобная модель может быть использована для того, чтобы выучить такое отображение фотографий лиц в вектор, что вектора для похожих лиц будут близко друг к другу. В частности, этим пользуются приложения поиска по изображениям, такие как FindFace.

Иллюстрацию модели можно видеть на диаграмме:

Картинка с сайта: habr.com

Здесь функция G превращает входную картинку в вектор, после чего вычисляется расстояние между векторами для пары картинок. Если картинки из одного класса, расстояние нужно минимизировать, если из разных — максимизировать.

После того, как такая нейросеть будет обучена, мы сможем представить произвольную картинку в виде вектора G(x) и использовать это представление либо для поиска ближайших изображений, либо как вектор признаков для других алгоритмов машинного обучения.

Будем описывать модель в коде соответствующим образом, максимально упростив извлечение и переиспользование частей нейросети.

Сначала определим на Keras функцию, отображающую входной вектор.

def create_base_network(input_dim):
    seq = Sequential()
    seq.add(Dense(128, input_shape=(input_dim,), activation='relu'))
    seq.add(Dropout(0.1))
    seq.add(Dense(128, activation='relu'))
    seq.add(Dropout(0.1))
    seq.add(Dense(128, activation='relu'))
    return seq

Обратите внимание: мы описали модель с помощью Sequential API, однако обернули ее создание в функцию. Теперь мы можем создать такую модель, вызвав эту функцию, и применить ее с помощью Functional API ко входным данным:

base_network = create_base_network(input_dim)

input_a = Input(shape=(input_dim,))
input_b = Input(shape=(input_dim,))

processed_a = base_network(input_a)
processed_b = base_network(input_b)

Теперь в переменных processed_a и processed_b лежат векторные представления, полученные путем применения сети, определенной ранее, к входным данным.

Нужно посчитать между ними расстояния. Для этого в Keras предусмотрена функция-обертка Lambda, представляющая любое выражение как слой (Layer). Не забудьте, что мы обрабатываем данные в батчах, так что у всех тензоров всегда есть дополнительная размерность, отвечающая за размер батча.

from keras import backend as K

def euclidean_distance(vects):
    x, y = vects
    return K.sqrt(K.sum(K.square(x - y), axis=1, keepdims=True))

distance = Lambda(euclidean_distance)([processed_a, processed_b])

Отлично, мы получили расстояние между внутренними представлениями, теперь осталось собрать входы и расстояние в одну модель.

model = Model([input_a, input_b], distance)

Благодаря модульной структуре мы можем использовать base_network отдельно, что особенно полезно после обучения модели. Как это можно сделать? Посмотрим на слои нашей модели:

>>> model.layers
[<keras.engine.topology.InputLayer object at 0x7f238fdacb38>, <keras.engine.topology.InputLayer object at 0x7f238fdc34a8>, <keras.models.Sequential object at 0x7f239127c3c8>, <keras.layers.core.Lambda object at 0x7f238fddc4a8>]

Видим третий объект в списке типа models.Sequential. Это и есть модель, отображающая входную картинку в вектор. Чтобы ее извлечь и использовать как полноценную модель (можно дообучать, валидировать, встраивать в другой граф) достаточно всего лишь вытащить ее из списка слоев:

>>> embedding_model = model.layers[2]
>>> embedding_model.layers
[<keras.layers.core.Dense object at 0x7f23c4e557f0>, <keras.layers.core.Dropout object at 0x7f238fe97908>, <keras.layers.core.Dense object at 0x7f238fe44898>, <keras.layers.core.Dropout object at 0x7f238fe449e8>, <keras.layers.core.Dense object at 0x7f238fe01f60>]

Например для уже обученной на данных MNIST сиамской сети с размерностью на выходе base_model, равной двум, можно визуализировать векторные представления следующим образом:

Загрузим данные и приведем картинки размера 28x28 к плоским векторам.

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_test = x_test.reshape(10000, 784)

Отобразим картинки с помощью извлеченной ранее модели:

embeddings = embedding_model.predict(x_test)

Теперь в embeddings лежат двумерные вектора, их можно изобразить на плоскости:

Картинка с сайта: habr.com

Полноценный пример сиамской сети можно увидеть здесь.

Заключение

Вот и все, мы сделали первые модели на Keras! Надеемся, что предоставляемые им возможности заинтересовали вас, так что вы будете его использовать в своей работе.

Пришло время обсудить плюсы и минусы Keras. К очевидным плюсам можно отнести простоту создания моделей, которая выливается в высокую скорость прототипирования. Например, авторы недавней статьи про спутники использовали именно Keras. В целом этот фреймворк становится все более и более популярным:

Картинка с сайта: habr.com

Keras за год догнал Torch, который разрабатывается уже 5 лет, судя по упоминаниям в научных статьях. Кажется, своей цели — простоты использования — Франсуа Шолле (François Chollet, автор Keras) добился. Более того, его инициатива не осталась незамеченной: буквально через несколько месяцев разработки компания Google пригласила его заниматься этим в команде, разрабатывающей Tensorflow. А также с версии Tensorflow 1.2 Keras будет включен в состав TF (tf.keras).

Также надо сказать пару слов о недостатках. К сожалению, идея Keras о универсальности кода выполняется не всегда: Keras 2.0 поломал совместимость с первой версией, некоторые функции стали называться по-другому, некоторые переехали, в общем, история похожа на второй и третий python. Отличием является то, что в случае Keras была выбрана только вторая версия для развития. Также код Keras работает на Tensorflow пока медленнее, чем на Theano (хотя для нативного кода фреймворки, как минимум, сравнимы).

В целом, можно порекомендовать Keras к использованию, когда вам нужно быстро составить и протестировать сеть для решения конкретной задачи. Но если вам нужны какие-то сложные вещи, вроде нестандартного слоя или распараллеливания кода на несколько GPU, то лучше (а подчас просто неизбежно) использовать нижележащий фреймворк.

Практически весь код из статьи есть в виде одного ноутбука здесь. Также очень рекомендуем вам документацию по Keras: keras.io, а так же официальные примеры, на которых эта статья во многом основана.

Пост написан в сотрудничестве с Wordbearer.