Форум программистов, компьютерный форум, киберфорум
Наши страницы
Искусственный интеллект
Войти
Регистрация
Восстановить пароль
 
 
Рейтинг 4.78/9: Рейтинг темы: голосов - 9, средняя оценка - 4.78
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
1

Простая задача, но сеть уходит в континуум

25.10.2016, 09:06. Просмотров 1632. Ответов 34
Метки нет (Все метки)

Здравствуйте.
Сеть: 10 входов, изначально связи нейронов N<->N, 1 нейрон на выходном слое, F сигмоид.
Вроде самую примитивную задачу поставил: научиться считать количество "1" и "0" в примере. Но не получается и всё, при обучении сеть после 5-7 итераций схватывает контузий.
Вывод выглядит так:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0,4994      0,999
0,4975      0,993
0,4861      0,96
0,4345      0,828
0,3154      0,581
0,222       0,395
0,1928      0,301
0,1856      0,252
0,1838      0,225
0,1832      0,209
0,183       0,199
0,183       0,192
0,1831      0,188
0,1831      0,185
0,1831      0,183
...................................
Первый столбец - это ошибка сети, второй - значение выхода на последнем примере выборки, там ожидается "0". Но к "0" так и не приближается.
Порог количества итераций обучения = 500, затем параметры сети сбрасываются, заново заполняются веса случайными числами. Но результат всё тот же, десяток итераций и привет.

Заполнял малыми, очень малыми весами, нулями - результат тот же.
Количество скрытых слоёв не оказывает влияния на итоги решений. Только сеть быстрее сваливается в сингулярность.
Возможно, что ошибка в структуре сети, только я не вижу её. Либо какая-нибудь ламерская ошибка, либо всё к чёрту неверно.
Прошу помочь знатоков, разглядеть где тут собака.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
const iLayersCount = 5;
const iDendrCount = 10;
const double dLearnStep = 0.01;
const double dHighValueErr = 0.12;
const iUotputCount = 1;
const double dImpulse = 0.5;
const int iIterations = 100;
//5 слоёв, включая 1 входной; выходной слой из одного нейрона (класс описан отдельно)
 
//Нейрон---------------------------------------------------------------------------------------
class TNeuron{
 public:
 double dSumm;
 double dDendr[iDendrCount];
 double dWeights[iDendrCount];
 double dExtremum[iDendrCount];
 double dDemWeights[iDendrCount];//"история" изменения весов
 double dSigma;
 
 TNeuron(){
   dSumm = 0;
   dSigma = 0;
   for ( int i = 0; i<iDendrCount; i++)
       dWeights[i] =  = (double)(rand()%200)/200.000;
   for ( int i = 0; i<iDendrCount; i++) dExtremum[i] = 1;
   for ( int i = 0; i<iDendrCount; i++) dDendr[i] = 0;
   for ( int i = 0; i<iDendrCount; i++) dDemWeights[i] = dWeights[i];
 }
 
  double _Func(){//acson
  dSumm = 0;
  for ( int i = 0; i < iDendrCount; i++){
        dSumm += dDendr[i]*dWeights[i];
      }
  return RoundingTo( 1/( 1 + exp(-1.1*dSumm)), -3);
 }
 
};
 
//Нейрон выходного слоя---------------------------------------------------------------
class TDecision{
 public:
 double dSumm;
 double dWeights[iDendrCount];
 double dDemWeights[iDendrCount];
 double dDendr[iDendrCount];
 double dSigma;
 TDecision(){
  dSumm = 0;
  dSigma = 0;
  for ( int i = 0; i<iDendrCount; i++)
      {
      double dd = (double)(rand()%200)/200.000;
      dWeights[i] = dd;
      }
  for ( int i = 0; i<iDendrCount; i++) dDendr[i] = 0;
  for ( int i = 0; i<iDendrCount; i++) dDemWeights[i] = dWeights[i];
 }
 
  double _Func(){//acson
  dSumm = 0;
  for ( int i = 0; i < iDendrCount; i++)
      {
        dSumm += dDendr[i]*dWeights[i];
      }
  return RoundingTo( 1/( 1 + exp(-1.1*dSumm)), -3);
 }
 
};
 
//класс слоя сети------------------------------------------------------------------------------
class TLayer{
 public:
 TNeuron *Neurones[iDendrCount];
 double dSigma;
 TLayer(){
  dSigma = 0;
  for ( int i = 0; i<iDendrCount; i++)
      Neurones[i] = new TNeuron();
 }
};
 
//класс сеть----------------------------------------------------------------------------
class TNetwork{
 public:
 TLayer *layers[iLayersCount];
 TDecision *dDec[iUotputCount];
 TNetwork(){
  for ( int i = 0; i<iLayersCount; i++){
        layers[i] = new TLayer();
      }
  for ( int i = 0; i<iUotputCount; i++){
        dDec[i] = new TDecision;
      }
 }
};
TNetwork* Net;
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
double _fastcall CalcSigmasOnLayer( int iLayer, int idxW)//сигмы внутренних слоёв
{
 double dSum = 0;
 if ( iLayer == iLayersCount)//это последний скрытый слой
    {
      for ( int N = 0; N < iUotputCount; N++)
          dSum += Net->dDec[N]->dSigma * Net->dDec[N]->dWeights[idxW];//сигма_выхода* вес_нейрона
    }
    else
    for ( int N = 0; N<iDendrCount; N++)//остальные внутренние слои
     {
       dSum += Net->layers[iLayer]->Neurones[N]->dSigma * Net->layers[iLayer]->Neurones[N]->dWeights[idxW];
     }
 return dSum;
}
 
//----------------------------------------------------------------------------------------------
double _fastcall CalcSigmasOnDec( double dY)//сигма выходного слоя
{
 double dSum = 0;   
 double dOut = Net->dDec[idxW]->_Func();//у сети всего один нейрон на выходном слое
 Net->dDec[idxW]->dSigma = dOut*(1-dOut)*(dY-dOut);
 return Net->dDec[idxW]->dSigma;
}
 
//----------------------------------------------------------------------------------------------
void CalcSigmasOnNeuron()//Сигма по нейронам скрытых слоёв
{
 for ( int N = 0; N<iDendrCount; N++)//последний скрытый слой
     {
       double dOut = Net->layers[iLayersCount-1]->Neurones[N]->_Func();//значение выхода нейрона слоя
       double dSigmaOnLayer = CalcSigmasOnLayer(iLayersCount, N);//сигма выходного слоя
       Net->layers[iLayersCount-1]->Neurones[N]->dSigma = dOut*(1-dOut)*(dSigmaOnLayer);
     }
 
 for ( int L = iLayersCount-2; L>0; L--)//внутренние слои, кроме последнего
     {
       for ( int N = 0; N<iDendrCount; N++)
           {
             double dOut = Net->layers[L]->Neurones[N]->_Func();
             Net->layers[L]->Neurones[N]->dSigma = dOut*(1-dOut)*CalcSigmasOnLayer(L+1, N);
           }
     }
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void CorrectNetWeights()//корректировка весов сети
{
 for ( int N = 0; N < iUotputCount; N++)//выходной слой
     {
       for ( int i = 0; i<iDendrCount; i++) {
             Net->dDec[N]->dDemWeights[i] = dLearnStep*Net->dDec[N]->dSigma + dImpulse*Net->dDec[N]->dDemWeights[i];
             Net->dDec[N]->dWeights[i] = Net->dDec[N]->dWeights[i] + Net->dDec[N]->dDemWeights[i];
           }
     }
 
for ( int L = iLayersCount-1; L>0; L--) {
     for ( int N = 0; N<iDendrCount; N++) {
         for ( int i = 0; i <iDendrCount; i++) {
                   Net->layers[L]->Neurones[N]->dDemWeights[i] = dLearnStep * Net->layers[L]->Neurones[N]->dSigma +
                                                                 dImpulse * Net->layers[L]->Neurones[N]->dDemWeights[i];
                   Net->layers[L]->Neurones[N]->dWeights[i] = Net->layers[L]->Neurones[N]->dWeights[i] +
                                                              Net->layers[L]->Neurones[N]->dDemWeights[i];
             }
         }
     }
 
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//Запуск обучения
String sInput[] = { "10010110111",//7
                     "11010110111",//8
                     "10010110000",//4
                     "10010110000",//4
                     "10010100000",//3
                     "10100110000",//4
                     "10000100000",//2
                     "10010111101",//7
                     "11010111101",//8
                     "01000101100"//4
                   };//обучающая выборка
 
while ( dErr_Current>dHighValueErr)
 {
 dErr_Current = 0;
 
 int iSz = sizeof(sInput)/4;//колво элементов в обучающей выборке
 
 for ( int Y = 0; Y<iSz; Y++)
       {
         sAwaited = sInput[Y][10];//ожидаемое значение выхода
 
         int iSzR = sInput[Y].Length();
         for ( int i = 0; i<iSzR; i++) {
               Net->layers[0]->Neurones[0]->dDendr[i] = String(sInput[Y][i+1]).ToInt();//подали сигналы на вход
             }
 
         //расчёт сети==============================================
          for ( int L = 1; L<iLayersCount; L++)//текущий слой
              {
                 for ( int N = 0; N < iDendrCount; N++)//нейроны текущего слоя
                     {
                       for ( int D = 0; D<iDendrCount; D++)//дендриты текущего нейрона текущего слоя
                           {
                             Net->layers[L]->Neurones[N]->dDendr[D] = Net->layers[L-1]->Neurones[D]->_Func();
                             double fff = Net->layers[L]->Neurones[N]->dDendr[D];
                           }
                     }
              }
 
           for ( int O = 0; O < iUotputCount; O++){
                 for ( int D = 0; D<iDendrCount; D++){
                       double dT = Net->layers[iLayersCount-1]->Neurones[D]->_Func();
                       Net->dDec[O]->dDendr[D] = dT;
                     }
               }
 
         double dOutput = Net->dDec[0]->_Func();
 
         //завершение расчёта сети======================================
 
         double dA_ = 0;//ожидаемые значения
 
         if ( sAwaited == "1")
            dA_ = 1;
 
         CalcSigmasOnDec( dA_);//расчёт сигмы на нейронах(-оне) выходного слоя
         CalcSigmasOnNeuron();//сигмы скрытых слоёв
         CorrectNetWeights();//корректировка весов
 
         double dEsum = fabs( pow(dOutput-dA_, 2)) * 0.5;
       }//for
 
   dErr_Current = (dErr_Current+1)/iSz;
 }
Добавлено через 9 минут
"10010110111" - обучающая выборка, считаются первые 10 элементов, [11] - ожидаемый ответ сети
sAwaited = sInput[Y][11];//ожидаемое значение выхода
0
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
25.10.2016, 09:06
Ответы с готовыми решениями:

Континуум
Добрый вечер! Проверьте, пожалуйста, правильность изложенного ниже. Доказать, что множество всех...

Простая нейронная сеть
Доброго времени суток, встал такой вопрос: Имеется неравенство x1 - x2 + 0.5 &gt;= 0. Это неравенство...

Дешевая простая домашная беспроводная сеть
Нужно связать несколько девайсов разного назначения с компьютером. Без проводов. Передавать большие...

Простая нейронная сеть для обхода препятствий (C# + Unity3d)
Всем привет, хочется написать простую нейронную сеть для обхода объектом препятствий. То есть есть...

Нет подключения роутера, простая сеть в Cisco Packet Tracer
Всем доброго времени суток! В общем такое дело, решил изучить сетевые технологии, в колледже сети...

34
VTsaregorodtsev
572 / 520 / 77
Регистрация: 19.02.2010
Сообщений: 1,908
25.10.2016, 11:16 2
Цитата Сообщение от IR001 Посмотреть сообщение
Вроде самую примитивную задачу поставил: научиться считать количество "1" и "0" в примере.
Задача - бред.
Код тоже... неоптимальный, например.
0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
25.10.2016, 16:25  [ТС] 3
В коде много ошибок, правлю.
А чем задача плоха? Где-то на просторах интернета видел: "понимать больше единиц в выборке или нет". Достаточно просто для начала, полагаю.
0
warhast
20 / 20 / 4
Регистрация: 02.02.2014
Сообщений: 77
25.10.2016, 16:55 4
Хорошей идеей было бы представить вычисления в виде операций над матрицами/векторами. Без этого как-то даже пытаться вникать в код не тянет. Но что успел увидеть - нету bias-ов, а значит нулевые входы обрабатываются хуже чем могли бы.
0
VTsaregorodtsev
572 / 520 / 77
Регистрация: 19.02.2010
Сообщений: 1,908
26.10.2016, 22:06 5
Цитата Сообщение от warhast Посмотреть сообщение
Хорошей идеей было бы представить вычисления в виде операций над матрицами/векторами.
Не, можно даже и не ожидать.
Покуда в учебниках это не излагается - никто из новичков до такого варианта и не додумывается. Отказаться от такой абстракции, как "нейрон" - да ни в жизнь, раз именно эта абстракция используется в тексте учебника.
Более того, глядя на формулы коррекции весов сети в учебниках - никто не додумывается и до выноса в матем.выражениях некоторого инварианта за скобки, хотя в школе это вроде как должны были изучать.
0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
29.10.2016, 19:46  [ТС] 6
Исправил ошибки в коде. Нашёл вариант задачи. Классификация по данным RGB, решение "к какому цвету ближе".
Работает. Очень интересно Но это в однослойном виде.
Теперь тружусь над многослойным вариантом. Конечно, всё сложнее для понимания. Почему-то веса связей скрытых слоёв изменяются у каждого нейрона равномерно.
Алгоритм корректировки сейчас таков (обратное распространение сигнала):
- суммирование ошибки на следующем слое (J+1) по каждому элементу N(j+1)слоя в зависимости от веса связи с нейроном N(j) слоя (J);
- изменение веса в зависимости от выхода сумматора нейрона N(j).

Возможно, что мной не понята пока ещё мат модель алгоритма.

Добавлено через 5 минут
это вроде как должны были изучать.
Школу я прогуливал, честно сказать. 20 лет назад. А интерес к НС появился три года назад, когда пытался сделать программу под личные нужды. И она как-то умудрялась работать. Но в итоге, разумеется, стало очевидно, что что-то сделано явно не так, как нужно. И теперь сел за изучение сызновь, не спеша и стараясь понять каждый момент. Мало того, что вся теория забыта, так она ещё и прочитана/понята была неправильно. Так что благодаря Великому Рандому программа всё же работала .

Но ведь как здорово, что на форуме есть такие светилы от Бога, как Вы!
0
Mikhaylo
202 / 189 / 24
Регистрация: 20.09.2014
Сообщений: 1,360
29.10.2016, 19:52 7
Мне трудно отследить в Вашей программе начало-конец, но мне кажется нужно обратить внимание на порядок обсчета весов сети. Сначала просчитываются веса входных нейронов сверху вниз, затем веса первого скрытого слоя, затем веса второго скрытого слоя и так далее.
0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
31.10.2016, 17:55  [ТС] 8
Mikhaylo, именно так.

Добавил скрытые слои. И вернулся обратно, к нерабочему коду.
Экспериментировал с количество слоёв(2-4, вкл. 1 входной) и нейронов(от 3-х до 9-и) в них.
Шаг обучения почти не играет роли сейчас. И убрал смещение и импульс.
Получилось вот так:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
const iLayersCount = 3;//количество скрытых слоёв, класс layers
const iHidden_N = 3;//количество нейронов в скрытом слое(-ях), класс Neurones
const iOutput_Y = 9;//количество нейронов выходного слоя, соответствует обучаемым ответам
//класс выходного слоя описан отдельно классом dDec.
 
//обучающая выборка
String sClrDisplay[iOutput_Y] = { "Красный", "Зеленый", "Синий", "Желтый",
                                  "Розовый", "Голубой", "Серый", "Черный", "Белый"
                                };
 int dInputTeach[9][4] = { {255,0,0, 0}, {0,255,0, 1}, {0,0,255, 2}, {255, 150, 0,  3},
                           {255, 0, 255, 4}, {0, 255, 255, 5}, {120, 120, 120, 6}, {0,0,0, 7}, {255, 255, 255, 8}
                         };
 
void CalcSigmaOnNeuron( int iLayer, int idxN)
{//iLayer - слой текущего нейрона, idxN - индекс текущего (вычисляемого) нейрона
 double dSumm = 0;
 if ( iLayersCount-1 == iLayer) {//если последний скрытый слой
      for ( int N = 0; N<iOutput_Y; N++) //ошибка от выходного слоя = веса i-связи * сигма_нейрона_выходного_слоя 
          dSumm += Net->dDec[N]->dWeights[idxN] * Net->dDec[N]->dSigma;
      //сигма скрытого слоя = значение_производной_F() на скрытом слое * ошибка_от_выходного_слоя;
      Net->layers[iLayer]->Neurones[idxN]->dSigma =  Net->layers[iLayer]->Neurones[idxN]->dOut * (1-Net->layers[iLayer]->Neurones[idxN]->dOut)* (dSumm);
    }
    else {
      for ( int N = 0; N<iHidden_N; N++) //веса связи с нейроном на следующем скрытом слое с текущим нейроном   *  сигмы соответствующих нейронов следующего слоя
          dSumm += Net->layers[iLayer+1]->Neurones[N]->dWeights[idxN] * Net->layers[iLayer+1]->Neurones[N]->dSigma;
      Net->layers[iLayer]->Neurones[idxN]->dSigma =  Net->layers[iLayer]->Neurones[idxN]->dOut * (1-Net->layers[iLayer]->Neurones[idxN]->dOut)* (dSumm);
    }
 
}
//--------------------------------------------------------------------------
//корректировка весов сети
void CorrectNetWeights( int dA_[])
{ //dA_[] массив с ожидаемыми ответами, например [0,0,0,1,0,0,0,0]
 
 //корректировка весов связей нейронов выходного слоя
 for ( int N = 0; N<iOutput_Y; N++) {
     //сигма нейрона выходного слоя = производная_F() * сигнал_ошибки; здесь получаем знак корректировки
     Net->dDec[N]->dSigma = Net->dDec[N]->dOut * (1-Net->dDec[N]->dOut) * ((double)dA_[N] - Net->dDec[N]->dOut);
     for ( int i = 0; i < iHidden_N; i++) {
         //изменение i-веса = сигма_нейрона * входной_сигнал_по_i-связи
         double deltaW = Net->dDec[N]->dSigma * Net->dDec[N]->dDendr[i] * dLearnStep;
         Net->dDec[N]->dWeights[i] = Net->dDec[N]->dWeights[i] + deltaW;
         //Net->dDec[N]->dBias = Net->dDec[N]->dBias + deltaW;
     }
 }
 
 //корректировка весов связей нейронов скрытых слоёв, за исключением выходного слоя
 for ( int L = iLayersCount-1; L > 0; L--) {
     for ( int N = 0; N < iHidden_N; N++) {
         CalcSigmaOnNeuron( L, N);//вычисление сигмы ответа текущего нейрона
         for ( int i = 0; i< iHidden_N; i++) {//перебор связей нейрона
             double deltaW = Net->layers[L]->Neurones[N]->dSigma * Net->layers[L]->Neurones[N]->dDendr[i] * dLearnStep;
             Net->layers[L]->Neurones[N]->dWeights[i] = Net->layers[L]->Neurones[N]->dWeights[i] + deltaW;
             //Net->layers[L]->Neurones[N]->dBias = Net->layers[L]->Neurones[N]->dBias + deltaW;
         }
     }
 }
}
Прошу уважаемых участников форума подтвердить или опровергнуть верен ли данный алгоритм обучения.
При передаче входных сигналов сразу на выход программа считает более-менее. Странно, но пограничные ответы "белый", "чёрный" не верны даже после 10 000 итераций обучения. Сред. кв. ошибка зависает в районе 0.36.

Добавлено через 4 минуты
Да, вот симптомы: веса связей скрытых слоёв остаются равны друг другу в контексте слоя, следовательно и выходной сигнал от всех нейронов одинаков; веса всех связей выходного слоя уходят в минус; сигма нейронов внутренних слоёв становится ничтожно малой. Впечатление, что алгоритм корректировки отрабатывает только для связей неройнов выходного слоя.
0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
02.11.2016, 16:21  [ТС] 9
Исправил несколько небольших ошибок в коде, добавил смещение. Заработала.
Но как: только к 50 000 итераций. При чём по пути пройдя 4 или 5 локальных минимумов.
5 слоёв, 4 нейрона в каждом (вкл один для смещения), 9 на выходе. Выборка 9 примеров на те самые 9 нейронов выходного слоя.
Неужели для многослойной сети такое долгое время настройки адекватно? Однослойный вариант настраивается в момент, конечно.
0
warhast
20 / 20 / 4
Регистрация: 02.02.2014
Сообщений: 77
02.11.2016, 17:21 10
Чем больше слоев - тем больше зависимость от начального заполнения весов, хотя 50к эпох - как-то слишком для 5 слоев. См. что писал по этому поводу тот же Xavier Glorot лет 6 назад - не то чтобы самый свежий подход к проблеме, зато точно один из простейших в реализации.
0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
02.11.2016, 17:30  [ТС] 11
Спасибо за ответ. Ещё подумаю в чём может быть тормоз.
Но с начальных весов = 1 быстрее сеть настраивается. С Его Величества Рандома более 100 000 итераций.
Может ещё точность неверно считаю, конечно, посмотрю. Но догоняю до E=0.0001 и стоп.
0
warhast
20 / 20 / 4
Регистрация: 02.02.2014
Сообщений: 77
02.11.2016, 21:06 12
Цитата Сообщение от IR001 Посмотреть сообщение
веса связей скрытых слоёв остаются равны друг другу в контексте слоя, следовательно и выходной сигнал от всех нейронов одинаков
следует из
Цитата Сообщение от IR001 Посмотреть сообщение
Но с начальных весов = 1 быстрее сеть настраивается.
0
woodbox
03.11.2016, 00:47
  #13

Не по теме:

... и понеслась

0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
03.11.2016, 09:41  [ТС] 14
следует из
Боюсь, что не понял Вас. Но дело в том, что изначально были ошибки в коде. И в мат. модели. Существенно улучшает обучение введение смещения (bias), импульса. Более того, при всей кривизне кода делал не более 1000 итераций. После чего видел не_большие изменения в весах (до 5-6 порядка в дробной части) и сдавался.

Сегодня довёл точность до 0.00001. Но интересно, что при переходные цвета перестали угадываться также часто, как было при намного меньшей СКВ ошибке. То есть если подать ( 200, 200, 90) сеть выдаст серый-голубой. Это конечно ошибочно, потому как в реальности цвет больше похож на серо-жёлтый.
Полагаю, что проблема в малой обучающей выборке (всего-то 9 примеров, по 1 на каждый элемент выходного слоя). Моё предположение верно?
То есть думаю так, надо будет добавить, скажем, ещё смешанных цветов с ожиданием сигналов по указанному выше примеру 0.7 по элементам выходного слоя "жёлтый" и "серый". Сделать большую выборку по градации цвета не составляет особого труда, пожалуй. И тогда попробовать определить переходные. Вот так, да?
С академии помню, что адекватной выборка будет только от 2000 примеров. О репрезентативности мне вообще сложно пока судить. Предметная область простая слишком.
0
woodbox
07.11.2016, 01:23
  #15

Не по теме:

Ответ - то есть? :)

0
Excalibur921
767 / 463 / 80
Регистрация: 12.10.2013
Сообщений: 3,115
08.11.2016, 14:39 16
Может я неправильно понял…
Цитата Сообщение от IR001 Посмотреть сообщение
"понимать больше единиц в выборке или нет".
Цитата Сообщение от IR001 Посмотреть сообщение
Сеть: 10 входов,
Т.е. вход: массив 0,1 из 10 элементов.
Выход: чего в массиве больше 0 или 1?
Если интеграл больше 5 то больше единиц.
Зачем тут нейросеть?

Цитата Сообщение от IR001 Посмотреть сообщение
Классификация по данным RGB, решение "к какому цвету ближе"
Т.е. вход: картинка RGB 10 пикселей
Выход: какой средний цвет всего поля.
Интеграл цвета всех субпикселей делим на их количество. Получим средний цвет.
Зачем тут нейросеть?
0
IR001
0 / 0 / 0
Регистрация: 25.10.2016
Сообщений: 14
Завершенные тесты: 1
08.11.2016, 16:05  [ТС] 17
Excalibur921, действительно, нейросеть для подсчёта количества единиц не нужна, достаточно идентификатора, унарного оператора ++ и оператора условия if Задачу подбирал. Нашёл интереснее и, пожалуй, подходящую для задач под ИНС.
Тоже самое и с цветами. Поиск задачи, чем проще для начала, тем лучше.

Сетка работает. Более-менее вроде понял теорию. Не уверен, но на всякий случай книжки умные читаю в свободное время.
Пока не разобрался только почему требуется такое количество эпох для приведения весов в годный вид.
0
Excalibur921
767 / 463 / 80
Регистрация: 12.10.2013
Сообщений: 3,115
08.11.2016, 18:07 18
Зачем здесь нейросеть?
“Пример задачи, которую хочу решить с помощью нейронной сети:
на вход поступают 2 числа в диапазоне [0..1], на выходе хочу получить в качестве ответа 1 - если первое число больше второго и 0 - если второе число больше первого.”
Нейронная сеть для сравнения двух чисел

А здесь зачем?
“что я должен подавать на вход нейронной сети?”
Обучение и применение нейронной сети для прохождения игры

В таком стиле заданий можно 1+0.001 искать численно дихотомией начиная с 1000 000 но зачем?

Мне кажется самый простой и наглядный hello world для нейросети это распознать искаженную букву. Но и здесь, 99.9% работы это задача фильтров а нейросеть как огромный switch case. Может и не понял сути…
0
transformator.t
defun
597 / 611 / 44
Регистрация: 30.04.2011
Сообщений: 698
08.11.2016, 18:17 19
Цитата Сообщение от Excalibur921 Посмотреть сообщение
наглядный hello world для нейросети это
xor
0
warhast
20 / 20 / 4
Регистрация: 02.02.2014
Сообщений: 77
08.11.2016, 18:39 20
xor-ами нейросети лет 50 назад троллили, сейчас на роль hello world-а как то MNIST больше тянет.
0
08.11.2016, 18:39
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
08.11.2016, 18:39

Простая задача.
Пожалуйста помогите кто может, очень нужно Даны натуральное число n, действительные числа...

Простая задача
Помогите пожалуйста решить. Имеется в наличии 3 арбуза. Найти самый тяжелый. Примечание: решить...

Не простая задача
Необходимо отправить из js запрос, трудность в слудующем. Один из параметров это url текущей...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
20
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.
Рейтинг@Mail.ru