Нейронные сети векторного квантования обучения (LVQ)

Архитектура

Сетевая архитектура LVQ показана ниже.

Сеть LVQ имеет первый конкурентный уровень и второй линейный уровень. Конкурентный уровень учится классифицировать входные векторы примерно так же, как конкурентные уровни Cluster with Self-Organizing Map Neural Network, описанные в этой теме. Линейный уровень преобразует классы конкурентного уровня в целевые классификации, определенные пользователем. Классы, полученные конкурентным уровнем, называются подклассами, а классы линейного уровня - целевыми классами.

Как конкурентный, так и линейный слои имеют один нейрон на (под или цель) класс. Таким образом, конкурентный уровень может обучаться до S1 подклассов. Они, в свою очередь, объединяются линейным слоем для формирования S2 целевых классов. (S1 всегда больше S2.)

Например, предположим, что нейроны 1, 2 и 3 в конкурентном слое все изучают подклассы входного пространства, которое принадлежит линейному слою целевого класса 2. Тогда конкурентные нейроны 1, 2 и 3 будут иметь LW2,1 веса от 1,0 до нейрона n2 в линейном слое и веса от 0 до всех других линейных нейронов. Таким образом, линейный нейрон производит 1, если любой из трех конкурентных нейронов (1, 2 или 3) выигрывает конкуренцию и выводит 1. Именно так подклассы конкурентного уровня объединяются в целевые классы в линейном уровне.

Короче говоря, 1 в i-ом ряду a1 (остальные элементы a1 будут равны нулю) эффективно выбирает i-й столбец LW2,1 в качестве сетевого выхода. Каждый такой столбец содержит один 1, соответствующий определенному классу. Таким образом, подкласс 1s из уровня 1 переводят в различные классы путем умножения LW2,1a1 на уровне 2.

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

Создание сети LVQ

С помощью этой функции можно создать сеть LVQ. lvqnet,

net = lvqnet(S1,LR,LF)

где

S1 - количество скрытых нейронов первого уровня.
LR - коэффициент обучения (по умолчанию 0,01).
LF является функцией обучения (по умолчанию learnlv1).

Предположим, что у вас есть 10 входных векторов. Создайте сеть, которая назначит каждый из этих входных векторов одному из четырех подклассов. Таким образом, в первом конкурентном слое имеется четыре нейрона. Эти подклассы затем присваиваются одному из двух выходных классов двумя нейронами на уровне 2. Входные векторы и цели задаются

P = [-3 -2 -2 0 0 0 0 2 2 3; 0 1 -1 2 1 -1 -2 1 -1 0];

Tc = [1 1 1 2 2 2 2 1 1 1];

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

P,Tc
P =
    -3    -2    -2     0     0     0     0     2     2     3
     0     1    -1     2     1    -1    -2     1    -1     0
Tc =
     1     1     1     2     2     2     2     1     1     1

График входных векторов будет следующим.

Как видно, существует четыре подкласса входных векторов. Вы хотите, чтобы сеть, которая классифицирует p1, p2, p3, p8, p9 и p10, получала выходной сигнал 1, и которая классифицирует векторы p4, p5, p6 и p7 для получения выходного сигнала 2. Заметим, что эта проблема нелинейно разделяема, и поэтому не может быть решена перцептроном, но сеть LVQ не имеет трудностей.

Следующее преобразование Tc матрица для целевых векторов.

T = ind2vec(Tc);

Это дает разреженную матрицу T которые могут быть отображены в полном объеме с

targets = full(T)

что дает

targets =
     1     1     1     0     0     0     0     1     1     1
     0     0     0     1     1     1     1     0     0     0

Выглядит правильно. Он говорит, например, что, если у вас есть первый столбец P в качестве входных данных вы должны получить первый столбец targets в качестве выходного документа; и этот выходной сигнал говорит, что входной сигнал попадает в класс 1, что является правильным. Теперь вы готовы позвонить lvqnet.

Звонить lvqnet создать сеть с четырьмя нейронами.

net = lvqnet(4);

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

net = configure(net,P,T);
net.IW{1}
ans =
     0     0
     0     0
     0     0
     0     0

Убедитесь, что вес второго слоя составляет 60% (6 из 10 дюймов Tc) его столбцов с 1 в первой строке (соответствует классу 1), и 40% его столбцов имеют 1 во второй строке (соответствует классу 2). Только с четырьмя столбцами, 60% и 40% на самом деле округляются до 50%, и есть два 1 в каждой строке.

net.LW{2,1}
ans =
     1     1     0     0
     0     0     1     1

Это тоже имеет смысл. Это говорит, что если конкурентный слой создает 1 в качестве первого или второго элемента, входной вектор классифицируется как класс 1; в противном случае это класс 2.

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

Вы можете смоделировать сеть с помощью sim. Использовать оригинал P матрица в качестве входных данных, чтобы увидеть, что вы получаете.

Y = net(P);
Yc = vec2ind(Y)
Yc =
     1     1     1     1     1     1     1     1     1     1

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

LVQ1 Правило обучения (learnlv1)

Обучение LVQ на конкурентном уровне основано на наборе пар вход/цель.

${_{p1},_{} t1},_{{} {p2}_{,} t2},_{.} . ._{} {$ pQ, tQ}

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

${_{p1} = \begin{matrix} \end{matrix} [2-10],_{t1} = \begin{array}{l} \end{array} [0010]}$

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

Для обучения сети представлен входной вектор p, и расстояние от p до каждой строки входной весовой матрицы IW1,1 вычисляется с помощью функции. negdist. Скрытые нейроны слоя 1 конкурировать. Предположим, что i-й элемент n1 является наиболее положительным, и нейрон i * выигрывает конкуренцию. Затем функция конкурентной передачи создает 1 как i * -й элемент a1. Все остальные элементы a1 равны 0.

Когда а1 умножается на LW2,1 весов слоя 2, одиночный 1 в а1 выбирает класс k *, связанный с вводом. Таким образом, сеть присвоила входной вектор p классу k *, и _α2k * будет равен 1. Конечно, это назначение может быть хорошим или плохим, _для tk * может быть 1 или 0, в зависимости от того, принадлежал ли ввод классу k * или нет.

Отрегулируйте i * -ю строку ^IW1,1 таким образом, чтобы переместить эту строку ближе к входному вектору p, если назначение правильное, и отодвинуть строку от p, если назначение неверное. Если p классифицирован правильно,

$(_{}^{}_{} αk∗2=tk∗=1)$

вычислить новое значение i * -й строки ^IW1,1 как

$^{Ii∗W1,1} (q)^{} =Ii∗W1,1 (q - 1) + {}_{(}α p^{(q})$ −Ii∗W1,1 (q − 1))

С другой стороны, если p классифицирован неправильно,

$(_{}^{}_{} αk∗2=1≠tk∗=0)$

вычислить новое значение i * -й строки ^IW1,1 как

$^{Ii∗W1,1} (q)^{} =Ii∗W1,1 (q - 1) - {}_{(}α p^{(q})$ −Ii∗W1,1 (q − 1))

Эти поправки можно внести в i * ю строку ^IW1,1 автоматически, не влияя на другие строки ^IW1,1, путем обратного распространения ошибок вывода на уровень 1.

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

Функция обучения, которая реализует эти изменения в весах уровня 1 в сетях LVQ, learnlv1. Его можно применять во время обучения.

Обучение

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

net.trainParam.epochs = 150;
net = train(net,P,T);

Теперь подтвердите веса первого уровня.

net.IW{1,1}
ans =
    0.3283    0.0051
   -0.1366    0.0001
   -0.0263    0.2234
         0   -0.0685

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

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

Y = net(P);
Yc = vec2ind(Y)

Это дает

Yc =
     1     1     1     2     2     2     2     1     1     1

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

pchk1 = [0; 0.5];
Y = net(pchk1);
Yc1 = vec2ind(Y)

Это дает

Yc1 =
     2

Это выглядит правильно, потому что pchk1 близок к другим векторам, классифицированным как 2. Аналогично,

pchk2 = [1; 0];
Y = net(pchk2);
Yc2 = vec2ind(Y)

дает

Yc2 =
     1

Это тоже выглядит правильно, потому что pchk2 близок к другим векторам, классифицированным как 1.

Вы можете попробовать примерную программу Learning Vector Quantization. Это следует за обсуждением обучения, приведенным выше.

Дополнительное правило обучения LVQ2.1 (learnlv2)

Следующее правило обучения может быть применено после первого применения LVQ1. Это может улучшить результат первого обучения. Этот конкретный вариант LVQ2 (называемый LVQ2.1 в литературе [Koho97]) воплощен в функции learnlv2. Обратите внимание на то, что LVQ2.1 должен использоваться только после применения LVQ1.

Обучение здесь похоже на learnlv2 за исключением того, что теперь могут быть обновлены два вектора уровня 1, которые являются ближайшими к входному вектору, при условии, что один принадлежит правильному классу, а один принадлежит неверному классу, и, кроме того, при условии, что входной сигнал попадает в «окно» рядом с промежуточной плоскостью двух векторов.

Окно определяется

$\min \frac{(_{}}{_{}} didj \frac{,_{}}{_{}} djdi)$ > s

где

$\frac{}{s≡1−w1+w}$

(где _di и _dj - евклидовы расстояния p от _i * ^IW1,1 _и j ^{* IW1,1} соответственно). Возьмем значение w в диапазоне от 0,2 до 0,3. Если выбрать, например, 0,25, то s = 0,6. Это означает, что если минимальное из двух отношений расстояний больше 0,6, то два вектора корректируются. То есть, если вход находится вблизи промежуточной платы, отрегулируйте два вектора при условии, что входной вектор p _и ^{j *} IW1,1 принадлежат одному классу, а _p и ⁱ * IW1,1 не принадлежат одному классу.

Внесенные корректировки:

$^{Ii∗W1,1} (q)^{} =Ii∗W1,1 (q - 1) - {}_{(}α p^{(q})$ −Ii∗W1,1 (q − 1))

$^{Ij∗W1,1} (q)^{} =Ij∗W1,1 (q - 1) + {}_{(}α p^{(q})$ −Ij∗W1,1 (q − 1))

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

Функция	Описание
`competlayer`	Создание конкурентного слоя.
`learnk`	Правило обучения Кохонена.
`selforgmap`	Создайте самоорганизующуюся карту.
`learncon`	Функция обучения предвзятости совести.
`boxdist`	Расстояние между двумя векторами положения.
`dist`	Евклидова функция веса расстояния.
`linkdist`	Функция расстояния канала.
`mandist`	Манхэттенская функция веса дистанции.
`gridtop`	Функция топологии слоя сетки.
`hextop`	Функция топологии шестигранного слоя.
`randtop`	Функция топологии случайного слоя.
`lvqnet`	Создание обучающей векторной сети квантования.
`learnlv1`	Функция изучения веса LVQ1.
`learnlv2`	Функция изучения веса LVQ2.

Документация