Conv1D

Описание

Info

Родительский класс: ConvND

Производные классы: -

Этот модуль выполняет операцию одномерной свёртки. Для более подробной теоретической информации об операции свёртки см. ConvND.

Для входного тензора с размерами (N, C_{in}, L_{in}), выходного с размерами (N, C_{out}, L_{out}) и ядра свёртки размера size операция проводится следующим образом (рассматриваем i-й элемент батча и j-ую карту выходного тензора):

out_i(C_{out_j}) = bias(C_{out_j}) + \sum_{k=0}^{C_{in} - 1}weight(C_{out_j}, k) \star input_i(k)

где

N - размер батча;
C - количество карт в тензоре;
L - размер последовательности;
bias - тензор смещений слоя свёртки, имеет размеры (1, C_{out}, 1, 1);
weight - тензор весов слоя свёртки, имеет размеры (C_{out}, C_{in}, 1, size);
\star - оператор взаимной корреляции.

Инициализация

def __init__(self, inmaps, outmaps, size, stride=1, pad=0, dilation=1, wscale=1.0, useBias=True, name=None,
                 initscheme=None, empty=False, groups=1):

Параметры

Параметр Возможные типы Описание По умолчанию
inmaps int Количество карт во входном тензоре -
outmaps int Количество карт в выходном тензоре -
size int Размер ядра свёртки -
stride int Шаг свёртки 1
pad int Паддинг карт 0
dilation int Разрежение окна свёртки 1
wscale float Дисперсия случайных весов слоя 1.0
useBias bool Использовать или нет вектор смещений True
initscheme Union[tuple, str] Указывает схему инициализации весов слоя (см. createTensorWithScheme) None -> ("xavier_uniform", "in")
name str Имя слоя None
empty bool Инициализировать ли матрицу весов и смещений False
groups int На сколько групп разбиваются карты для раздельной обработки 1

Пояснения

Info

Для вышерассмотренных входного (N, C_{in}, L_{in}) и выходного (N, C_{out}, L_{out}) тензоров существует зависимость между их размерами: \begin{equation} L_{out} = \frac{L_{in} + 2pad - dil(size - 1) - 1}{stride} + 1 \end{equation}


pad - возможна передача только единой величины отступа для всех сторон карт. Возможности создания асимметричного паддинга (заполнение дополнительными элементами только с одной стороны тензора) для данного модуля не предусмотрено, используйте Pad1D;


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

По умолчанию каждая выходная карта взаимодействует со всеми входными картами (groups=1).

Если группы две, операция становится эквивалентна двум слоям свертки, каждый из которых видит половину входных каналов другого и производит половину выходных каналов. Каждая из этих выходных последовательностей затем выстраивается друг за другом.

Если количество групп совпадает с количеством входных карт, каждый канал сворачивается со своим собственным набором ядер размера (\frac{outmaps}{inmaps})

Значения параметров inmaps и outmaps должны делиться на значение параметра groups.

Примеры


Базовый пример свёртки


Необходимые импорты.

import numpy as np
from PuzzleLib.Backend import gpuarray
from PuzzleLib.Modules import Conv1D
from PuzzleLib.Variable import Variable

Info

gpuarray необходим для правильного размещения тензора на GPU

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

batchsize, inmaps, l = 1, 1, 10
outmaps = 2

data = gpuarray.to_gpu(np.arange(batchsize * inmaps * l).reshape((batchsize, inmaps, l)).astype(np.float32))
print(data)
[[[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]]]

Размер фильтра зададим 2, остальные параметры свёртки оставим по умолчанию (stride=1, pad=0, dilation=1, groups=1). Использование смещений явно отключим (хоть по умолчанию их тензор будет нулевым и не окажет влияния на итоговый результат):

size = 2
conv = Conv1D(inmaps=inmaps, outmaps=outmaps, size=size, useBias=False)

В этом моменте проведён небольшой хак, чтобы задать веса явно. Так как выходных карт две и тензоры весов имеют размерности вида (C_{out}, C_{in}, 1, size):

def customW(size):
    w1 = np.ones(shape=(1, 1, 1, size))
    w2 = np.arange(size).reshape((1, 1, 1, size)) * -1
    w = np.vstack([w1, w2]).astype(np.float32)

    return w

w = customW(size)
print(w)
[[[[ 1.  1.]]]

 [[[ 0. -1.]]]]

Установим веса на модуль:

conv.setVar("W", Variable(gpuarray.to_gpu(w)))

Important

Вводим условие, что веса модуля для всех примеров задаются функцией customW. Для краткости этот момент в примерах кода будет опущен.

Проведём операцию свёртки на синтетическом тензоре. Так как паддинг не был задан, то размер карт выходного тензора меньше, чем входного:

print(conv(data))
[[[ 1.  3.  5.  7.  9. 11. 13. 15. 17.]
  [-1. -2. -3. -4. -5. -6. -7. -8. -9.]]]


Параметр size


Используем всё то же самое, что и в предыдущем примере, но зададим другой размер фильтра:

conv = Conv1D(inmaps=inmaps, outmaps=outmaps, size=3, useBias=False)
print(conv(data))
[[[  3.   6.   9.  12.  15.  18.  21.  24.]
  [ -5.  -8. -11. -14. -17. -20. -23. -26.]]]


Параметр pad


Используем параметры с предыдущего примера, но, допустим, хотим сохранить размеры тензора. Учитывая, что размер фильтра равен 3, а шаг свёртки 1, то для сохранения размера 5 нам понадобится паддинг 1, т.е. исходный тензор будет выглядеть следующим образом:

[[[0. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 0.]]]

Переинициализируем свёртку:

conv = Conv1D(inmaps=inmaps, outmaps=outmaps, size=3, pad=1, useBias=False)
print(conv(data))
[[[  1.   3.   6.   9.  12.  15.  18.  21.  24.  17.]
  [ -2.  -5.  -8. -11. -14. -17. -20. -23. -26.  -9.]]]


Параметр stride


Вернёмся к параметрам по умолчанию и фильтру размера 2, но изменим шаг свёртки:

conv = Conv1D(inmaps=inmaps, outmaps=outmaps, size=2, stride=2, useBias=False)
print(conv(data))
[[[ 1.  5.  9. 13. 17.]
  [-1. -3. -5. -7. -9.]]]

Чтобы сохранить размер исходного тензора, придётся выставлять паддинг, равный 2:

conv = Conv1D(inmaps=inmaps, outmaps=outmaps, size=2, stride=2, pad=2, useBias=False)
print(conv(data))
[[[ 0.  0.  0.  3.  7. 11. 15.  9.  0.  0.]
  [ 0.  0.  0. -2. -4. -6. -8.  0.  0.  0.]]]


Параметр dilation


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

conv = Conv1D(inmaps=inmaps, outmaps=outmaps, size=2, stride=1, pad=0, dilation=2, useBias=False)
print(conv(data))
[[[ 2.  4.  6.  8. 10. 12. 14. 16.]
  [-2. -3. -4. -5. -6. -7. -8. -9.]]]


Параметр groups


Для данного примера вывод тензоров приведёт к очень громоздким конструкциям, поэтому опустим их.

В данном примере переинициализации весов функциией customW не происходит.

batchsize, inmaps, l = 1, 16, 10
outmaps = 32
groups = 1
conv = Conv1D(inmaps, outmaps, size=2, initscheme="gaussian", groups=groups)
print(conv.W.shape)
(32, 16, 1, 2)
Видно, что получилась обычная свёртка. Поменяем количество групп:
groups = 4
conv = Conv1D(inmaps, outmaps, size=2, initscheme="gaussian", groups=groups)
print(conv.W.shape)
(32, 4, 1, 2)
Это может быть не очевидно из представленного кода, но теперь операция свёртки будет проходить следующим образом: из первых \frac{inmaps}{groups}=4 входных карт будут получены \frac{outmaps}{groups}=8 выходных карт, этот же принцип сохраняется и для оставшихся четвёрок.

Чтобы получить Depthwise Separable Convolution блок:

from PuzzleLib.Containers import Sequential
seq = Sequential()
seq.append(Conv1D(inmaps, inmaps, size=size, initscheme="gaussian", groups=inmaps, name="depthwise"))
seq.append(Conv1D(inmaps, outmaps, size=1, initscheme="gaussian", name="pointwise"))
print(seq["depthwise"].W.shape)
(16, 1, 1, 2)
print(seq["pointwise"].W.shape)
(32, 16, 1, 1)
data = gpuarray.to_gpu(np.random.randn(batchsize, inmaps, l).astype(np.float32))
seq(data)