Построение сверточной модели шаг за шагом

машинное обучение искусственный интеллект алгоритм Нейронные сети

Примечание. Содержание этой статьи взято из упражнения по программированию курса [Сверточные нейронные сети]: Сверточная модель: шаг за шагом. Хотя в таких фреймворках, как TensorFlow, уже есть модули сверточной нейронной сети с высокой степенью интеграции, полезно шаг за шагом построить сверточную модель, чтобы получить глубокое понимание сверточных нейронных сетей.

В этом упражнении по программированию мы реализуем слой свертки (CONV) и слой пула (POOL), используя numpy.

В этом руководстве используетсясимвол:

  • Верхний индекс [l] представляет объект на уровне l.

    • Например: a[4] — функция активации 4-го слоя, W[5] и b[5] — параметры 5-го слоя.

  • Верхний индекс (i) представляет объект i-го образца.

    • Например: x(i) — i-я входная выборка.

  • Нижний индекс i представляет i-й элемент вектора.

    • Например: a[l]i представляет собой i-й элемент функции активации l-го уровня, который считается полносвязным (FC) уровнем.

  • nH, nW и nC представляют высоту, ширину и количество каналов определенного слоя соответственно. Если вы хотите обратиться к слою l, вы можете написать nH[l], nW[l], nC[l].

  • nHprev, nWprev и nCprev представляют высоту, ширину и количество каналов предыдущего слоя соответственно. Если вы хотите указать слой l, вы также можете написать nH[l-1], nW[l-1], nC[l-1] .

Прежде чем приступить к программированию, вам необходимо ознакомиться с numpy. Давайте начнем!

1 - Импорт пакета

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

  • Numpy — это основной пакет для научных вычислений на Python.

  • matplotlib — это пакет для построения графиков на Python.

  • np.random.seed(1) используется для обеспечения того, чтобы сгенерированные случайные числа были одинаковыми, что удобно для модульного тестирования.

import numpy as np
import h5py
import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

%load_ext autoreload
%autoreload 2

np.random.seed(1)скопировать код

Примечание:% — это знак инструкции в Jupyter Notebook.Если приведенный выше код помещен в скрипт на чистом Python, строку % необходимо удалить.

2 - Схема домашнего задания по программированию

Далее вы будете реализовывать строительные блоки сверточных нейронных сетей! Каждая функция имеет подробное описание:

  • Функции свертки включают в себя:

    • заполнение нулями

    • окно свертки

    • Сверточное прямое распространение

  • Функции объединения включают в себя:

    • объединенный пас вперед

    • Создать маску

Вы будете реализовывать эти функции с нуля в numpy, а в следующем упражнении по программированию вы будете использовать TensorFlow для создания следующих моделей:

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

3 - Сверточные нейронные сети

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

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

3.1 - Заполнение нулями

Zero padding добавляет нулевые элементы вокруг границ изображения:

Рис. 1. Заполнение нулями: 3-канальное изображение заполнено двумя единицами.

Основными преимуществами набивки являются:

  • Используйте слои CONV, не уменьшая высоту и ширину объема. Это очень важно для построения более глубоких сетей, иначе сеть будет очень глубокой и высота/ширина будут резко уменьшены. Важным частным случаем этого является «та самая» свертка, высота/ширина которой полностью сохраняется после операции свертки.

  • Это может помочь нам сохранить больше информации о границах изображения. Без заполнения часть данных в следующем слое будет затронута краями пикселей.

Упражнение: Реализуйте следующую функцию для заполнения нулями всех изображений в образце X. Пожалуйста, используйте np.pad для реализации. Обратите внимание, что если бы вы задали массив "a" формы (5,5,5,5,5), с pad=1 для второго измерения, pad=3 для четвертого и pad=0 для остальных измерений , вы Это может быть достигнуто следующим образом:

a = np.pad(a, ((0,0), (1,1), (0,0), (3,3), (0,0)), 'constant', constant_values = (..,..))скопировать код
# GRADED FUNCTION: zero_pad

def zero_pad(X, pad):
    """
    Pad with zeros all images of the dataset X. The padding is applied to the height and width of an image, 
    as illustrated in Figure 1.

    Argument:
    X -- python numpy array of shape (m, n_H, n_W, n_C) representing a batch of m images
    pad -- integer, amount of padding around each image on vertical and horizontal dimensions

    Returns:
    X_pad -- padded image of shape (m, n_H + 2*pad, n_W + 2*pad, n_C)
    """

    ### START CODE HERE ### (≈ 1 line)
    X_pad = np.pad(X, ((0, 0), (pad, pad),(pad, pad), (0, 0)), 'constant')
    ### END CODE HERE ###

    return X_padскопировать код

3.2 - Одношаговая свертка

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

  • получить входной объем

  • Примените фильтр к каждой позиции входного объема

  • вывести другой объем данных (обычно другого размера)

Рис. 2. Операция свертки: размер фильтра 2x2, шаг 1

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

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

Упражнение: реализовать conv_single_step().

# GRADED FUNCTION: conv_single_step

def conv_single_step(a_slice_prev, W, b):
    """
    Apply one filter defined by parameters W on a single slice (a_slice_prev) of the output activation 
    of the previous layer.

    Arguments:
    a_slice_prev -- slice of input data of shape (f, f, n_C_prev)
    W -- Weight parameters contained in a window - matrix of shape (f, f, n_C_prev)
    b -- Bias parameters contained in a window - matrix of shape (1, 1, 1)

    Returns:
    Z -- a scalar value, result of convolving the sliding window (W, b) on a slice x of the input data
    """

    ### START CODE HERE ### (≈ 2 lines of code)
    # Element-wise product between a_slice and W. Do not add the bias yet.
    s = a_slice_prev * W
    # Sum over all entries of the volume s.
    Z = np.sum(s)
    # Add bias b to Z. Cast b to a float() so that Z results in a scalar value.
    Z = Z + b[0, 0, 0]
    ### END CODE HERE ###

    return Zскопировать код

3.3 — Сверточные нейронные сети — прямое распространение

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

Упражнение: Реализуйте следующую функцию для выполнения операции свертки с фильтром W при входной активации A_prev. Параметры функции имеют вход A_prev, выход активации предыдущего слоя (входная партия равна m), фильтры F (представленные весами W и вектором смещения b, где каждый фильтр имеет свое собственное смещение). Наконец, у вас также есть доступ к словарю гиперпараметров, содержащих шаги и отступы.

намекать:

  1. Чтобы выбрать верхний левый фрагмент 2x2 матрицы "a_prev" формы (5,5,3), вы должны реализовать это следующим образом:

    a_slice_prev = a_prev[0:2,0:2,:]скопировать код

  2. Чтобы определить a_slice, вам нужно определить четыре угла: vert_start, vert_end, horiz_start и horiz_end. Диаграмма ниже может помочь вам узнать, как использовать h, w, f и s для определения каждого угла в приведенном ниже коде.

Рис. 3. Определение срезов с вертикальным и горизонтальным началом/концом (фильтр 2x2), на этом рисунке показан только один канал

напоминать: Формула для выходной формы свертки и входной формы:

В этом упражнении нам не нужно думать о векторизации и использовать цикл for для реализации всего.

# GRADED FUNCTION: conv_forward

def conv_forward(A_prev, W, b, hparameters):
    """
    Implements the forward propagation for a convolution function

    Arguments:
    A_prev -- output activations of the previous layer, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)
    W -- Weights, numpy array of shape (f, f, n_C_prev, n_C)
    b -- Biases, numpy array of shape (1, 1, 1, n_C)
    hparameters -- python dictionary containing "stride" and "pad"

    Returns:
    Z -- conv output, numpy array of shape (m, n_H, n_W, n_C)
    cache -- cache of values needed for the conv_backward() function
    """

    ### START CODE HERE ###
    # Retrieve dimensions from A_prev's shape (≈1 line)  
    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape

    # Retrieve dimensions from W's shape (≈1 line)
    (f, f, n_C_prev, n_C) = W.shape

    # Retrieve information from "hparameters" (≈2 lines)
    stride = hparameters["stride"]
    pad = hparameters["pad"]

    # Compute the dimensions of the CONV output volume using the formula given above. Hint: use int() to floor. (≈2 lines)
    n_H = int((n_H_prev -f + 2 * pad) / stride) + 1
    n_W = int((n_W_prev -f + 2 * pad) / stride) + 1

    # Initialize the output volume Z with zeros. (≈1 line)
    Z = np.zeros((m, n_H, n_W, n_C))

    # Create A_prev_pad by padding A_prev
    A_prev_pad = zero_pad(A_prev, pad)

    for i in range(m):                                  # loop over the batch of training examples
        a_prev_pad = A_prev_pad[i, :, :, :]             # Select ith training example's padded activation
        for h in range(n_H):                            # loop over vertical axis of the output volume
            for w in range(n_W):                        # loop over horizontal axis of the output volume
                for c in range(n_C):                    # loop over channels (= #filters) of the output volume

                    # Find the corners of the current "slice" (≈4 lines)
                    vert_start = h * stride
                    vert_end = vert_start + f
                    horiz_start = w * stride
                    horiz_end = horiz_start + f

                    # Use the corners to define the (3D) slice of a_prev_pad (See Hint above the cell). (≈1 line)
                    a_slice_prev = a_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :]


                    # Convolve the (3D) slice with the correct filter W and bias b, to get back one output neuron. (≈1 line)
                    Z[i, h, w, c] = conv_single_step(a_slice_prev, W[:, :, :, c], b[:, :, :, c])

    ### END CODE HERE ###

    # Making sure your output shape is correct
    assert(Z.shape == (m, n_H, n_W, n_C))

    # Save information in "cache" for the backprop
    cache = (A_prev, W, b, hparameters)

    return Z, cacheскопировать код

Наконец, слой CONV также должен содержать функцию активации, обычно добавляя следующую строку кода:

# Convolve the window to get back one output neuron
Z[i, h, w, c] = ...
# Apply activation
A[i, h, w, c] = activation(Z[i, h, w, c])скопировать код

Но здесь это пока не нужно.

4 - Слой пула

Слои объединения (POOL) уменьшают высоту и ширину ввода. Это помогает уменьшить объем вычислений и помогает сделать входную позицию детектора признаков более стабильной. Два объединяющих слоя:

  • Слой максимального пула: сдвигает окно (f, f) на входе и сохраняет максимальное значение окна на выходе.

  • Слой среднего пула: скольжение окна (f, f) на входе и сохранение среднего значения окна на выходе.

Эти объединяющие слои не имеют параметров для обучения обратному распространению. Однако существуют гиперпараметры, такие как размер окна f, которые определяют высоту и ширину окна fxf, по которым вычисляется максимальное или среднее значение.

4.1 - Форвардный пул

Теперь вы реализуете MAX-POOL и AVG-POOL в одной и той же функции.

Упражнение: Реализуйте прямое распространение слоя пула, пожалуйста, реализуйте его в соответствии с подсказками в комментариях.

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

# GRADED FUNCTION: pool_forward

def pool_forward(A_prev, hparameters, mode = "max"):
    """
    Implements the forward pass of the pooling layer

    Arguments:
    A_prev -- Input data, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)
    hparameters -- python dictionary containing "f" and "stride"
    mode -- the pooling mode you would like to use, defined as a string ("max" or "average")

    Returns:
    A -- output of the pool layer, a numpy array of shape (m, n_H, n_W, n_C)
    cache -- cache used in the backward pass of the pooling layer, contains the input and hparameters 
    """

    # Retrieve dimensions from the input shape
    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape

    # Retrieve hyperparameters from "hparameters"
    f = hparameters["f"]
    stride = hparameters["stride"]

    # Define the dimensions of the output
    n_H = int(1 + (n_H_prev - f) / stride)
    n_W = int(1 + (n_W_prev - f) / stride)
    n_C = n_C_prev

    # Initialize output matrix A
    A = np.zeros((m, n_H, n_W, n_C))              

    ### START CODE HERE ###
    for i in range(m):                         # loop over the training examples
        for h in range(n_H):                     # loop on the vertical axis of the output volume
            for w in range(n_W):                 # loop on the horizontal axis of the output volume
                for c in range (n_C):            # loop over the channels of the output volume

                    # Find the corners of the current "slice" (≈4 lines)
                    vert_start = h * stride
                    vert_end = vert_start + f
                    horiz_start = w * stride
                    horiz_end = horiz_start + f

                    # Use the corners to define the current slice on the ith training example of A_prev, channel c. (≈1 line)
                    a_prev_slice = A_prev[i, vert_start:vert_end, horiz_start:horiz_end, c]

                    # Compute the pooling operation on the slice. Use an if statment to differentiate the modes. Use np.max/np.mean.
                    if mode == "max":
                        A[i, h, w, c] = np.max(a_prev_slice)
                    elif mode == "average":
                        A[i, h, w, c] = np.mean(a_prev_slice)

    ### END CODE HERE ###

    # Store the input and hparameters in "cache" for pool_backward()
    cache = (A_prev, hparameters)

    # Making sure your output shape is correct
    assert(A.shape == (m, n_H, n_W, n_C))

    return A, cacheскопировать код

Поздравляем! Теперь вы реализовали прямое распространение для всех слоев сверточной сети.

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

Категории