Запрограммируем перцептрон Розенблатта?

    После одной провокационной статьи Перцептрон Розенблатта — что забыто и придумано историей? и одной полностью доказывающей отсутствие проблем в перцептроне Розенблатта, и даже наоборот показывающей некоторые интересные стороны и возможности Какова роль первого «случайного» слоя в перцептроне Розенблатта, я так думаю у некоторых хабражителей появилось желание разобраться, что же это за зверь такой — перцептрон Розенблатта. И действительно, достоверную информацию о нем, кроме как в оригинале, найти не возможно. Но и там достаточно сложно описано как этот перцептрон запрограммировать. Полный код я выкладывать не буду. Но попробуем вместе пройти ряд основ.

    Начнем… ах да, предупреждаю, я буду рассказывать не классически, а несколько осовременено…



    Код на C#, но думаю к нему лучше относиться как к псевдокоду. Но если кто-то чего-то не понял спрашивайте — объясню.

    А начнем мы с сенсоров.

    public class cSensor
    {
        public event EventHandler ChangeState;
        private sbyte state = 0;
        public sbyte State
        {
            get { return state; }
            set 
            {
                state = value;
                if (state == 1 && ChangeState != null)
                {
                    ChangeState(thisnew EventArgs());
                }
            }
        }
    }
     


    Тут все просто. Сенсор имеет состояние 0 или 1. Как только сенсор получает единицу он посылает событие. Дальше мы имеем синапс.

    public delegate void BackCommunication(sbyte Type);
    class cSinaps
    {
        private sbyte type;
        private BackCommunication hBackCommunication;
        public cSinaps(sbyte tType,BackCommunication tBackCommunication)
        {
            type = tType;
            hBackCommunication = tBackCommunication;
        }
        public void ChangeSensorState(object sourse, EventArgs e)
        {
            hBackCommunication(type);
        }
    }
     


    Он имеет тип — будет возбуждать или тормозить активность сенсора. А также реакцию, на изменение сенсора (ChangeSensorState). Теперь собственно А-элемент в среднем слое.

        public class cAssociation
        {
            // Уровень активации А-элемента
            public int ActivationLevel = 0;
            // Синапсы соединенные с этим А-элементом 
            private cSinaps[] oSinaps;
     
            public cAssociation(cSensor[] sensorsField, int SCount, Random RND)
            {
                int SinapsCount = 10;
                oSinaps = new cSinaps[SinapsCount];
     
                int tSinapsNumber = 0;
                int tmpSensorNumber = 0;
                sbyte tmpSensorType = 0;
     
                for (int j = 1; j < SinapsCount + 1; j++)
                {
                    tmpSensorNumber = RND.Next(SCount);
                    if (RND.Next(2) == 0) tmpSensorType = 1; else tmpSensorType = -1;
     
                    oSinaps[tSinapsNumber] = new cSinaps(tmpSensorType, AssumeSinapsSignal);
     
                    sensorsField[tmpSensorNumber].ChangeState +=
                            new EventHandler(oSinaps[tSinapsNumber].ChangeSensorState);
                    tSinapsNumber++;
                }
            }
     
            void AssumeSinapsSignal(sbyte Type)
            {
                ActivationLevel += Type;
            }
        }
     


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

    В общем все, все то что так сложно рассказывалось в Какова роль первого «случайного» слоя в перцептроне Розенблатта — мы реализовали. Мы имеем в множестве А-элементов уже гарантированно линейное представление любой произвольной задачи.

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

     public class cNeironNet
    {
          public cSensor[] SensorsField; /* Сенсорное поле*/
          public cAssociation[] AssociationsFiled; /* Ассоциативное поле*/
          int ACount;
          int SCount;
          public ArrayList AHConnections;
          Random RND = new Random();
     
            public cNeironNet(int argSCount, int argACount)
            {
                ACount = argACount;
                SCount = argSCount;
                SensorsField = new cSensor[SCount];
                for (int i = 0; i < SCount; i++)
                {
                    SensorsField[i] = new cSensor();
                }
                AssociationsFiled = new cAssociation[ACount];
                for (int i = 0; i < ACount; i++)
                {
                    AssociationsFiled[i] = new cAssociation(SensorsField, SCount, RND);
                }
            }
     
          /*Добавить на обработку новый пример из обучающей выборки*/
          public ArrayList JoinStimul(int[] tPerception, int[] tReaction)
          {
              for (int i = 1; i < ACount + 1; i++)
              {
                  AssociationsFiled[i].ActivationLevel = 0;
              }
              for (int i = 1; i < SCount + 1; i++)
              {
                  SensorsField[i].State = 0;
              }
              // Кинем на сенсоры полученный пример
              for (int i = 0; i < SCount; i++)
              {
                  SensorsField[i].State = tPerception[i];
              }
              // Запомним какие А-элементы были активны на этом примере
              AHConnections = new ArrayList();
              for (= 0; i < ACount; i++)
              {
                  if (AssociationsFiled[i].ActivationLevel > 0)
                  {
                        AHConnections.Add(i);
                  }
              }
              // Запомним какая реакция должна быть на этот пример
              SaveReaction(tReaction);
              return AHConnections;
          }
          /* Когда все примеры добавлены, вызывается чтобы перцептрон их выучил*/
          private void Storing()
          {
              // Делаем очень много итераций
              for (int n = 1; n < 100000 + 1; n++)
              {
                  // За каждую итерацию прокручиваем все примеры из обучающей выборки
                  for (int i = 1; i < StimulCount + 1; i++)
                  {
                      // Активизируем R-элементы, т.е. рассчитываем выходы
                      RAktivization(i);
                      // Узнаем ошибся перцептрон или нет, если ошибся отправляем на обучение
                      bool e = GetError(i);
                      if (e)
                      {
                          LearnedStimul(i);
                          Error++; // Число ошибок, если в конце итерации =0, то выскакиваем из обучения.
                      }
                  }
              }
          }
    }


    Активация R-элементов тоже проста. Суммируем веса от активных А-элементов, и пробрасываем через порог (=0).

    private void RAktivization(int ReactionNumber)
    {
         int[] Summa = new int[RCount + 1];
         for (int j = 1; j < RCount + 1; j++)
         {
             for (= 1; i < AHConnections[ReactionNumber].Count + 1; i++)
             {
                 Summa[j] += Weight[AHConnections[ReactionNumber].Value[i]].Value[j];
             }
         }
         for (int i = 1; i < RCount + 1; i++)
         {
             if (Summa[i] > 0) Reactions[i] = 1;
             if (Summa[i] <= 0) Reactions[i] = -1;
         }
    }

    Проверка есть ошибка или нет ниже.

    private int GetError(int ReactionNumber)
    {
        int IsError = 0;
        for (int i = 1; i < RCount + 1; i++)
        {
            if (Reactions[i] == NecessaryReactions[ReactionNumber].Value[i])
            {
                ReactionError[i] = 0;
            }
            else
            {
                IsError = 1;
                ReactionError[i] = NecessaryReactions[ReactionNumber].Value[i];
            }
        }
        return IsError;
    }
     


    Тут сверяем текущую реакцию с той, что есть, и подготавливаем массив для обучения о том какая реакция ReactionError. Теперь остановимся на последнем — собственно обучении.

    private void LearnedStimul(int ReactionNumber)
    {
        for (int j = 1; j < RCount + 1; j++)
        {
            for (int i = 1; i < AHConnections[ReactionNumber].Count + 1; i++)
            {
                Weight[AHConnections[ReactionNumber].Value[i]].Value[j] += ReactionError[j];
            }
        }
    }
     


    И усё.

    Единственно, меня спрашивают — «видимо, этот алгоритм обучения коррекции с ошибкой тоже застревает как и алгоритм обратного распространения ошибки, если веса нулевые?». Как видим нет, тут само обучение начинается с нулевых весов. Тут нет ни каких математических формул — элементарные инкременты или декременты. Если вес был 0, то при коррекции ошибки он станет или +1 или -1, вес может со временем снова поменять знак пройдя через ноль, но застрять ему в нуле физически не получается.

    upd.

    Ниже retran предложил для активации А-элементов использовать матрицы и linq от функционального программирования в замен моему коду в событиях согласно более четкой модели по ООП.

        public class Perceptron1
        {
            public int[][] SAMatrix { get; private set; }
            public Perceptron1(int sensorsCount, int associativeElementsCount)
            {
                var random = new Random();
                SAMatrix = new int[associativeElementsCount][];
                for (var i = 0; i < associativeElementsCount; i++)
                {
                    SAMatrix[i] = new int[sensorsCount];
                    for (var j = 0; j < 10; j++) 
                    {
                        var sindex = random.Next(sensorsCount);
                        if (random.Next(2) == 1)
                            if (random.Next(2) == 1)
                                SAMatrix[i][sindex] += 1;
                            else
                                SAMatrix[i][sindex] -= 1; 
                    }
                }
            }
            public int Activate(int i, int[] inputs)
            {
                return (SAMatrix[i].Zip(inputs, (w, input) => w * input).Sum() > 0 ? 1 : 0);
            }
        }
     


    Да, конечно код значительно короче. Но менее понятен, в него сложнее вносить изменения если меняются процессы по активации. Но главное он работает более чем в 100 раз медленнее. Вот вам и прелести математического и функционального программирования :)

    Тестируем так (правда в моем коде выше несколько багов, но их легко поправить, если кто-то этим будет заниматься, + большую часть устранил и обновил код выше):

                Random random = new Random();
                int[] Input = new int[1000];
                int[] AActiv = new int[900];
     
                TimeSpan BeginTime = DateTime.Now.TimeOfDay;
                Perceptron1 P1 = new Perceptron1(1000900);
                for (int i = 0; i < 100; i++)
                {
                    for (int j = 0; j < 1000; j++)
                    {
                        Input[j] = random.Next(2);
                    }
                    for (int j = 0; j < 900; j++)
                    {
                        AActiv[j] = P1.Activate(j, Input);
                    }
                }
                TimeSpan locTime = DateTime.Now.TimeOfDay - BeginTime;
     
                //TimeSpan BeginTime = DateTime.Now.TimeOfDay;
                //Perceptron2 P2 = new Perceptron2(1000, 900);
                //for (int i = 0; i < 10000; i++)
                //{
                //    for (int j = 0; j < 1000; j++)
                //    {
                //        Input[j] = random.Next(2);
                //    }
                //    P2.JoinStimul(Input);
                //}
                //TimeSpan locTime = DateTime.Now.TimeOfDay - BeginTime;
     
                Console.WriteLine(locTime.ToString());
                Console.ReadLine();
     
    Share post

    Similar posts

    Comments 211

    • UFO just landed and posted this here
        +2
        C#
          +2
          Наверное лучше указывать это где-то в начале статьи, многие могут не понять сами. И еще, читать без коментов в коде сложновато, особенно тем, для кого сишарп «не родной».
            0
            Ок, уточнил в начале
              +4
              Какая разница, что это за язык, если есть трудности с разбором классов и циклов, то знание названия языка не помогут!
                0
                А если события сразу же.

                new EventArgs()

                А у меня например вообще непонятка как это реализовать на обычном Си.

                Указателем?
                  –7
                  А не легче ли на современный язык программирования перейти?
                    0
                    Хм… Секундочку…
                    Какая разница, что это за язык, если есть трудности с реализацией событийной модели, то знание названия языка не помогут!
                      0
                      > Какая разница, что это за язык, если есть трудности с реализацией событийной модели, то знание названия языка не помогут!

                      Итак, разница есть большая в названии Runtime классов, которые реализуют данную функциональность.

                      Хорошо когда @rumkin может реализовать это все на любом языке, но хотелось бы сосредоточиться на целевом алгоритме, а не на реализации событий или особенностях событийной модели.

                      P.S. В Си насколько мне известно нет событий, но код очень похож на следующий языки C++/Java/PHP.
                        0
                        Хм… Как раз-таки наоборот, если я не могу реализовать какой-то функционал на известном мне языке, значит, мне ничего не дает знание того, что где-то это реализовано. И единственно, что я могу сделать это пойти гуглить «модель событий на C».

                        P.S. На php не похож ( в php "." оператор объединения строк), на С++ не похож (должно быть int name[] вместо int[] name)
                        P.P.S. Самому интересно как модель событий на C++ запрограммировать.
                          0
                          Самому интересно как модель событий на C++ запрограммировать

                          Но это же легко делается — через указатели на функцию.
                            0
                            Т.е. ссылка на функцию в C++ может ссылается на функцию в контексте объекта и чем-то сродни замыканиям? Или же она ссылается на описание функции?
            –2
            Спасибо, интересно.
            Насколько можно судить, Вы это сами придумали.
            А Вы не хотите «полный» код защитить, а потом продать?
            (может у Вас и ещё что по сетям есть ;)
              +6
              Я не из России, мне ваши паттенты не гарантируют ничего :) А вообще я сторонник — OpenSource, поэтому если кто-то на основании этого алгоритма что-то сделает и выложит в свободный доступ — то буду считать, что моя миссия выполнена :)

              Да, и кстати, защитить классический алгоритм думаю нельзя. Да, у меня есть разработки по нейронным сетям, особенные их виды, такие как рефрактерный перцептрон — его идея опубликована в статьях, и тут да при использовании настаиваю на ссылку на меня, но это просто научная этика (бить рублем не буду)
              –20
              «Я не из России, мне ваши патенты не гарантируют ничего :) „

              ):-О
              ):-(
              Международные патенты — ничего не гарантируют?
              (что не из РФ — неудобно конечно, но чисто из-за администрирования взаимодействия)

              “А вообще я сторонник — OpenSource»

              ):-О (2 раза) (хотя для хабры это норма)
              ):-(
              Так OpenSource — и стоит на патентах, и только на патентах!
              OpenSource это — не «нет патентов», а «открытый код».
              А принуждают к открытости — как раз лицензионными ограничениями, которые основываются на патентах и только патентах.
              Изучите практику того же несчастного Microsoft-а, то, что не запатентовано, в OpenSource — не отдаётся (да и не может).

              «Да, и кстати, защитить классический алгоритм думаю нельзя.»

              ):-О
              Разве?
              Да вроде вот уже лет сто как всё прекрасно патентуется.

              «Да, у меня есть разработки по нейронным сетям»

              Потому и написали.
              Сети достаточно активно используются в промавтоматике (у нас было пара клиентов), а это — хороший повод для прине$ения пользы людям.

              «и тут да при использовании настаиваю на ссылку на меня, но это просто научная этика»

              Ааа…
              Тогда понятно.
              Учоные, это — достаточно тяжелая категория для распатентования.
              Но нескольких Ваших коллег, причём отсюда, из дикой РФ, нам всё таки удалось вывести на путь истинный.
              И в$е остались довольны.;)
                +12
                Ёпрст, читая ваши сообщения, я начинаю по-новому осмыслять термин «патентный тролль».
                  –11
                  Так любое «осмысление» это же — очень хорошо!
                  (думать — вообще полезно)
                  Просто если кто-то (не будем показывать пальцем) придумал что-то хорошее (даже необязательно по теме ускорения расчётов в нейронных сетях), но не хочет сам получить пару $М, он — всегда имеет возможность на тех или иных у$ловиях передать это право кому нибудь другому.
                  Умные — всегда должны быть богаче глупых, иначе прогресс сменится регрессом.
                  0
                  судя по нику, это такой неудачный самопиар в духе «кто со мной — тот герой, а кто без меня — тот свинья».
                    0
                    Грамотный пиар — это не «давайте заведём корпоративный блог на хабре». Грамотный пиар — это общая адекватность в общении с окружающими людьми, в т.ч. онлайн.
                    0
                    Выложи проект с исходниками
                      0
                      на ты мы не переходили
                      +1
                      Действительно выложите исходники… сравним эффективность с разными методами.
                      +4
                      на хабре неделя «перцептрона Розенблатта»? =)
                        0
                        А я вообще сериями пишу — «мост», «биовычисления», «перцептрон». А зачем распыляться, давайте концентрировать усилия :) Буду рад если предлагаемую тематику поддержат…
                          0
                          Полностью поддерживаю! Пишите еще! Будут реализации практические — выложу!
                            0
                            Существует тьма реализаций на всевозможных языках, а вот разбираться алгоритмику в них — было бы очень полезно.
                            0
                            жду когда вы наконец скрестите machine learning и фолдинг РНК.
                              0
                              Этого не будет, как минимум прямо. Фолдинг РНК — это причина почему я ушел из machine learning, причины тут Ограничение оптимизирующих методов в играх с противником и без.
                                0
                                Очень странно конечно, т.к. machine learning очень успешно применяется для фолдинга белков. Уверен, что такие исследования были сделаны и для РНК.
                                  0
                                  :), ну дайте ссылки, а так это скорее реклама
                                    +1
                                    Это конечно только вторичная структура, но все же…
                                    A predictive model for secondary RNA structure using graph theory and a neural network.
                                    www.ncbi.nlm.nih.gov/pubmed/20946605

                                    О фолдинге белков можно почитать много где, но вот сайт профессора, который выиграл один из конкурсов по фолдингу белков: они используют смесь техник.
                                      0
                                      А давайте на спор — (я даже не читал в статью) — оно не предскажет все водородные связи в том рибозиме о котором я писал в 4 части. Просто есть теоретические ограничения для алгоритмов — если они не могут — значит не могут.

                                      Про смесь техник — это уже серьезнее.
                                        +1
                                        А никто их не предскажет, даже экспериментально это сделать нереально. ЯМР повзоляет определить водороды у белков, у РНК наверняка тоже, но и эти водородные связи под вопросом. Система подвижная, потеря одной водородной связи компенсируется образованием другой и т.п.
                                          0
                                          Здесь есть хорошие приближение [http://rna.tbi.univie.ac.at/cgi-bin/RNAfold.cgi Предсказание вторичной структуры РНК (online версия в интернете)]

                                          Но они предсказывают только водородные связи спиралей, это уже хорошо. Но между спиралями они предсказать не могут.
                                            0
                                            Не-а, у РНК они не видят… да и как то я слышал, что водороды в белках тоже не видны, по крайней мере их нету в PDB
                                              0
                                              У белков методом ЯМР можно водороды получить, насчет РНК не знаю.
                                          0
                                          Ну и для вторичной — конечно можно попробовать использовать, это совсем другая задача по сложности.
                                            0
                                            Вот это уже было очень успешно сделано. Вторичную структуру белков предсказывают более-менее хорошо — 70-90% точности достигают.
                                            0
                                            В статье A predictive model for secondary RNA structure using graph theory and a neural network. www.ncbi.nlm.nih.gov/pubmed/20946605

                                            используется простой MLP+BackProp, и там всего 24 нейрона в средне слое, и 2 выхода. Элементарнее не придумаешь. Поэтому роль тут нейросети минимальна, важно именно правильное представление задачи.
                                          0
                                          Ну, и почитайте про «Ограничение оптимизирующих методов в играх с противником и без», если есть такое ограничение — невозможно эффективно, что-то применить.
                                            0
                                            Да, и кстати, связь тут обратная. Я надеюсь из опыта с фолдингом РНК — пренести нечто новое в мир machine learning. Ведь на самом деле оно сейчас способно решать только марковские задачи, а во всем остальном лишь попытки без решения.
                                              0
                                              Про марковские знаю плохо. Делю задачи на индуктивные и дедуктивные, и те и другие работают довольно хорошо, ЕСЛИ учитывать много параметров в правильной последовательности.
                                                0
                                                Марковские если грубо — это те, где история взаимодействий не влияет на текущие состояние. Т.е. постановка задачи/энергетическая поверхность/и прочие условия среды — не меняются с течением времени.
                                                  0
                                                  Кстати, именно поэтому возможно применять machine learning для предсказания вторичной структуры, т.к. процесс рассматривается не во времени.
                                    +1
                                    Перцептрон Розенблатта похож на кортикальный алгоритм Хокинса — там тоже обучение производится путем увеличения силы асссоциативной связи.
                                      0
                                      Скорее наоборот HTM Хокинса похоже на перцептрон Розенблатта. Кстати, никто не хочет запрограммировать HTM Хокинса? Он нем инфо тут Иерархическая Темпоральная Память (НТМ) и алгоритмы ее самообучения, я было начал но руки все не доходят. Оно обещает быть мощнее, чем перцептрон Розенблатта (кстати, такую оценку могу дать только для HTM, все остально же просто сравнимо с перцептроном Розенблатта).
                                        0
                                        У меня тоже не доходят.
                                          +1
                                          Я хочу, всё тянусь руками. Скоро дотянусь.
                                            0
                                            Может попробуем сделать вместе, желательно на C#?
                                              0
                                              Мои инструменты — php, ruby.
                                              Мне больше интересено, как будет проходить процесс самообучения и к каким результатам он приведет.
                                              А переписать программу/библиотеку с одного языка на другой не проблема.
                                              Последнюю неделю дочитываю материалы по теме и приступаю.
                                              Буду очень нуждаться в советах по нейросетям, в предмете которых, как я понял, Вы весьма неплохо разбираетесь.
                                                0
                                                ok, спрашивайте, потом надеюсь увидеть ваш код, буду переписывать на C#
                                        0
                                        «видимо, этот алгоритм обучения коррекции с ошибкой тоже застревает как и алгоритм обратного распространения ошибки, если веса нулевые?» Посмотрел еще раз алгоритм обратного распространения, вроде для однослойного не должно застревать, так как отличается от приведенного здесь, только умножением ошибки на значение входа и коэффициент.
                                          –1
                                          не сильно разбирался из-за чего, но с начальными нулевыми весами — BackProp не обучается
                                            +1
                                            Для BackProp начальные веса должны быть случайными
                                              0
                                              вот формула: Δw_ij = η * δ_j * x_i, если брать δ_j = t_j — o_j для линейной функции ативации, то работает, а если δ_j = (t_j — o_j) * o_j * (1 — o_j) для логистической, то идет умножение на ноль.
                                              Δw_ij — изменение веса, δ_j — ошибка на выходе, x_i — значение на входе, t_j — требуемое значение на выходе, o_j — полученное.
                                                0
                                                ативации -> активации -> активности
                                            +2
                                            tac, при всем моем уважении, у вас опыт промышленной разработки есть? Или только академический?
                                            Код откровенно «студенческий» и показывать его в качестве примера совсем нельзя:
                                            1. Почему у вас все массивы больше на один элемент чем надо и не используют нулевой?
                                            2. Именование ужасное в нарушение всех существующих в .net стилей. Даже не учитывая ошибок в английском.
                                            3. Дикий оверхед из-за использования ООП, там где оно не нужно, и, более того, только усложняет жизнь.
                                            4. Код сам по себе процедурный. Холиварно, но сейчас модно использовать linq.

                                            Чтобы не быть голословным и зная ваш характер, накидал свой вариант: dumpz.org/186774/
                                              –4
                                              ну, я же тоже могу придраться к отсутствию фигурных скобочек для тела цикла тут :)

                                              for (var j = 0; j < sensorsCount; j++)
                                              SAMatrix[i][j] = random.Next(3) — 1;

                                              но этого не делаю…

                                                +3
                                                Вы бы лучше придрались, что я в конструкторе забыл проинициализировать ATreshold и RTReshold.

                                                Фигурные скобочки там и не нужны, однострочная операция все-таки.
                                                  –4
                                                  «в нарушение всех существующих в .net стилей» :)
                                                    +2
                                                    Ни один стиль который я видел этот спорный на самом деле вопрос не регламентирует ;)
                                                    В отличие от именования.
                                                      –4
                                                      Я открою вам один секрет — стиль регламентируется внутри компании. И есть стили которые этот вопрос регламентируют.
                                                        +2
                                                        ВНЕЗАПНО, в дотнете есть аж целых два общепринятых стиля, которые используют 99% компаний: майкрософтовский и дотнетовский.
                                                0
                                                И я, конечно, извиняюсь — но что вы думаете делает накиданный вами код?
                                                  0
                                                  То же что и ваш, кроме той части, которая бросает в перцептрон обучающую выборку.
                                                    0
                                                    Вы думаете, что создав SA матрицу случайно Вы повторили мой код?
                                                      0
                                                      Да. Отсутствие связи — это ноль в матрице.
                                                      А у вас там оверхед со случайным выбором сенсора, с которым нужно связываться.
                                                        –2
                                                        Ну, ну… интересно даже посмотреть как «ваша» реализация заработает :)
                                                          +1
                                                          Посмотрите ;) Только добавьте инициализацию порогов в конструктор, это действительно косяк. Хотя и так должно работать ;)

                                                          И да, опять минусы вместо аргументов? ;)) Я же говорил уже, что плевать, все равно заплюсуют как и мои предыдущие комментарии. Тем более, что грамотных разработчиков на хабре хватает ;)

                                                          Дальше на споры с вами тратить время не хочу, просто пожелаю того, чтобы вы научились программировать и умерили самоуверенность.
                                                            –1
                                                            Мне тоже не приятно разговаривать с человеком большого самомнения о себе
                                                              –1
                                                              Написали Вы 100% неработающий перцептрон!
                                                                0
                                                                Ну какие аргументы, когда не код, а сплошной бред… вот что по вашему делает Train у вас? Что такое загадочное output? Там вот это output умножается на то, что активировался или нет некий А-элемент? причем по индексу почему то совпадающий с индексом веса…
                                                                  –2
                                                                  А я понял, у вас только один R-элемент. И при этом вы забыли, что при отсутствии ошибки корректировать веса не нужно. Садитесь два — исправляйте.
                                                                    0
                                                                    Моя цель была показать почему ваш код мне не нравится. А алгоритм полностью и вполне специально взят из вашей же статьи на википедии, дабы сохранить чистоту эксперимента.
                                                                      0
                                                                      Не смешите меня, в википедии кода нет. А тут обсуждаем этот код. Вы не разобрались в теме.
                                                                        0
                                                                        Я где-то про код написал? Я написал «алгоритм» ;)
                                                                          –1
                                                                          Какой?

                                                                          «Классический метод обучения перцептрона — это метод коррекции ошибки.[8] Он представляет собой такой вид обучения с учителем, при котором вес связи не изменяется до тех пор, пока текущая реакция перцептрона остается правильной. При появлении неправильной реакции вес изменяется на единицу, а знак (±) определяется противоположным от знака ошибки.»

                                                                          Этот? И где он реализован?
                                                                            0
                                                                            «Допустим, мы хотим обучить перцептрон разделять два класса объектов так, чтобы при предъявлении объектов первого класса выход перцептрона был положителен (+1), а при предъявлении объектов второго класса — отрицательным (−1). Для этого выполним следующий алгоритм:[5]
                                                                            Случайным образом выбираем пороги для A-элементов и устанавливаем связи S—A (далее они изменяться не будут).
                                                                            Начальные коэффициенты полагаем равными нулю.
                                                                            Предъявляем обучающую выборку: объекты (например, круги либо квадраты) с указанием класса, к которым они принадлежат.
                                                                            Показываем перцептрону объект первого класса. При этом некоторые A-элементы возбудятся. Коэффициенты, соответствующие этим возбуждённым элементам, увеличиваем на 1.
                                                                            Предъявляем объект второго класса и коэффициенты тех A-элементов, которые возбудятся при этом показе, уменьшаем на 1.
                                                                            Обе части шага 3 выполним для всей обучающей выборки. В результате обучения сформируются значения весов связей .»
                                                                              0
                                                                              М-да, проглядел — это второй автор мне
                                                                              так удружил :)
                                                                                0
                                                                                Тогда претензия не к вам, сорри ;)
                                                                        –1
                                                                        Ну, ладно не разобрались. Вы свой код легко не измените — и это причина почему ваша «функциональщина» сильно уступает ООП.
                                                                          0
                                                                          Засекайте время.
                                                                            0
                                                                            не забудьте про это
                                                                            0
                                                                            dumpz.org/186796/

                                                                            Исправлено все что вам не понравилось.
                                                                              +2
                                                                              dumpz.org/186798/

                                                                              Забыл удалить старую инициализацию матрицы.
                                                                                0
                                                                                И конечно:
                                                                                if (random.Next(2) == 1)
                                                                                SAMatrix[i][sindex] += 1;
                                                                                else
                                                                                SAMatrix[i][sindex] -= 1;

                                                                                Code completion меня слегка подвел ;)

                                                                                И поясните, пожалуйста, как функциональщина связана с ООП и каким образом вы их сравниваете?
                                                                            –1
                                                                            А все туда же с претензией на грамотность. Вам бы не советы другим раздавать, а культуре поучится.
                                                                      0
                                                                      Хотя, если присмотреться, то у вас получается 0.5 вероятность установления связи, 0.25 положительной и 0.25 отрицательной. Смысла такого назначения не понимаю, если вы же доказывали, что они могут быть случайными.
                                                                        0
                                                                        Вероятность связи много меньше 0.5 и зависит от числа сенсоров и синапсов на один А-элемент, например, может быть 10 синапсов на 1000 сенсоров. И немного подумайте зачем нам тут работать с квадратными матрицами? Конечно, идея у вас может и была не плохая, но увы — такой стиль программирования как вы предлагаете не дает свободы рефакторинга при небольших изменениях. Вот как вы перепишите это, с учетом сказанного?
                                                                          0
                                                                          тут даже дело не в рефакторинге, а в возможности легко уточнять модель
                                                                            0
                                                                            Собственно, проверил свой вариант рандома и ваш. Перцептрон работает абсолютно одинаково. И че, собственно?
                                                                              0
                                                                              Осталось теперь собственно реально по времени сравнить. И уже будет конструктивно.
                                                                                0
                                                                                Ну вот я проверил, ваш вариант работает в 100 раз медленнее.
                                                                                  0
                                                                                  Выложите исходники тестов, пожалуйста.
                                                                                    0
                                                                                    см. выше, я обновил статью
                                                                                    0
                                                                                    Ага, увидел апдейт.
                                                                                      0
                                                                                      Сразу вопросы:

                                                                                      1. Почему вы тестируете только функцию активации? Где остальное?
                                                                                      По хорошему надо отдельно померять скорость обучения, а затем отдельно скорость распознавания на обученном перцептроне.

                                                                                      2. Почему мою функцию вы запускаете 900 * 100 = 90000 раз, а свою — 10000 раз?

                                                                                      Незачет ;)
                                                                                        0
                                                                                        1. Вторая часть меня мало интересует, эти скорости независимы
                                                                                        2. Свою я запускаю в 100 раз больше 10000 раз — это 100*100

                                                                                        а 900 раз у меня прогоняется внутри функции.
                                                                                          0
                                                                                          Тем не менее протестируйте, пожалуйста, полностью.

                                                                                          > Но менее понятен, в него сложнее вносить изменения если меняются процессы по активации.

                                                                                          А вот это уже неправда. Спорить не буду, не отвечайте ;) Пусть общественность рассудит.
                                                                                            0
                                                                                            давайте сами
                                                                                              0
                                                                                              Я уже пилю реализацию на F#, не интересно возвращаться к этому коду. Тем более доказывать мне тут нечего, я знаю, что оно работает медленнее по факту ;)
                                                                                                0
                                                                                                :) ну и стоило тут бучу поднимать
                                                                                                  0
                                                                                                  Я по поводу производительности ничего не говорил ;)
                                                                                                    0
                                                                                                    А стоило, я бы проверять не пошел :) и может тогда апломба было бы у вас меньше :) а так ввели в заблуждение…

                                                                                                    Хотя продолжайте, благодаря вам, то что было всего лишь моими предпочтениями — становится реально доказанными фактами и я все больше убеждаюсь в том, что ООП рулит, а функциональщина — прошлы век :)
                                                                                                      +1
                                                                                                      Во-первых, мой код не оптимизирован по производительности, а оптимизировать там очень много чего. В одном Activate можно три последовательных цикла заменить на один, например.

                                                                                                      Во-вторых, не вижу каким образом вы сравниваете модель вычислений (которая у меня гибридная, а у вас чисто императивная) со способом структурирования кода(который в обоих вариантах — ООП). Это разные вещи.

                                                                                                      В третьих, в наш современный век многоядерных процессоров… Предложите вариант быстро адаптировать ваш код для параллельных вычислений.

                                                                                                      Напомню, что в моем это делается тупой заменой вызовов LINQ на вызовы PLINQ.
                                                                                                        0
                                                                                                        Мой код уже параллелен в обсуждаемой части :), даже без параллельности… но это сложно понять, поэтому сделайте замены на PLINQ я посмотрю как много это дает.
                                                                                                          0
                                                                                                          Параллелен без параллельности? Жжете.

                                                                                                          Еще раз — мне лень заниматься оптимизацией кода, написанного в чисто иллюстративных целях и суть моих претензий к вашему совсем не в производительности.
                                                                                                            0
                                                                                                            именно, долго объяснять
                                                                                                              0
                                                                                                              Если я правильно понял вы предлагали вот так:

                                                                                                              public int Activate(int i, int[] inputs)
                                                                                                              {
                                                                                                              return (SAMatrix[i].AsParallel().Zip(inputs.AsParallel(), (w, input) => w * input).Sum() > 0? 1: 0);
                                                                                                              }

                                                                                                              Это еще больше тормозит, где-то в 4 раза медленнее
                                                                                                                0
                                                                                                                Потому что самый внешний цикл (в тесте) не параллельный и на каждой итерации старательно ждет, пока внутренние параллельные закончатся. А так как тут вы распараллелили очень атомарные операции, то получается, что издержки на параллелизацию больше, чем сами операции. Параллелить надо обучение и вычисление всей нейросети.
                                                                                                                  0
                                                                                                                  Ясно, преимущество легкого распараллеливания обещанного только заменой PLINQ — не ожидается. Так вот и не надо голову пудрить людям. Когда нормально распараллелите — поговорим… но и ежу понятно, что иметь 100 процессоров вместо одного накладненько… поэтому дело не в параллелизме — а в непродуманной модели — что есть проблема математическо-функционального программирования.
                                                                                                                    0
                                                                                                                    tac, в силу того, что переубедить вас невозможно, при всем моем желании, и времени на это у меня уже нет, а промышленного опыта разработки у вас явно нет и проблем ее вы не понимаете, я воспользуюсь вашим любимым аргументом — срочно идите читать первоисточники:
                                                                                                                    1. Про ООП — «Рефакторинг» и «Архитектуру корпоративных систем» Мартина Фаулера.
                                                                                                                    2. Так называемый SICP — про функциональное программирование.

                                                                                                                    Вы сейчас выглядите как те, вами ненавидимые люди, которые дают неправильное определение перцептрону, серьезно.
                                                                                                                      –2
                                                                                                                      Дорой мой товарищ, да будет вам известно, что опыта в пром. разработке у меня будет побольше вашего. И читал и знаю все ваши книжечки. Проблема в одном — надо уметь различать рекламу (типа модной функциональщины, которая имеет очень узкое применение, а такие как вы суете ее всюду куда не надо) от того, что работает в реальности.
                                                                                                                        0
                                                                                                                        По вашему коду весь ваш опыт четко виден и в дополнительных комментариях не нуждается. За сим откланиваюсь.
                                                                                                                          –1
                                                                                                                          Ага, в 100 раз больше и быстрее :)
                                                                                                                      0
                                                                                                                      «Совершенный код» Макконнела еще.
                                                                                                                    +2
                                                                                                                    Ну и sum, очевидно, вообще не параллелится ;)
                                                                                                                      –2
                                                                                                                      Вот, начинается озарение… скоро разберетесь :) Так вот когда будите в следующий раз холиварить и выкидывать на окружающих свое понимание — ведите себя культурнее, без личностных выпадов. Предлагая и спрашивая — «а почему бы не улучшить так?»… тогда посмотрим и улучшим или увидим минусы.
                                                                                                                        +1
                                                                                                                        Я веду себя ровным счетом так же как и вы ;) Только вот мои комментарии плюсуют, а ваши минусуют ;)))

                                                                                                                        > скоро разберетесь :)

                                                                                                                        Желаю вам того же. И научиться аргументировано отстаивать свою позицию, не занимаясь подменой понятий и демагогией.
                                                                                                                          –3
                                                                                                                          Ну, конечно, медленный код — не аргумент :)
                                                                                                                            0
                                                                                                                            Не позорьтесь уже, а? Читайте Макконнела, там много умного. В том числе и про оптимизацию кода.
                                                                                                                              –2
                                                                                                                              Это вам надо читать и очень много… оптимизировать идите жену учить :)
                                                                                                                                0
                                                                                                                                Господи… Надоело.

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

                                                                                                                                А жизнь и рынок труда все и всех расставит по местам, правда?
                                                                                                                                  –1
                                                                                                                                  а мне то как надоело ваше хамство
                                                                                                                            –1
                                                                                                                            Так же? Может вам напомнить как вы сюда пришли и начали с выливания помоев?
                                                                                                                  0
                                                                                                                  Что-то я не понял, где у вас циклы в Activate?
                                                                                                                    0
                                                                                                                    Внутри Zip и Sum.
                                                                                                        0
                                                                                                        Сравним потом полноценную функциональную реализацию с lazy evaluation и функциональным распараллеливанием.
                                                                                                    0
                                                                                                    Может это связано с повторным вычислением Activate в циклах: weight * Activate(index, inputs)) и validOutputs[j] * Activate(i, inputs), тут должно помочь динамическое программирование(если кто знает как правильно его тут использовать, пожалуйста покажите) или запоминание результатов функции в массив.
                                                                                                      0
                                                                                                      отсюда dumpz.org/186798/
                                                                                                        0
                                                                                                        Это связано с излишними мат. вычислениями. Сигналы идут только при наличии активности, в математике упорно будем складывать нули.
                                                                                                          0
                                                                                                          более того, судя по этому «if (state == 1» только при активации сенсора
                                                                                                            0
                                                                                                            Это значит, что значение А-элемента будет сохранено, когда сенсор деактивируется. Т.е. последовательность показа образцов имеет значение, если после первого образца идет второй образец — подмножество первого, в перцептроне Розенблатта второй будет проигнорирован(если наоборот, то нет), а в матричной модели — нет.
                                                                                                              0
                                                                                                              Вы не заметили сброс в нули уровня активации, при показе следующего образа.
                                                                                                          0
                                                                                                          Тут помогут ленивые вычисления.
                                                                                                          0
                                                                                                          Если что — LINQ в данной реализации действительно должен работать медленнее, но не настолько.

                                                                                                          Но вот если включить распараллеливание… Но это уже читерство, вы свой код так легко не распараллелите ;)
                                                                                                            0
                                                                                                            вообще то даже в 150 раз
                                                                                                    0
                                                                                                    А доказывал я совсем другое, это не про эту матрицу речь… но вы же все равно разбираться не будите, а выкрики с места мне уже надоели.
                                                                                              –4
                                                                                              1. Ну, не люблю я нулевые элементы
                                                                                              2. Там единственная проблема, что в параметрах я не использую префикс arg (иногда есть просто t)
                                                                                              3. Глупость
                                                                                              4. Не люблю linq принципиально, т.к. это как раз не ООП
                                                                                                +1
                                                                                                1. Тратя память, нарушая уже давно принятый стиль индексации элементов в множествах с нуля…
                                                                                                2. Любые префиксы в дотнет(кроме интерфейсных) — глупость. На эту тему ругался даже лично Симони, который их придумал.
                                                                                                3. Вы опять моделируете с помощью ООП объекты, которые моделировать не нужно. Да еще и криво ;)
                                                                                                4. Да, это функциональщина.
                                                                                                  –1
                                                                                                  Ну не согласен я с вами по пунктам 1-3, а 4 — это ужас. Но я заметьте не холиварю в отличии от вас.
                                                                                                    0
                                                                                                    Отнюдь. Я выражаю общепринятую практику, выработанную поколениями разработчиков большой кровью. А вы опять считаете себя самым умным.

                                                                                                    Насчет 4, ну если вы этого не понимаете — то это ваши проблемы ;) Тут на днях был топик про цикл for, я там много на эту тему писал.
                                                                                                0
                                                                                                По поводу 3, в статье приведена больше биологическая модель, а у вас математическая, которая конечно же будет короче.
                                                                                                  –1
                                                                                                  ИНС и есть математическая модель. Нет никакого смысла представлять взаимосвязи в объектной форме, это только усложнение кода и дополнительные накладные расходы.
                                                                                                    +1
                                                                                                    Если цель — показать работу модели, как можно ближе(или достаточно близко) к оригиналу, то смысл есть. Из умножения матриц не видно как передаются сигналы в мозгу, Кроме того, если потребуется уточнить модель, то чем ближе она будет к моделируемому объекту, тем проще это будет сделать независимо от длины описания модели. Если же стоит задача решить конкретную проблему, то скорее всего вместо достаточно далекой от предметной области ИНС, применить чистую математику поверх известных данных будет эффективнее, потому что выбирая ИНС, мы загоняем себя в рамки ее возможностей.
                                                                                                      0
                                                                                                      вот это если потребуется уточнить модель, то чем ближе она будет к моделируемому объекту, тем проще это будет сделать независимо от длины описания модели и есть важный аргумент, причем вообще ООП vs. Функциональное программирование.
                                                                                                0
                                                                                                Как ваши статьи набирают столько плюсов? У меня происходящему есть только одно объяснение — большинство плюсующих даже не открывают статью, а действуют по-принципу: «ух ты, нейронные сети на хабре, надо поддержать автора». Сам делал так пару раз, больше не буду…
                                                                                                Код в статье очень слабый, согласен со всеми аргументами retran (кроме последнего про linq, ну да не будем разводить холивар).

                                                                                                У меня один вопрос: доколе это мракобесие будет продолжаться?
                                                                                                  0
                                                                                                  Да, LINQ — это типичный холивор и претензия больше вкусовая. Да и давать его в руки, до изучения какого-нибудь SICP не стоит, а то такого можно наворотить…

                                                                                                  Но:
                                                                                                  1. Функциональное программирование традиционно и успешно применяется в западной академической среде, так как близко к классической математике.
                                                                                                  2. Именно ИНС очень хорошо на него ложатся.

                                                                                                  Если присмотреться к моему коду (в комментариях выше), то видно, что у меня там в методах Recognize и Activate записано по сути математическое определение перцептрона.
                                                                                                    –1
                                                                                                    Я LINQ постоянно использую в работе, и все равно тяжеловато читается код в Recognize. Для ИНС лучше всего подходят матрицы, там и простор для распараллеливания и накладных расходов меньше.
                                                                                                      0
                                                                                                      Про матрицы — согласен. Про тяжелую читаемость — имхо, дело привычки.
                                                                                                      Собственно, еще одна претензия к коду в статье — он плохо параллелится ;)
                                                                                                      А в моем достаточно заменить linq на plinq и переписать Train ;)
                                                                                                    0
                                                                                                    Не завидуйте. Алгоритма перцептрона Розенблатта — вообще в интернете не было еще :), вот почему-то трудно людям его закодировать
                                                                                                      –1
                                                                                                      Трудно закодировать? Не смешите )

                                                                                                      А на счет того был он или нет: в библиотеки AForge класс AForge.Neuro.Learning.PerceptronLearning
                                                                                                      (http://www.aforgenet.com/framework/docs) давным давно есть.
                                                                                                        0
                                                                                                        Там, извините, бредо-код. Им и вам надо читать до полного просветления Перцептрон Розенблатта — что забыто и придумано историей?

                                                                                                        а то, что там есть к перцептрону Розенблатта не относится. А чтобы закодировать надо хотя бы знать что такое перцептрон Розенблатта. Вот в этом и поголовная сложность у многих.
                                                                                                  0
                                                                                                  Вот как я понял работу перцептрона Розенблатта:
                                                                                                  s1 s2 s3 s4 s5
                                                                                                  _|__|__|__|__|_
                                                                                                  _0_1_-1_0__0 -> a1
                                                                                                  _-1_0_1__0_0 -> a2
                                                                                                  _0_1_0__0_-1 -> a3
                                                                                                  _1_0_0_-1__0 -> a4
                                                                                                  _1_0_0__0_-1 -> a5
                                                                                                  Число положительных единиц(в строке?) равно числу отрицательных.

                                                                                                  a1 a2 a3 a4 a5
                                                                                                  _|__|__|__|__|_
                                                                                                  _3_5_-8_ 4_1 -> r

                                                                                                  Если r != r_треб прибавляем 1 к тем из (_3_5_-8_ 4_1_), для которых соответствующий A-элемент был активен, когда активизировался(1) R-элемент и вычитаем 1 из тех, для которых A-элемент был активен, когда R-элемент подавился(-1). Получается два подмножества А-элементов: активизирующее и подавляющее.
                                                                                                    0
                                                                                                    Чтобы запомнить варианты r соответствующие каждой комбинации активности элементов А непосредственно нужно 2^(число А-элементов) бит, означает ли это что на каждое число матрицы приходится 1 бит информации?
                                                                                                      0
                                                                                                      2^(число А-элементов) бит -> (число А-элементов) бит
                                                                                                        0
                                                                                                        Да, это так.
                                                                                                          0
                                                                                                          этот ответ меня запутал
                                                                                                          0
                                                                                                          2^(число А-элементов) бит все таки: по одному биту на вариант комбинации. Изначально вопрос звучал так: чтобы запомнить варианты r соответствующие каждой комбинации активности элементов А непосредственно нужно 2^(число А-элементов) бит, означает ли это что:
                                                                                                          -на каждое число матрицы приходится 2^(число А-элементов)/(число А-элементов) бит информации?
                                                                                                          -каждое число матрицы может быть записано приблизительно 2^(число А-элементов)/(число А-элементов) битами?
                                                                                                          -если не может, то что хотя бы такая матрица может быть получена, если существует несколько вариантов окончательных матриц для одних данных?
                                                                                                          -если не может, то что суммарное число бит, достаточное для записи всех чисел равно 2^(число А-элементов) (или что такая матрица может быть получена?)?
                                                                                                            0
                                                                                                            Что-то я не пойму чего вы хотите. 2^(число А-элементов) — это все возможные варианты активностей А-элементов. Выход А-элемента 0 или 1 — т.е. бит.

                                                                                                            Дальше не понимаю ваших вопросов. Каждый стимул активирует А-элементы, чтобы запомнить внутреннею А-реакцию — нужно (число А-элементов) бит.

                                                                                                            Отсюда можно посчитать сколько стимулов сможет различать перцептрон: 2^(число А-элементов)/(число А-элементов) = число разнообразных стимулов, которые будут отличимы.

                                                                                                            А вам что нужно?
                                                                                                              0
                                                                                                              спасибо за прояснение, перцептрон запоминает число образцов, равное числу А-элементов, а значит, действительно на один А-элемент приходится 1 бит.
                                                                                                              Вопросы сводятся к следующему: какие преимущества дает применение перцептрона вместо простого запоминания вариантов ответа? И есть ли способ быстро, не прогоняя тысячи раз образцы, получить эти преимущества, работая одновременно со всеми образцами?
                                                                                                                0
                                                                                                                Ну, не совсем так. В теории да число образов = числу А-элементов, но из практики образы пересекаются сильно, поэтому где-то число образов = 0.6 * числа А-элементов (для случайных образов), а если они сильно коррелированы, то в плоть до 0.2 * числа А-элементов.

                                                                                                                Преимущества сводятся к двум: (1) из уточнения выше видим, что перцептрон может сжимать образы (2) перцептрон строит модель — поэтому он способен предсказывать (это собственно его функция). Запоминание предсказывать не может.
                                                                                                                  0
                                                                                                                  Нет, от итерационного обучения вы не избавитесь, хотя есть т.н. фильтры (особый вид ИНС) они обучаются после одного прогона, но жрут много памяти (+образы не сжимают).
                                                                                                                    0
                                                                                                                      0
                                                                                                                      Типа того, но есть лучший вариант называется CC4 от Себастьяна Как — хотя в сети найти сложно это будет
                                                                                                            0
                                                                                                            Не существует точной формулы количества нейронов в зависимости от входных данных, но есть примерная формула для вычисления максимального количества «запоминаний» состояний. Плюс ко всему чаще всего веса оперируют вещественными значениями, так что бита тут само собой более, чем не достаточно. Кстати сам по себе перцептрон не несет существенного интереса с точки зрения алгоритмов, куда интереснее его обучение, тут насколько я понял изложен вывод из самого простого метода градиентного спуска.
                                                                                                              0
                                                                                                              вы пишите о MLP+BackProp, перцептрон Розенблатта сильно отличается. Поэтому ваши слова не относятся к перцептрону Розенблатта.
                                                                                                          0
                                                                                                          Сразу вспоминаются лабы по ИНС.
                                                                                                          • UFO just landed and posted this here
                                                                                                              +2
                                                                                                              Я тут задумал статейку со сравнением перцептрона Розенблатта и перцептрона Румельхарта на реальной задаче. Код на F# (ну не так уж далеко от хаскелля) + OpenCV. Интересно?
                                                                                                                0
                                                                                                                давайте
                                                                                                              0
                                                                                                              Что-то нехорошо в королевстве датском…

                                                                                                              Англоязычная вмкмпедия, не представляет возможности ознакомится в понятияими A — матрица и G — матрица

                                                                                                              Мало того, автор статей в русскоязыной википедии — ЗАБЛОКИРОван.

                                                                                                              Просто, какая-то дезинформация глобальная.
                                                                                                                0
                                                                                                                Ну заблокирован автор по другим причинам :), а про английскую википедию — это да, может найдется человек со знанием английского — тогда сможем внести правильную информацию.
                                                                                                                  +1
                                                                                                                  ;) Вы лукавите

                                                                                                                  Оригинал материала, который Вы излагаете здесь, был написан на английском ;)
                                                                                                                  Никаких других публикаций кроме локальных, в «Publication in the Scientific Journal of RTU» нету.

                                                                                                                  Что-то здесь не так.
                                                                                                                  Хотелось бы видеть пару публикаций из более рецензируемых изданий.
                                                                                                                  Я уже не буду упоминать IEEE…

                                                                                                                  А ссылки, на собственноручно написанный материал в Википедии, это моветон.

                                                                                                                  Может переместите весь набор в блог «Я пиарюсь»? ;)


                                                                                                                  Вопрос по теме. Почему Детерминант?
                                                                                                                    –1
                                                                                                                    Ах вот Вы как :) Идите читайте оригиналы!!! Придете поговорим.
                                                                                                                      –1
                                                                                                                      В других публикациях этого быть не может, т.к. представляет только историческую ценность. Но как оказывается, это не знает куча народа.
                                                                                                                        0
                                                                                                                        Ах, да если сложно найти оригиналы, то Principles of Neurodynamic: Perceptrons and the Theory of Brain Mechanisms, там стр. 96 — найдете о G-матрице. А лучше начните читать с начала. И на будущие, в такой манере прошу не общаться — вот это точно моветон.
                                                                                                                          0
                                                                                                                          Ой
                                                                                                                          А почему это такой ответ?

                                                                                                                          Не воспринимаете альтернативные точки зрения? ;)

                                                                                                                          Вопрос по теме.
                                                                                                                          Есть некоторый опыт в прогнозировании временных рядов. (Multilayer Neural Network with Multi-Valued Neurons)
                                                                                                                          В связи с этим, несколько непонятно, как использовать ваш подход для прогнозирования временных рядов.

                                                                                                                          Вычислительная сложность сильно возрастает.
                                                                                                                            0
                                                                                                                            Какие могут быть точки зрения — в достоверных фактах?

                                                                                                                            Вопрос не ясен, «вычислительная сложность сильно возрастает» чего и по сравнению с чем?
                                                                                                                              0
                                                                                                                              Multilayer Neural Network with Multi-Valued Neurons

                                                                                                                              О таком не знаю. Чем он отличается от MLP+BackProp?
                                                                                                                                0
                                                                                                                                Можете дать ссылку на автора, который придумал Multilayer Neural Network with Multi-Valued Neurons?
                                                                                                                                  0
                                                                                                                                  ;)
                                                                                                                                  гуглим
                                                                                                                                    –3
                                                                                                                                    мне это не надо
                                                                                                                                      0
                                                                                                                                      Да и походу вы сами не знаете кто автор, этого вида сети :)
                                                                                                                                        0
                                                                                                                                        А я понял — это ваш руководитель придумал, и вы решили попиариться в теме об ИНС. Так вот, как только дадите сравнение вашей сети с перцептроном Розенблатта — я буду это серьезно рассматривать, а пока увы… не интересно.
                                                                                                                                          +1
                                                                                                                                          ;)
                                                                                                                                          Очень приятно видель ваши ответы. ;)

                                                                                                                                          Сранение.
                                                                                                                                          Чего с чем?

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

                                                                                                                                          Много хорошего слышал о Рижской школе. Но некоторые ее представители могут перечеркнуть все услышанное.
                                                                                                                                            0
                                                                                                                                            Это Вы о своей сети с такими эпитетами? Увы, вам пожалуй надо знать что перцептрон Розенблатта изобрел не я :) а описан он в классике в книге Principles of Neurodynamic: Perceptrons and the Theory of Brain Mechanisms. Вот с ним я и предлагаю вам сравнить ваше новое изобретение. Только тогда оно будет интересно другим, чтобы посмотреть что это такое.
                                                                                                                                              0
                                                                                                                                              Ах, да вы наверное не в курсе, что уровень рецензирования перцептрона Розенблатта был на порядок выше ВСЕХ существующих ИНС. Поэтому давайте по скромнее о своих Multilayer Neural Network with Multi-Valued Neurons
                                                                                                                            0
                                                                                                                            У меня ваш код не компилируется.
                                                                                                                              0
                                                                                                                              а он не претендует на это :) (в статье не раз об этом сказано), но там все легко поправить
                                                                                                                                0
                                                                                                                                Вот и поправьте. Потому что иначе это выглядит как голословное утверждение «мой код работает быстрее» (но я вам его не дам).
                                                                                                                                  –1
                                                                                                                                  Если Вы хотите разобраться, а не по холиваривать — то это вам надо править. Причем баги там до смешного простые, если вы с этим справится не можете, то не стоит этим заниматься вообще. Учитесь!
                                                                                                                                    0
                                                                                                                                    Вообще-то, бремя доказательства лежит на утверждающем.

                                                                                                                                    А выкладывать некомпилируемый (вплоть до отсутствия методов) код — неуважение к читателю.
                                                                                                                                      –1
                                                                                                                                      Я статью не пробовали читать, не видели что ли: «Полный код я выкладывать не буду.» Именно потому, что куча халявщиков, которые не хотят учится и разбираться. Код выложен как псевдокод, а статья имеет чисто обучающие цели.
                                                                                                                                    –1
                                                                                                                                    Но если вам что-то действительно не получается исправить напишите, подскажу так и быть.
                                                                                                                                      +1
                                                                                                                                      Я уже написал — не компилируется. Не совпадают типы, нет как минимум одного метода и так далее.
                                                                                                                                        –1
                                                                                                                                        Для проверки скорости вам тот метод не нужен — комментируйте, а Perceptron2=cNeironNet. tReaction — тоже для теста выкидывайте
                                                                                                                                          +1
                                                                                                                                          Нет уж, давайте мы будем делать полное тестирование — т.е., с обучением и распознаванием.

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

                                                                                                                                              Слишком уж много всего надо додумывать — и как сохранить реакцию, и в каком порядке что вызывать, и что куда что пишет… я бы все-таки предпочел увидеть просто полный работающий код. Это намного понятнее.
                                                                                                                                                –1
                                                                                                                                                А меня наводит на мысль, что вы программировать не умеете, когда сделать простое переприсваивание и подкорректировать типы — так сложно.
                                                                                                                                                  0
                                                                                                                                                  Если в коде надо «подкорректировать типы» — то он никогда не работал. Это наводит на мысли, что он собран из разных мест (если не допускать того варианта, что он просто написан без запуска). Соответственно, лучше пусть его собирает автор, чем я — я, поскольку не в теме, могу что-то напутать.
                                                                                                                                                +1
                                                                                                                                                * facepalm * Теперь понимаю, почему вы полностью тестировать не хотели…
                                                                                                                                                  0
                                                                                                                                                  вот, как только вы сделаете, то что обещали напишите и выложите код для сравнения MLP+BackProp на F#. Я выложу свой текст. Его действительно в удобочитаемом виде нету, я его выбрал из более сложной разработки по нейросетям.

                                                                                                                                                  Ну, и потом с такими троллями как вы и ваш товарищ мне разговаривать неприятно. Как только появятся приличные люди — и разговор будет другой.
                                                                                                                                                    0
                                                                                                                                                    Я свой код выложу тогда, когда буду полностью уверен, что он работает и прилично выглядит.
                                                                                                                                  –1
                                                                                                                                  Я уже думаю, что softpatent был в чем то прав, надо патентовать и продавать, тогда хотя бы будет смысл «смазывать и подслащать» покупателю. А так одни претензии, и ни грамма уважения.

                                                                                                                                    0
                                                                                                                                    Просто публикуйтесь
                                                                                                                                    Право первого упоминания принесет намного больше чем патент.

                                                                                                                                    Да и о каком патенте может идти речь, если Фрэнк Розеблатт все это уже описал? ;)

                                                                                                                                  Only users with full accounts can post comments. Log in, please.