sequential python что это

Боковая панель

НАЧАЛО РАБОТЫ

МОДЕЛИ

ПРЕДОБРАБОТКА

ПРИМЕРЫ

Sequential model: руководство

Модель Sequential представляет собой линейный стек слоев.

Вы может создать модель Sequential, передав список слоев конструктору модели:

Указание размерности входных данных

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

Таким образом, следующие примеры эквивалентны:

Компиляция

Перед обучением модели необходимо настроить сам процесс. Это выполняется с помощью метода compile(). Он получает три аргумента:

# Задача бинарной классификации
model.compile(optimizer=’rmsprop’, loss=’binary_crossentropy’, metrics=[‘accuracy’])

# Среднеквадратичная ошибка регрессии
model.compile(optimizer=’rmsprop’, loss=’mse’)

# Пользовательская метрика
import keras.backend as K
def mean_pred(y_true, y_pred):
return K.mean(y_pred)
model.compile(optimizer=’rmsprop’, loss=’binary_crossentropy’, metrics=[‘accuracy’, mean_pred])

Обучение

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

# Модель с одномерными входными данными и бинарной классификацией

model.add(Dense(32, activation=’relu’, input_dim=100))

# Генерируем случайные данные

import numpy as np

data = np.random.random((1000, 100))

labels = np.random.randint(2, size=(1000, 1))

# Обучаем модель, перебирая данные в пакетах по 32 примера

model.fit(data, labels, epochs=10, batch_size=32)

# Модель с одномерными входными данными и 10 классами

model.add(Dense(32, activation=’relu’, input_dim=100))

# Генерируем случайные данные

import numpy as np

data = np.random.random((1000, 100))

labels = np.random.randint(10, size=(1000, 1))

# Преобразуем метки в OHE (one-hot encoding)

one_hot_labels = keras.utils.to_categorical(labels, num_classes=10)

# Обучаем модель, перебирая данные в пакетах по 32 примера

model.fit(data, one_hot_labels, epochs=10, batch_size=32)

Примеры

Вот несколько примеров, с которых можно начать!

В папке примеров вы также найдете варианты решения задач с реальными наборами данных:

Многослойный персептрон (MLP) для мультиклассовой классификаци (softmax):

import keras

from keras.models import Sequential

from keras.layers import Dense, Dropout, Activation

from keras.optimizers import SGD

# Генерируем случайные данные

import numpy as np

x_train = np.random.random((1000, 20))

y_train = keras.utils.to_categorical(
np.random.randint(10, size=(1000, 1)), num_classes=10)

x_test = np.random.random((100, 20))

y_test = keras.utils.to_categorical(
np.random.randint(10, size=(100, 1)), num_classes=10)

# Dense(64) — это полносвязный слой с 64 скрытыми нейронами.

# в первом слое вы должны указать размерность входных данных:

# здесь, это векторы длинной 20.

model.add(Dense(64, activation=’relu’, input_dim=20))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

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

MLP для бинарной классификации:

import numpy as np

from keras.models import Sequential

from keras.layers import Dense, Dropout

# Генерируем случайные данные

x_train = np.random.random((1000, 20))

y_train = np.random.randint(2, size=(1000, 1))

x_test = np.random.random((100, 20))

y_test = np.random.randint(2, size=(100, 1))

model.add(Dense(64, input_dim=20, activation=’relu’))

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

VGG-подобная сверточная сеть:

import numpy as np

import keras

from keras.models import Sequential

from keras.layers import Dense, Dropout, Flatten

from keras.layers import Conv2D, MaxPooling2D

from keras.optimizers import SGD

# Генерируем случайные данные

x_train = np.random.random((100, 100, 100, 3))

y_train = keras.utils.to_categorical(
np.random.randint(10, size=(100, 1)), num_classes=10)

x_test = np.random.random((20, 100, 100, 3))

y_test = keras.utils.to_categorical(
np.random.randint(10, size=(20, 1)), num_classes=10)

# применим здесь сверточный слой с 32 нейронами и ядром свертки (3, 3)

model.add(Conv2D(32, (3, 3), activation=’relu’,
input_shape=(100, 100, 3)))

model.add(Conv2D(32, (3, 3), activation=’relu’))

model.add(Conv2D(64, (3, 3), activation=’relu’))

model.add(Conv2D(64, (3, 3), activation=’relu’))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

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

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

Классификация последовательностей с помощью LSTM:

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.layers import Embedding

from keras.layers import LSTM

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

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

Классификация последовательностей с помощью одномерной свертки:

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.layers import Embedding

from keras.layers import Conv1D, GlobalAveragePooling1D, MaxPooling1D

model.add(Conv1D(64, 3, activation=’relu’,
input_shape=(seq_length, 100)))

model.add(Conv1D(64, 3, activation=’relu’))

model.add(Conv1D(128, 3, activation=’relu’))

model.add(Conv1D(128, 3, activation=’relu’))

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

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

Классификация последовательностей с помощью LSTM с памятью:

В этой модели мы накладываем 3 слоя LSTM друг на друга, делая модель способной изучать временные представления более высокого уровня.

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

from keras.models import Sequential

from keras.layers import LSTM, Dense

import numpy as np

# ожидаемая размерность входных данных:
# (batch_size, timesteps, data_dim)

model.add(LSTM(32, return_sequences=True,

input_shape=(timesteps, data_dim)))
# возвращает последовательность векторов длинной 32

model.add(LSTM(32, return_sequences=True))

# возвращает последовательность векторов длинной 32

model.add(LSTM(32)) # возвращает одиночный векторов длинной 32

# Генерируем случайные данные

x_train = np.random.random((1000, timesteps, data_dim))

y_train = np.random.random((1000, num_classes))

# Генерируем случайные проверочные данные

x_val = np.random.random((100, timesteps, data_dim))

y_val = np.random.random((100, num_classes))

LSTM с передачей состояния

Рекуррентная модель с состоянием — это модель, для которой внутренней состояние, полученное после обработки очередного пакета данных, повторно используется в качестве начальных состояний для выборок следующей серии. Это позволяет обрабатывать более длинные последовательности.

from keras.models import Sequential

from keras.layers import LSTM, Dense

import numpy as np

# ожидаемая размерность входных данных:
# (batch_size, timesteps, data_dim)

# Обратите внимание, что мы должны указать полную размерность входных

# данных batch_input_shape, так как это сеть с состоянием

# i-тый пример в k-ом пакете является продолжением

# i-того примера в k-1-ом пакете

model.add(LSTM(32, return_sequences=True, stateful=True,

batch_input_shape=(batch_size, timesteps, data_dim)))

model.add(LSTM(32, return_sequences=True, stateful=True))

model.add(LSTM(32, stateful=True))

# Генерируем случайные данные

x_train = np.random.random((batch_size * 10, timesteps, data_dim))

y_train = np.random.random((batch_size * 10, num_classes))

# Генерируем случайные проверочные данные

x_val = np.random.random((batch_size * 3, timesteps, data_dim))

y_val = np.random.random((batch_size * 3, num_classes))

batch_size=batch_size, epochs=5, shuffle=False,

Источник

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

(Подробнее о них также см. официальную документацию https://keras.io/api/models/).

Некоторые из этих классов мы с вами уже использовали в курсе «Нейронные сети». Если вы его не смотрели, то рекомендую ознакомиться:

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

Класс Sequential

Часто архитектуры нейронных сетей строят в виде последовательности слоев, начиная с входного и заканчивая выходным:

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

А, затем, создаем экземпляр класса Sequential, то есть, последовательную архитектуру нейронной сети:

В действительности, это эквивалентно последовательному вызову слоев для некоторого входного тензора:

Класс Sequential предоставляет лишь удобство и некоторый дополнительный функционал при работе с моделью. Например, все слои доступны через список model.layers:

Можно удалить последний слой методом pop():

А, затем, добавить методом add():

Соответственно, можно вначале определить пустую модель (без слоев):

а после этого добавить необходимые элементы:

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

У каждого слоя и у модели в целом имеется свойство weights, содержащее список настраиваемых параметров (весовых коэффициентов). Если обратиться к первому слою и свойству weights:

то увидим пустой список. А если сделать то же самое для всей модели:

то получим исключение (ошибку). Это связано с тем, что до момента подачи входного сигнала на вход сети весовые коэффициенты еще не были сформированы. Здесь все работает по аналогии с нашим классом DenseLayer, который мы создавали на предыдущем занятии. Пока не будет вызван метод build слоя, весовые коэффициенты отсутствуют.

Давайте пропустим через модель входной сигнал, состоящий из одного наблюдения длиной 20 чисел:

Теперь при обращении к свойству weights получим список всех весовых коэффициентов модели:

и мы также можем вывести структуру этой модели с помощью метода summary():

Слой Input

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

Здесь первый слой Input() устанавливает размерность входного тензора, равным 20 элементов. Это означает, что на вход следует подавать данные в формате:

Обратите внимание, в Keras первая размерность – это размер мини-батча, по которому производится расчет градиентов и оптимизация весовых коэффициентов. Поэтому, указывая размер 20, получаем матрицу:

Именно так мы задавали входной тензор для нашей модели (размерностью 1 x 20):

Также следует иметь в виду, что в коллекции model.layers:

будет всего два слоя, а не три, так как входной слой Input не является функциональным и нужен лишь для определения свойств входного сигнала.Того же эффекта можно добиться, просто указывая размерность через параметр input_shape:

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

Обучение модели

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

то достаточно задать функцию потерь, оптимизатор:

и запустить обучением через метод fit():

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

Извлечение признаков из последовательной модели

Давайте теперь на основе последовательной модели сформируем немного более сложную модель, которая будет иметь тот же один вход, но два выхода (по одному от каждого слоя):

Такое преобразование легко выполнить с помощью другого, общего класса моделей – keras.Model. При создании его экземпляра достаточно в сформированной нейронной сети указать список входов и список выходов. В нашем случае, это можно сделать так:

Обратите внимание, мы это делаем после обучения сети. В результате, модель model_ex будет содержать те же самые слои и весовые коэффициенты, что и модель model, так как лишь меняет конфигурацию входов и выходов, но не создает сеть заново. То есть, обе модель ссылаются на одну и ту же архитектуру НС.Благодаря этому, мы можем обучать любую из них, а затем, использовать обе, как обученный вариант НС.

В качестве маленького эксперимента давайте создадим модель model_ex непосредственно после модели model, обучим первую модель (model) и сравним выходные результаты последнего слоя:

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

Однако, если сформировать модель, указав только один выход с промежуточного слоя:

то получим урезанный вариант исходной модели. Здесь выходной слой будет отсутствовать, так как он идет после первого. А если указать один выходной слой:

то получим эквивалент исходной модели, так как все промежуточные слои между входом и указанными выходами автоматически повторяются. Мы можем в этом убедиться, вызвав метод summary() для второй модели:

Обратите внимание, как мы обратились к выходному слою – по его имени, которое было задано через параметр name этого слоя. Это пример того, как можно извлекать отдельные слои из моделей нейронных сетей.

Расширение существующей модели

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

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

И после компилирования второй модели:

дообучим ее последний слой:

При необходимости можно «замораживать» отдельные слои, исключая их из обучения. Для этого следует обратиться к слою и установить у него тот же параметр trainable в False:

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

Видео по теме

#1. Что такое Tensorflow? Примеры применения. Установка

#2. Тензоры tf.constant и tf.Variable. Индексирование и изменение формы

#3. Математические операции и функции над тензорами

#4. Реализация автоматического дифференцирования. Объект GradientTape

#5. Строим градиентные алгоритмы оптимизации Adam, RMSProp, Adagrad, Adadelta

#6. Делаем модель с помощью класса tf.Module. Пример обучения простой нейросети

#7. Делаем модель нейросети для распознавания рукописных цифр

#8. Декоратор tf.function для ускорения выполнения функций

#9. Введение в модели и слои бэкэнда Keras

#13. Создаем ResNet подобную архитектуру для классификации изображений CIFAR-10

#14. Тонкая настройка и контроль процесса обучения через метод fit()

#15. Тонкая настройка обучения моделей через метод compile()

#16. Способы сохранения и загрузки моделей в Keras

© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта

Источник

Боковая панель

НАЧАЛО РАБОТЫ

МОДЕЛИ

ПРЕДОБРАБОТКА

ПРИМЕРЫ

Sequential

API модели Sequential

Для начала прочтите это руководство по модели Keras Sequential.

Методы последовательной модели

compile

Настраивает модель Keras Sequential для обучения.

Исключения

fit

fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False)

Обучает модель Keras Sequential для фиксированного количества эпох (итераций на наборе данных).

Аргументы

validation_data: Данные, по которым оцениваются потери и любые показатели модели в конце каждой эпохи. Модель не будет обучена работе с этими данными. данные validation_data будут переопределять данные validation_split. данные validation_data могут быть: — кортеж (x_val, y_val) нулевых массивов или тензоры — кортеж (x_val, y_val, val_sample_weights) нулевых массивов — набор данных или итератор набора данных.

Для первых двух случаев необходимо указать batch_size. В последнем случае должны быть предоставлены validation_steps.

shuffle: Булевы (чтобы перетасовать тренировочные данные перед каждой эпохой) или str (для «batch»). «Batch» — это специальная опция для работы с ограничениями данных HDF5; он тасуется в кусках пакетного размера. Не имеет эффекта, когда steps_per_epoch не None.

Объект History. Его атрибут History.history представляет собой запись обучающих значений потерь и метрик в последующие эпохи, а также значений потерь проверки и метрик проверки (если применимо).

Исключения

evaluate

evaluate(x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False)

Возвращает значение потерь и метрики для модели Keras Sequential в тестовом режиме.

Вычисление производится партиями.

Аргументы

Исключеия

Возврат

Скалярные тестовые потери (если модель имеет один выход и не имеет метрик) или список скаляров (если модель имеет несколько выходов и/или метрик). Атрибут model.metrics_names даст вам метки отображения для скалярных выходов.

predict

predict(x, batch_size=None, verbose=0, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False)

Генерирует предсказания для входных сэмплов.

Вычисление производится партиями.

Аргументы

Возврат

Numpy массив(ы) предсказаний.

train_on_batch

train_on_batch(x, y, sample_weight=None, class_weight=None, reset_metrics=True)

Выполняет обновление одного градиента на одном пакете данных.

Аргументы

Возврат

Скалярные потери при обучении (если модель имеет один выход и не имеет метрик) или список скаляров (если модель имеет несколько выходов и/или метрик). Атрибут model.metrics_names даст вам метки отображения для скалярных выходов.

test_on_batch

test_on_batch(x, y, sample_weight=None, reset_metrics=True)

Тестируем модель Keras Sequential на одной партии образцов.

Аргументы

Возврат

Скалярные тестовые потери (если модель имеет один выход и не имеет метрик) или список скаляров (если модель имеет несколько выходов и/или метрик). Атрибут model.metrics_names даст вам метки отображения для скалярных выходов.

predict_on_batch

Возвращает прогнозы для одной партии образцов.

Аргументы

Возврат

Numpy массив(ы) предсказаний.

fit_generator

fit_generator(generator, steps_per_epoch=None, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, validation_freq=1, class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, shuffle=True, initial_epoch=0)

Поставляет модель Keras Sequential на основе данных, сгенерированных пакетно по пакетам генератором Python (или экземпляром Sequence).

Генератор работает параллельно с моделью, для большей эффективности. Например, это позволяет выполнять увеличение данных на изображениях на CPU в реальном времени параллельно с обучением модели на GPU.

Использование keras.utils.Sequence гарантирует упорядочение и однократное использование каждого входа в эпоху при использовании use_multiprocessing=True.

Returns

A History object. Its History.history attribute is a record of training loss values and metrics values at successive epochs, as well as validation loss values and validation metrics values (if applicable).

Пример

def generate_arrays_from_file(path):

while True:

with open(path) as f:

for line in f:

# создавать Numpy массивы входных данных

# и метки, из каждой строки в файле.

x1, x2, y = process_line(line)

evaluate_generator

evaluate_generator(generator, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0)

Оценивает модель Keras Sequential на генераторе данных.

Генератор должен возвращать данные того же типа, что и test_on_batch.

Аргументы

generator: Генератор, выдающий кортежи (входы, цели) или (входы, цели, sample_weights) или экземпляр объекта Sequence (keras.utils.Sequence), чтобы избежать дублирования данных при использовании многопроцессорной обработки.

steps: Общее количество шагов (партий образцов) для выхода из генератора до остановки. Необязательно для Sequence: если не указано, будет использоваться len(generator) в качестве нескольких шагов.

callbacks: Список экземпляров keras.callbacks.callback. List of callbacks to apply during training (Список обратных вызовов, применяемых во время тренировки). См. callbacks.

max_queue_size: максимальный размер очереди генератора.

workers: Целостный. Максимальное количество процессов для раскрутки при использовании многопоточности на основе процессов. Если не указано, то по умолчанию рабочие будут равны 1. Если 0, то генератор будет выполняться в главном потоке.

use_multiprocessing: если значение True, использовать многопоточность на основе процессов. Обратите внимание, что поскольку эта реализация основана на многопроцессорной обработке, не следует передавать генератору непикируемые аргументы, так как они не могут быть легко переданы дочерним процессам.

verbose: verbosity mode, 0 или 1.

Возврат.

Скалярные тестовые потери (если модель имеет один выход и не имеет метрик) или список скаляров (если модель имеет несколько выходов и/или метрик). Атрибут model.metrics_names даст вам метки отображения для скалярных выходов.

Исключения

predict_generator

predict_generator(generator, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0)

Генерирует предсказания для входных образцов из генератора данных.

Генератор должен возвращать данные того же вида, что и принятый в predict_on_batch.

Аргументы

Возврат

Numpy массив(ы) предсказаний.

Исключения

get_layer

get_layer(name=None, index=None)

Восстанавливает слой на основе его имени (уникального) или индекса.

Если указаны и name, и index, то приоритет будет отдан индексу.

Индексы основываются на порядке обхода горизонтального графика (снизу вверх).

Аргументы

Возврат

Исключения

Источник