Многослойный перцептрон — как выполнить действия?

Question

[iamserge]

Собственно вопрос простой, разбираюсь с сетями и сделал пока только простейший перцептрон, в нем несколько входов, столько же весов и всего один выход. Я просто вычисляю произведение входа на соответсвующий вес т.е. а потом все складываю: Sum(w[i] * Input[i]) => в сигмоиду и вот и собственно все готово ... Обучение идет чуть иначе, но схожим образом ...

Но вот с многослойной сетью где N выходов уже немного не ясно, вот тут есть пример, вставлю и сюда картинку, судя по всему тут стоит делать точно так же, в соответствии с связями... Но вот не ясно, где тут эти вектора проходят? Я банально никак не пойму что мне на что умножать и как складывать в несколько шагов т.к. тут явно есть w1, w2 чего в самом простом перцептроне нет, а значит и в один проход это не делается ... Но как сделать?

Answer 1

[rPman]

input1..3 размерность N и output1..3 размерность M это вектора I и O соответственно, каждый со своей размерностью (в твоем примере одинаковая)
размер скрытого слоя - K
веса между input и скрытым слоем w1x это матрица A, размерность NxK
веса между скрытым слоем и output w2x это матрица B, размерность KxM

Формула
sigmoid(I*A) получаем вектор H размерностью K
следующий слой
sigmoid(H*B) получаем вектор O размерностью M

т.е. O = sigmoid(sigmoid(I*A)*B)

входной и выходной вектора еще нормализуют

Comments

[iamserge]

А что значит "еще нормализуют"? Т.е. я так понял нужно еще какую-то функцию/средства нормализации подключить кроме сигмоиды?

[rPman]

Нормализация вектора A, это когда его значения сдвигают (плюс/минус) и пропорционально (уменьшают/увеличивают кратно) таким образом, чтобы значения находились на некотором интервале, общем для всей сети, например [0..+1] или [-1..+1]. Еще там есть линейные и нелинейные методы нормализации (т.е. будут ли значения близкие к минимальным быть на том же расстоянии что и близкие например к максимальным)...

Делать это можно разными способами, например если значения у тебя гуляют от конкретных значений min/max то можно использовать сдвиг (A-min) а затем разделить на (max-min), полученное значение будет на интервале [0..1]. Напоминаю что в этом случае min/max должны быть костантой на все время существования сети, т.е. если ты добавляешь данные, и они выходят за min/max предыдущей версии выборки, то нужно переобучать (правда обычно дообучение будет простым, веса за считанные шаги скорректируются под новые значения).

Если значения гуляют от 0 до бесконечности, можно использовать 1/1+A

Сигмоида - одна из функций нормализации. Именно поэтому значение выходных векторов должны быть [-1..+1]

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

[iamserge]

rPman, Понятно, просто у меня Inputs они как byte идут, я в некотором смысле нормализовал их еще до ... Даже не думал, что как-то можно иначе и все равно будет работать ^_^

[iamserge]

rPman, Т.е. я по большому счету делаю расчеты до, а inputs представляю как набор признаков где все они отвечают на вопрос в рамках ДА/НЕТ о чем либо про данные. Ну например, что данные сейчас выше среднего = 1 или 0, ну или ниже среднего = 1 или 0. И так по каждому случаю, в таком смысле у меня они нормализованы, но я думал что так и должно быть т.е. нельзя inputs кормить всеми подряд данными оО

[rPman]

обычно перцептрон используют как классификатор, выходы это классы а значения 0 - нет, 1 - да

формально можно использовать выходные и как значения от 0 до 1 например для оценки величины, но на сколько я помню нейронные сети плохо тут работают, пример если у тебя были примеры где значения выхода 0.1 0.2 0.3... от входа например линейно, то нейронная сеть для значений между ними может подставить не линейно, т.е. ты ожидаешь 0.14, 0.15, 0.16 а нейронка выдаст 0.11, 0.12, 0.19 и будет права, значения ведь между и друг с другом так же отсортированы
-------

нейронка МОЖЕТ принимать на вход любые значения, но работать она будет хуже, так как для нормализации в этом случае она будет использовать первый скрытый слой (тебе придется делать дополнительный), т.е. ты будешь тратить дорогие ресурсы на ее обучение только чтобы провести эту нормализацию, которую тупо дешевле сделать однократно для исходных данных

-----

да, на вход нейронка может получать ЛЮБОЙ идеологически тип входа, цвет пиксела, вес, разницу двух значений (т.е. буквально производная) и т.п. весь смысл нейронных сетей что они могут внутри себя разобраться что там на входе и работать, проблема только в лишних затратах ресурсов, если данные не подготовить удобными. Не нужно даже заботиться о том что рядом стоящие значения были соседними значениями в векторе.... т.е. к примеру ты пикселы представляешь тремя числами RGB и соответственно изображение можешь представить либо как три отдельные матрицы либо одна матрица но для каждого пиксела друг за другом идут RGB числа. Нейронке абсолютно пофиг.

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

[iamserge]

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

А вот ресурсы да, судя по O = sigmoid(sigmoid(I*A)*B) - это при увеличении количества слоев будет зависимым и параллелится только на уровне самого умножения. Я C# использую и тут это кажется только набор классов Vector2-4 и матрицы там еще есть... Хм ну или OpenCL я пробовал, но моя видео карта не очень готова хватать звезды с неба =(

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

[rPman]

iamserge, что значит медленно работает?

если матрица влезает в быструю память GPU (сотни килобайт) то вычисления будут 100-1000кратно быстрее чем на процессоре, если влезает в gpu vram то в 10-100 кратно, если не влезает (используется трансфер pci-e) то в зависимости от конфига - в считанные разы быстрее.

количество весов в слое - квадрат от размерности (N*M), суммарное количество весов - линейно от количества слоев.

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

[iamserge]

rPman, Хм, однако надо будет попробовать. А чем примерно пользоваться? Ну в смысле просто обычные double/float перемножать или есть что либо получше в смысле интерфейсов?

Просто я пробовал как бенч поиск простых чисел и она оказалась чуть лучше Xeon E5-2696V4, то есть там +20% на моей RX580 8GB всего навсего ...

[rPman]

самостоятельно реализовывать эффективные вычисления на gpu не просто, сомневаюсь что тут кто то даст нормальные советы, попробуй отдельный вопрос задать, у меня мало опыта и я в основном писал универсально на opencl и тюнил гиперпараметры (количество воркеров и предварительная подготовка данных и удобное их размещение в памяти)

ты не ответил, что значит медленно? посчитай сколько у тебя получается flops, и сравни с производительностью той же реализации на cpu а так же с тем что предлагают реализация torch.

10-50х быстрее чем на cpu при тупой реализации в лоб и там и там - это нормально.

[iamserge]

rPman, Хм, сколько именно не считал, на самом деле это вот этот код:
https://github.com/rogalmic/opencl-csharp/blob/mas...

Но я добавил еще вот это и получилось примерно одинаково, а итераций по 100М, так более веско что ли, не люблю ms высчитывать:

public static void doItCPU()
        {
            
            var sw = new Stopwatch();
            sw.Start();

            int[] message = Enumerable.Range(2, 100000000).ToArray();
            Parallel.ForEach(message, (number, state, index) =>
            {
                int upperlimit = (int)Math.Sqrt(number);
                for (int i = 2; i <= upperlimit; i++)
                {
                    if (message[index] % i == 0)  //no lock needed. every index is independent
                    {
                        message[index] = 0;
                        break;
                    }
                }
            });

            sw.Stop();
            Console.WriteLine($"Total time: {sw.ElapsedMilliseconds.ToString()}");
            Console.ReadKey();

        }

[iamserge]

rPman, Но разбираться я буду позже) Просто на удивление я скормил ему данные просто так, не 1 или 0, нормализовал через сигмоиду и на выходе получилось схоже с тем что было и это меня очень удивляет :_:

[iamserge]

rPman, Знаешь, я тут вспомнил про это, сначала как-то забыл написать. Я просто попробовал кое что иное. Я взял случайные данные, сгенерированные генератором чисел ... И было забавно наблюдать за результатом.

Answer 2

[freeExec]

Во-первых, где у тебя bias, либо дополнительный вход на котором всегда 1? В противном случае у тебя функция вращается вокруг центра.
Во-вторых, прелесть перцептрона в том, что его логика везде одна, хоть в однослойном, хоть миллиардслойном. Так что тебе надо вернуться назад и сделать логику универсальной, не учитывающий, что у тебя "один проход".

Comments

[iamserge]

Прочитал что такое bias, слышу первый раз) А где он должен быть и как может выглядеть?