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

1. Товары
2. Клиенты
3. Случаи использования

1. Переполнение стека Публичные вопросы и ответы
2. Команды Частные вопросы и ответы для вашей команды
3. предприятие Частные вопросы и ответы для вашего предприятия
4. работы Программирование и связанные с ним технические возможности карьерного роста
5. Талант Нанимать технический талант
6. реклама Связаться с разработчиками по всему миру

Последовательный класс

Последовательный класс

  tf.keras.Sequential (слоев = нет, имя = нет)
  

Последовательный группирует линейный стек слоев в tf.keras.Model .

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

Примеры

  >>>
>>> модель = tf.keras.Sequential ()
>>> модель.адд (тф.keras.layers.Dense (8, input_shape = (16,)))
>>>
>>> model.add (tf.keras.layers.Dense (4))
  

  >>>
>>> модель = tf.keras.Sequential ()
>>> model.add (tf.keras.Input (shape = (16,)))
>>> model.add (tf.keras.layers.Dense (8))
  

  >>>
>>>
>>>
>>> модель = tf.keras.Sequential ()
>>> model.add (tf.keras.layers.Dense (8))
>>> model.add (tf.keras.layers.Dense (4))
>>>
  

  >>>
>>>
>>> модель = тф.keras.Sequential ()
>>> model.add (tf.keras.layers.Dense (8, input_shape = (16,)))
>>> model.add (tf.keras.layers.Dense (4))
>>> лен (модель.веса)
4
  

  >>>
>>>
>>>
>>> модель = tf.keras.Sequential ()
>>> model.add (tf.keras.layers.Dense (8))
>>> model.add (tf.keras.layers.Dense (4))
>>> model.build ((Нет, 16))
>>> лен (модель.весы)
4
  

  # Обратите внимание, что при использовании шаблона отложенного построения (не указана форма ввода),
# модель строится в первый раз, когда вы вызываете `fit`,` eval` или `Forect`,
# или в первый раз, когда вы вызываете модель для некоторых входных данных.model = tf.keras.Sequential ()
model.add (tf.keras.layers.Dense (8))
model.add (tf.keras.layers.Dense (1))
model.compile (оптимизатор = 'sgd', потеря = 'mse')
# Это строит модель в первый раз:
model.fit (x, y, batch_size = 32, epochs = 10)
  

добавить метод

Добавляет экземпляр слоя поверх стека слоев.

Аргументы

Повышает

• TypeError : Если , уровень не является экземпляром уровня.
• ValueError : если аргумент layer не соответствует знать его входную форму.
• ValueError : в случае, если аргумент layer имеет несколько выходных тензоров или уже подключены где-то еще (запрещено в последовательных моделей).

поп метод

Удаляет последний слой в модели.

Повышает

• TypeError : если в модели нет слоев.

Последовательная модель

Автор: fchollet
Дата создания: 2020/04/12
Последнее изменение: 2020/04/12
Описание: Полное руководство по последовательной модели.

Просмотреть в Colab • GitHub source

Настройка

  импорт тензор потока как тф
из тензор потока импортных керас
из tenensflow.keras импортировать слои
  

Когда использовать последовательную модель

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

Схематично следующая модель Последовательная модель :

  # Определить последовательную модель с 3 слоями
model = keras.Sequential (
    [
        layer.Dense (2, активация = "relu", name = "layer1"),
        layer.Dense (3, активация = "relu", name = "layer2"),
        layer.Dense (4, name = "layer3"),
    ]
)
# Вызвать модель на тестовом входе
x = tf.ones ((3, 3))
у = модель (х)
  

соответствует этой функции:

  # Создать 3 слоя
layer1 = слои.Плотный (2, активация = "relu", name = "layer1")
layer2 = layer.Dense (3, активация = "relu", name = "layer2")
layer3 = layer.Dense (4, name = "layer3")

# Вызов слоев на тестовом входе
x = tf.ones ((3, 3))
y = layer3 (layer2 (layer1 (x)))
  

Последовательная модель не подходит , когда:

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

Создание последовательной модели

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

 модель  = керас. Последовательный (
    [
        layer.Dense (2, активация = "relu"),
        layer.Dense (3, активация = "relu"),
        layers.Dense (4),
    ]
)
  

Его слои доступны через слоев. Атрибут :

  [<тензор потока.python.keras.layers.core.Dense at 0x148873e90>,
 ,
 ]
  

Вы также можете постепенно создать последовательную модель с помощью метода add () :

 модель  = keras.Sequential ()
model.add (Layers.Dense (2, Activation = "Relu"))
model.add (Layers.Dense (3, Activation = "Relu"))
model.add (layers.Dense (4))
  

Обратите внимание, что существует также соответствующий метод pop () для удаления слоев: Последовательная модель ведет себя очень похоже на список слоев.

  model.pop ()
print (len (model.layers)) # 2
  

Также обратите внимание, что конструктор Sequential принимает аргумент name , как любой слой или модель в керасе. Это полезно для аннотирования графиков TensorBoard с семантически значимыми именами.

  модель = keras.Sequential (name = "my_sequential")
model.add (layer.Dense (2, активация = "relu", name = "layer1"))
model.add (layer.Dense (3, активация = "relu", name = "layer2"))
model.add (layer.Dense (4, name = "layer3"))
  

Задание формы ввода заранее

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

  слой = слои. Густой (3)
layer.weights # Пусто
  

Создает свои веса при первом вызове на входе, поскольку форма вес зависит от формы входов:

  # Уровень вызова на тестовом входе
x = tf.ones ((1, 4))
у = слой (х)
layer.weights # Теперь у него есть веса, формы (4, 3) и (3,)
  

  [,
 ]
  

Естественно, это также относится к последовательным моделям. Когда вы создаете Последовательная модель без входной формы, она не «построена»: она не имеет весов (и звонит Модель .вес приводит к ошибке, утверждающей только это). Весы созданы когда модель впервые видит некоторые входные данные:

 модель  = керас. Последовательный (
    [
        layer.Dense (2, активация = "relu"),
        layer.Dense (3, активация = "relu"),
        layers.Dense (4),
    ]
) # Нет весов на этом этапе!

# На данный момент вы не можете сделать это:
# model.weights

# Вы также не можете сделать это:
# model.summary ()

# Вызвать модель на тестовом входе
x = tf.ones ((1, 4))
у = модель (х)
print («Количество весов после вызова модели:», len (model.весов)) # 6
  

  Количество весов после вызова модели: 6
  

После того, как модель «построена», вы можете вызвать ее метод summary () , чтобы отобразить ее содержание:

  Модель: "sequential_3"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
плотность_7 (плотная) (1, 2) 10
_________________________________________________________________
density_8 (Плотный) (1, 3) 9
_________________________________________________________________
density_9 (Плотный) (1, 4) 16
================================================== ===============
Всего параметров: 35
Обучаемые параметры: 35
Не обучаемые параметры: 0
_________________________________________________________________
  

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

 модель  = keras.Sequential ()
model.add (keras.Input (форма = (4,)))
model.add (Layers.Dense (2, Activation = "Relu"))

model.summary ()
  

  Модель: "sequential_4"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
density_10 (Плотный) (Нет, 2) 10
================================================== ===============
Всего параметров: 10
Обучаемые параметры: 10
Не обучаемые параметры: 0
_________________________________________________________________
  

Обратите внимание, что объект Input не отображается как часть модели .слои , так как это не слой:

  []
  

Простая альтернатива — просто передать аргумент input_shape вашему первому слой:

 модель  = keras.Sequential ()
model.add (Layers.Dense (2, активация = "relu", input_shape = (4,)))

model.summary ()
  

  Модель: "sequential_5"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
density_11 (Плотный) (Нет, 2) 10
================================================== ===============
Всего параметров: 10
Обучаемые параметры: 10
Не обучаемые параметры: 0
_________________________________________________________________
  

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

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

Общий рабочий процесс отладки: add () + Summary ()

При построении новой последовательной архитектуры полезно наращивать в стеке слои с добавить () и часто печатать сводки моделей. Например, это позволяет отслеживать, как работает стек из слоев Conv2D и MaxPooling2D карты изображения с понижающей дискретизацией:

 модель  = керас.Последовательное ()
model.add (keras.Input (shape = (250, 250, 3))) # 250x250 RGB-изображений
model.add (слои. Conv2D (32, 5, шаг = 2, активация = "relu"))
model.add (layer.Conv2D (32, 3, активация = "relu"))
model.add (layers.MaxPooling2D (3))

# Можете ли вы угадать, какова текущая форма вывода на данный момент? Возможно нет.
# Давайте просто напечатать это:
model.summary ()

# Ответ был: (40, 40, 32), так что мы можем продолжать понижать выборку ...

model.add (layer.Conv2D (32, 3, активация = "relu"))
model.add (layer.Conv2D (32, 3, активация = "relu"))
модель.Добавить (layers.MaxPooling2D (3))
model.add (layer.Conv2D (32, 3, активация = "relu"))
model.add (layer.Conv2D (32, 3, активация = "relu"))
model.add (layers.MaxPooling2D (2))

# И сейчас?
model.summary ()

# Теперь, когда у нас есть карты объектов 4x4, пришло время применить глобальный максимальный пул.
model.add (layers.GlobalMaxPooling2D ())

# Наконец, мы добавляем слой классификации.
model.add (layers.Dense (10))
  

  Модель: "sequential_6"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
conv2d (Conv2D) (Нет, 123, 123, 32) 2432
_________________________________________________________________
conv2d_1 (Conv2D) (нет, 121, 121, 32) 9248
_________________________________________________________________
max_pooling2d (MaxPooling2D) (нет, 40, 40, 32) 0
================================================== ===============
Всего параметров: 11 680
Обучаемые параметры: 11680
Не обучаемые параметры: 0
_________________________________________________________________
Модель: "sequential_6"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
conv2d (Conv2D) (Нет, 123, 123, 32) 2432
_________________________________________________________________
conv2d_1 (Conv2D) (нет, 121, 121, 32) 9248
_________________________________________________________________
max_pooling2d (MaxPooling2D) (нет, 40, 40, 32) 0
_________________________________________________________________
conv2d_2 (Conv2D) (нет, 38, 38, 32) 9248
_________________________________________________________________
conv2d_3 (Conv2D) (Нет, 36, 36, 32) 9248
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (Нет, 12, 12, 32) 0
_________________________________________________________________
conv2d_4 (Conv2D) (нет, 10, 10, 32) 9248
_________________________________________________________________
conv2d_5 (Conv2D) (нет, 8, 8, 32) 9248
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (Нет, 4, 4, 32) 0
================================================== ===============
Всего параметров: 48 672
Обучаемые параметры: 48,672
Не обучаемые параметры: 0
_________________________________________________________________
  

Очень практично, правда?

Что делать, если у вас есть модель

Как только ваша модель архитектуры будет готова, вы захотите:

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

  initial_model = keras.Sequential (
    [
        keras.Input (форма = (250, 250, 3)),
        слои.Conv2D (32, 5, шаг = 2, активация = "relu"),
        слои.Conv2D (32, 3, активация = "relu"),
        слои.Conv2D (32, 3, активация = "relu"),
    ]
)
feature_extractor = керас.Модель(
    входов = initial_model.inputs,
    output = [layer.output для слоя в initial_model.layers],
)

# Вызов функции извлечения на тестовом вводе.
x = tf.ones ((1, 250, 250, 3))
features = feature_extractor (x)
  

Вот аналогичный пример, который извлекает объекты только из одного слоя:

  initial_model = keras.Sequential (
    [
        keras.Input (форма = (250, 250, 3)),
        слои.Conv2D (32, 5, шаг = 2, активация = "relu"),
        слои.Conv2D (32, 3, активация = "relu", имя = "my_intermediate_layer"),
        слои.Conv2D (32, 3, активация = "relu"),
    ]
)
feature_extractor = keras.Model (
    входов = initial_model.inputs,
    Выходы = initial_model.get_layer (имя = "my_intermediate_layer"). Выход,
)
# Вызов функции извлечения на тестовом вводе.
x = tf.ones ((1, 250, 250, 3))
features = feature_extractor (x)
  

Передача обучения с последовательной моделью

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

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

Во-первых, предположим, что у вас есть последовательная модель, и вы хотите заморозить все слои, кроме последнего. В этом случае вы просто перебрали бы model.layers и set layer.trainable = False на каждом слое, кроме последний. Как это:

  модель = керас. Последовательный ([
    keras.Input (форма = (784))
    layer.Dense (32, активация = 'relu'),
    слои.Плотный (32, активация = 'relu'),
    layer.Dense (32, активация = 'relu'),
    layers.Dense (10),
])

# Предположительно, вы хотели бы сначала загрузить предварительно обученные веса.
model.load_weights (...)

# Заморозить все слои, кроме последнего.
для слоя в model.layers [: - 1]:
  layer.trainable = False

# Перекомпилируйте и обучите (это только обновит веса последнего слоя).
model.compile (...)
model.fit (...)
  

Еще одним распространенным планом является использование последовательной модели для укладки предварительно обученных модель и некоторые недавно инициализированные слои классификации.Как это:

  # Загрузите сверточную базу предварительно подготовленными гирьками
base_model = keras.applications.Xception (
    вес = 'imagenet',
    include_top = False,
    Пулы = «ср»)

# Заморозить базовую модель
base_model.trainable = False

# Используйте последовательную модель, чтобы добавить обучаемый классификатор сверху
model = keras.Sequential ([
    base_model,
    layers.Dense (1000),
])

# Компилировать и обучать
model.compile (...)
model.fit (...)
  

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

Это все, что вам нужно знать о последовательных моделях!

Чтобы узнать больше о создании моделей в Керасе, см .: