Форум программистов, компьютерный форум, киберфорум
C# для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.55/11: Рейтинг темы: голосов - 11, средняя оценка - 4.55
24 / 23 / 3
Регистрация: 21.04.2012
Сообщений: 253
1

Нейросеть

17.01.2017, 03:11. Просмотров 2214. Ответов 2
Метки нет (Все метки)


Кликните здесь для просмотра всего текста
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
using System;
using System.IO;
using System.Runtime.InteropServices;
 
 
namespace ClassLibraryNeuralNetworks
{
 
    // Структура дря разбиения переменных типа int и double на байты
    [StructLayout(LayoutKind.Explicit)]
    internal class DataToByte
    {
        [FieldOffset(0)]
        public double vDouble;
 
        [FieldOffset(0)]
        public int vInt;
 
        [FieldOffset(0)]
        public byte b1;
        [FieldOffset(1)]
        public byte b2;
        [FieldOffset(2)]
        public byte b3;
        [FieldOffset(3)]
        public byte b4;
        [FieldOffset(4)]
        public byte b5;
        [FieldOffset(5)]
        public byte b6;
        [FieldOffset(6)]
        public byte b7;
        [FieldOffset(7)]
        public byte b8;
    }
 
    // Класс - слой нейросети
    public class LayerNW
    {
        double[,] Weights;
        int cX, cY;
 
        // Заполняем веса случайными числами
        public void GenerateWeights()
        {
            Random rnd = new Random();
            for (int i = 0; i < cX; i++)
            {
                for (int j = 0; j < cY; j++)
                {
                    Weights[i, j] = rnd.NextDouble() - 0.5;
                }
            }
        }
 
        // Выделяет память под веса
        protected void GiveMemory()
        {
            Weights = new double[cX, cY];
        }
 
        // Конструктор с параметрами. передается количество входных и выходных нейронов
        public LayerNW(int countX, int countY)
        {
            cX = countX;
            cY = countY;
            GiveMemory();
        }
 
        public int countX
        {
            get { return cX; }
        }
 
        public int countY
        {
            get { return cY; }
        }
 
        public double this[int row, int col]
        {
            get { return Weights[row, col]; }
            set { Weights[row, col] = value; }
        }
 
    }
 
    // Класс - нейронная сеть
    public class NeuralNW
    {
        LayerNW[] Layers;
        int countLayers = 0, countX, countY;
        double[][] NETOUT;  // NETOUT[countLayers + 1][]
        double[][] DELTA;   // NETOUT[countLayers    ][]
 
        // Конструкторы
        /* Создает полносвязанную сеть из 1 слоя. 
           sizeX - размерность вектора входных параметров
           sizeY - размерность вектора выходных параметров */
        public NeuralNW(int sizeX, int sizeY)
        {
            countLayers = 1;
            Layers = new LayerNW[countLayers];
            Layers[0] = new LayerNW(sizeX, sizeY);
            Layers[0].GenerateWeights();
        }
 
        /* Создает полносвязанную сеть из n слоев. 
           sizeX - размерность вектора входных параметров
           layers - массив слоев. Значение элементов массива - количество нейронов в слое               
         */
        public NeuralNW(int sizeX, params int[] layers)
        {
            countLayers = layers.Length;
            countX = sizeX;
            countY = layers[layers.Length - 1];
            // Размерность выходов нейронов и Дельты
            NETOUT = new double[countLayers + 1][];
            NETOUT[0] = new double[sizeX];
            DELTA = new double[countLayers][];
 
            this.Layers = new LayerNW[countLayers];
 
            int countY1, countX1 = sizeX;
            // Устанавливаем размерность слоям и заполняем слоя случайнымичислами
            for (int i = 0; i < countLayers; i++)
            {
                countY1 = layers[i];
 
                NETOUT[i + 1] = new double[countY1];
                DELTA[i] = new double[countY1];
 
                this.Layers[i] = new LayerNW(countX1, countY1);
                this.Layers[i].GenerateWeights();
                countX1 = countY1;
            }
        }
 
        // Открывает НС
        public NeuralNW(String FileName)
        {
            OpenNW(FileName);
        }
 
        // Открывает НС
        public void OpenNW(String FileName)
        {
            byte[] binNW = File.ReadAllBytes(FileName);
 
            int k = 0;
            // Извлекаем количество слоев из массива
            countLayers = ReadFromArrayInt(binNW, ref k);
            Layers = new LayerNW[countLayers];
 
            // Извлекаем размерность слоев
            int CountY1=0, CountX1 = ReadFromArrayInt(binNW, ref k);
            // Размерность входа
            countX = CountX1;
            // Выделяемпамять под выходы нейронов и дельта
            NETOUT = new double[countLayers + 1][];
            NETOUT[0] = new double[CountX1];
            DELTA = new double[countLayers][];
 
            for (int i = 0; i < countLayers; i++)
            {
                CountY1 = ReadFromArrayInt(binNW, ref k);
                Layers[i] = new LayerNW(CountX1, CountY1);
                CountX1 = CountY1;
 
                // Выделяем память
                NETOUT[i + 1] = new double[CountY1];
                DELTA[i] = new double[CountY1];
            }
            // Размерность выхода
            countY = CountY1;
            // Извлекаем и записываем сами веса
            for (int r = 0; r < countLayers; r++)
                for (int p = 0; p < Layers[r].countX; p++)
                    for (int q = 0; q < Layers[r].countY; q++)
                    {
                        Layers[r][p, q] = ReadFromArrayDouble(binNW, ref k);
                    }
        }
 
        // Сохраняет НС
        public void SaveNW(String FileName)
        {
            // размер сети в байтах
            int sizeNW = GetSizeNW();
            byte[] binNW = new byte[sizeNW];
 
            int k = 0;
            // Записываем размерности слоев в массив байтов
            WriteInArray(binNW, ref k, countLayers);
            if (countLayers <= 0)
                return;
 
            WriteInArray(binNW, ref k, Layers[0].countX);
            for (int i = 0; i < countLayers; i++)
                WriteInArray(binNW, ref k, Layers[i].countY);
 
            // Зпаисвыаем сами веса
            for (int r = 0; r < countLayers; r++)
                for (int p = 0; p < Layers[r].countX; p++)
                    for (int q = 0; q < Layers[r].countY; q++)
                    {
                        WriteInArray(binNW, ref k, Layers[r][p, q]);
                    }
 
 
            File.WriteAllBytes(FileName, binNW);
        }
 
        // Возвращает значение j-го слоя НС
        public void NetOUT(double[] inX, out double[] outY, int jLayer)
        {
            GetOUT(inX, jLayer);
            int N = NETOUT[jLayer].Length;
 
            outY = new double[N];
 
            for (int i = 0; i < N; i++)
            {
                outY[i] = NETOUT[jLayer][i];
            }
 
        }
 
        // Возвращает значение НС
        public void NetOUT(double[] inX, out double[] outY)
        {
            int j = countLayers;
            NetOUT(inX, out outY, j);
        }
 
        // Возвращает ошибку (метод наименьших квадратов)
        public double CalcError(double[] X, double[] Y)
        {
            double kErr = 0;
            for (int i = 0; i < Y.Length; i++)
            {
                kErr += Math.Pow(Y[i] - NETOUT[countLayers][i], 2);
            }
 
            return 0.5 * kErr;
        }
 
        /* Обучает сеть, изменяя ее весовые коэффициэнты. 
           X, Y - обучающая пара. kLern - скорость обучаемости
           В качестве результата метод возвращает ошибку 0.5(Y-outY)^2 */
        public double LernNW(double[] X, double[] Y, double kLern)
        {
            double O;  // Вход нейрона
            double s;
 
            // Вычисляем выход сети
            GetOUT(X);
 
            // Заполняем дельта последнего слоя
            for (int j = 0; j < Layers[countLayers - 1].countY; j++)
            {
                O = NETOUT[countLayers][j];
                DELTA[countLayers - 1][j] = (Y[j] - O) * O * (1 - O);
            }
 
            // Перебираем все слои начиная споследнего 
            // изменяя веса и вычисляя дельта для скрытого слоя
            for (int k = countLayers - 1; k >= 0; k--)
            {
                // Изменяем веса выходного слоя
                for (int j = 0; j < Layers[k].countY; j++)
                {
                    for (int i = 0; i < Layers[k].countX; i++)
                    {
                        Layers[k][i, j] += kLern * DELTA[k][j] * NETOUT[k][i];
                    }
                }
                if (k > 0)
                {
 
                    // Вычисляем дельта слоя к-1
                    for (int j = 0; j < Layers[k - 1].countY; j++)
                    {
 
                        s = 0;
                        for (int i = 0; i < Layers[k].countY; i++)
                        {
                            s += Layers[k][j, i] * DELTA[k][i];
                        }
 
                        DELTA[k - 1][j] = NETOUT[k][j] * (1 - NETOUT[k][j]) * s;
                    }
                }
            }
 
            return CalcError(X, Y);
        }
 
        // Свойства. Возвращает число входов и выходов сети
        public int GetX
        {
            get { return countX; }
        }
 
        public int GetY
        {
            get { return countY; }
        }
 
        public int CountLayers
        {
            get { return countLayers; }
        }
        /* Вспомогательные закрытые функции */
 
        // Возвращает все значения нейронов до lastLayer слоя
        void GetOUT(double[] inX, int lastLayer)
        {
            double s;
 
            for (int j = 0; j < Layers[0].countX; j++)
                NETOUT[0][j] = inX[j];
 
            for (int i = 0; i < lastLayer; i++)
            {
                // размерность столбца проходящего через i-й слой
                for (int j = 0; j < Layers[i].countY; j++)
                {
                    s = 0;
                    for (int k = 0; k < Layers[i].countX; k++)
                    {
                        s += Layers[i][k, j] * NETOUT[i][k];
                    }
 
                    // Вычисляем значение активационной функции
                    s = 1.0 / (1 + Math.Exp(-s));
                    NETOUT[i + 1][j] = 0.998 * s + 0.001;
 
                }
            }
 
        }
 
        // Возвращает все значения нейронов всех слоев
        void GetOUT(double[] inX)
        {
            GetOUT(inX, countLayers);
        }
 
        // Возвращает размер НС в байтах
        int GetSizeNW()
        {
            int sizeNW = sizeof(int) * (countLayers + 2);
            for (int i = 0; i < countLayers; i++)
            {
                sizeNW += sizeof(double) * Layers[i].countX * Layers[i].countY;
            }
            return sizeNW;
        }
 
        // Возвращает num-й слой Нейронной сети
        public LayerNW Layer(int num)
        {
            return Layers[num]; 
        }
 
        // Разбивает переменную типа int на байты и записывает в массив
        void WriteInArray(byte[] mas, ref int pos, int value)
        {
            DataToByte DTB = new DataToByte();
            DTB.vInt = value;
            mas[pos++] = DTB.b1;
            mas[pos++] = DTB.b2;
            mas[pos++] = DTB.b3;
            mas[pos++] = DTB.b4;
        }
 
        // Разбивает переменную типа int на байты и записывает в массив
        void WriteInArray(byte[] mas, ref int pos, double value)
        {
            DataToByte DTB = new DataToByte();
            DTB.vDouble = value;
            mas[pos++] = DTB.b1;
            mas[pos++] = DTB.b2;
            mas[pos++] = DTB.b3;
            mas[pos++] = DTB.b4;
            mas[pos++] = DTB.b5;
            mas[pos++] = DTB.b6;
            mas[pos++] = DTB.b7;
            mas[pos++] = DTB.b8;
        }
 
        // Извлекает переменную типа int из 4-х байтов массива
        int ReadFromArrayInt(byte[] mas, ref int pos)
        {
            DataToByte DTB = new DataToByte();
            DTB.b1 = mas[pos++];
            DTB.b2 = mas[pos++];
            DTB.b3 = mas[pos++];
            DTB.b4 = mas[pos++];
 
            return DTB.vInt;
        }
 
        // Извлекает переменную типа double из 8-ми байтов массива
        double ReadFromArrayDouble(byte[] mas, ref int pos)
        {
            DataToByte DTB = new DataToByte();
            DTB.b1 = mas[pos++];
            DTB.b2 = mas[pos++];
            DTB.b3 = mas[pos++];
            DTB.b4 = mas[pos++];
            DTB.b5 = mas[pos++];
            DTB.b6 = mas[pos++];
            DTB.b7 = mas[pos++];
            DTB.b8 = mas[pos++];
 
            return DTB.vDouble;
        }
 
    }
}

Использую данный класс для самой сети.
Саму сеть обучаю передавая ей колличество букв в слове, первые две буквы и последние две буквы. На выходе - 2 значения - является ли слово, данные которого я передал - существительным.
Обучение провожу с learningRate 0.5 на обучающей выборке 33к слов.

Как это исправить? )

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for (int i = 0; i < w_count; i++)
            {
                double[] x = new double[3];
                double[] y = new double[2];
                for (int k = 0; k < 5; k++)
                {
                    if (k < 3)
                    {
                        x[k] = a[i][k];
                    }
                    else
                    {
                        
                        if (k == 3) y[0] = a[i][k];
                        if (k == 4) y[1] = a[i][k];
                    }
                }
                double error = net.LernNW(x, y, 0.5);
 
                Console.WriteLine("Error = " + error.ToString());
}
Передаю данные для определения:

C#
1
2
3
4
5
6
double[] outY = new double[2];
                double[] g = make_date(d);
                net.NetOUT(g, out outY);
                if (outY[0] > outY[1]) Console.WriteLine(d + "\r\nIt's not a noun");
                else if (outY[1] > outY[0]) Console.WriteLine("\r\nIt's a noun! ");
                outY = null;
Добавлено через 6 часов 37 минут
Подниму тему )

Добавлено через 9 часов 48 минут
Изменил выходные данные на массив из шести элементов, каждый отвечает своей части речи. И получается, что первые 3 элемента дают 0.999 и все. Независимо от введенного слова.
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
17.01.2017, 03:11
Ответы с готовыми решениями:

Неправильно обучается нейросеть
Вопрос, наверное, плохой, но уже не знаю что делать. Пишу нейросеть с 2 входными нейронами, одним...

Нейросеть, которая распознает символ
Здравствуйте,формучане. у меня такая задача-нужно сделать нейросеть, которая распознает символ,но...

Нейросеть для окрашивания изображений
Здравствуйте! Есть необходимость перевести (задача написать нейросеть для раскрашивания...

Научить нейросеть переводить двоичные числа в десятиричные
В общем. Задание :научить нейросеть переводить двоичные числа в десятиричные. С чего начинать...

__________________
Помогаю в написании студенческих работ здесь.
Записывайтесь на профессиональные курсы С#-разработчиков‌
2
2263 / 1721 / 511
Регистрация: 02.08.2011
Сообщений: 4,914
17.01.2017, 05:25 2
Видимо, вы неправильно обучаете сеть.
В backpropagation, если это backpropagation, нужно во всех слоях, начиная с последнего выполнять два шага:
1. Вычислить вектор ошибки для слоя.
2. Модифицировать веса этого слоя в соответствии с найденным вектором ошибки.
У вас же, предположительно, вектор ошибки один на все слои, отсюда и неверный результат.
Ошибка-то хоть уменьшается в процессе обучения на выборке?

Сейчас понимаю, это даже не backpropagation. Вы просто используете алгоритм для однослойного перцептрона на многослойную сеть, и то, afaik, там нужно изменять веса, только в случае если элемент из выборки
был отнесен к некорректному классу. Такое не будет работать.
1
24 / 23 / 3
Регистрация: 21.04.2012
Сообщений: 253
18.01.2017, 01:44  [ТС] 3
Кликните здесь для просмотра всего текста
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace xml_to_svc_base
{
    class Network
    {
        static int layerCnt;
        static int[] neuronCnt;
        static double[][] outNneuron;
        static double[][][] weight;
        static double[][] delta;
        static double[][][] prevDwt;
        static double alpha;
        static double beta;
 
 
 
        public Network(int nl, int[] sz, double b, double a)
        {            layerCnt = nl; // Кол-во слоев
 
            neuronCnt = new int[layerCnt];
            weight = new double[layerCnt][][];
            delta = new double[layerCnt][];
            prevDwt = new double[layerCnt][][];
            alpha = a;
            beta = b;
            neuronCnt = new int[layerCnt];
            for (int i = 0; i < layerCnt; i++)
            {
                neuronCnt[i] = sz[i]; // Кол-во нейроннов в слое i. neuronCnt[id слоя]
            }
 
            // Выделяем память для кажого выходного нейрона
            outNneuron = new double[layerCnt][];
            for (int i = 0; i < layerCnt; i++)
            {
                outNneuron[i] = new double[neuronCnt[i]]; // Значение на выходе нейрона. outNneuron[id слоя][id нейрона]
            }
            // Выделяем память для delta
            for (int i = 1; i < layerCnt; i++)
            {
                delta[i] = new double[neuronCnt[i]];
            }
            // Выделяем память для весов связей неронов
            // weight[id слоя нейрона][id нейрона][id предыдущего нейрона, с которым установленна связь]; 
            for (int i = 1; i < layerCnt; i++)
            {
                weight[i] = new double[neuronCnt[i]][];
            }
            for (int i = 1; i < layerCnt; i++)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    weight[i][j] = new double[neuronCnt[i - 1] + 1];
                }
            }
 
            // Выделяем память для предыдущего веса нейрона
            for (int i = 1; i < layerCnt; i++)
            {
                prevDwt[i] = new double[neuronCnt[i]][];
            }
            for (int i = 1; i < layerCnt; i++)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    prevDwt[i][j] = new double[neuronCnt[i]];
 
                    prevDwt[i][j] = new double[neuronCnt[i - 1] + 1];
                }
            }
 
            // Заполнить весы нейроннов случайными значениями
            /////////////////////
            Random r = new Random();
            for (int i = 1; i < layerCnt; i++)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    for (int k = 0; k < neuronCnt[i - 1] + 1; k++)
                    {
                        weight[i][j][k] = (double)r.Next(0, 1);
                        ;
                    }
                }
            }
 
            // Инициализация предыдущих весов для первой (0) итерации
            for (int i = 1; i < layerCnt; i++)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    for (int k = 0; k < neuronCnt[i - 1] + 1; k++)
                    {
                        prevDwt[i][j][k] = (double)0.0;
                    }
                }
            }
        }
    
 
        public static double sigmoid(double math)
        {
            return (double)(1 / (1 + Math.Exp(-math)));
        }
        public static double mse(double[] t)
        {
            double mse = 0.0;
            for (int i = 0; i < neuronCnt[layerCnt - 1]; i++)
            {
                mse += (t[i] - outNneuron[layerCnt - 1][i]) * (t[i] - outNneuron[layerCnt - 1][i]);
            }
            return mse / 2.0;
        }
        public double Out(int i)
        {
            return outNneuron[layerCnt - 1][i];
        }
        public void FeedForwards(double[] array)
        {
            double sum;
            int curLayer, curNneuron, prevNneuron;
 
            // Назначить содержание для первого слоя (входного)
            for (int i = 0; i < neuronCnt[0]; i++)
            {
                outNneuron[0][i] = array[i];
            }
 
            // --- Проходимся по каждому слою, пропуская входной (curLayer = 1)
            for (curLayer = 1; curLayer < layerCnt; curLayer++)
            {
 
                // --- Проходимся по каждому нейронну в слое
                for (curNneuron = 0; curNneuron < neuronCnt[curLayer]; curNneuron++)
                {
 
                    // --- Проходимся по всем нейроннам предыдущего слоя
                    sum = 0.0;
                    for (prevNneuron = 0; prevNneuron < neuronCnt[curLayer - 1]; prevNneuron++)
                    {
                        sum += outNneuron[curLayer - 1][prevNneuron] * weight[curLayer][curNneuron]
            [prevNneuron]; // Умножаем вход на вес и прибавляем к сумме нейрона
                    }
 
                    // Добавляем смещение
                    sum += weight[curLayer][curNneuron][neuronCnt[curLayer - 1]];
 
                    // Обновляем значение выода нейрона. Применяем функцию сжатия
                    outNneuron[curLayer][curNneuron] = sigmoid(sum);
                }
            }
        }
        // Обратное распространение ошибки
        public void BackPropogate(double[] array, double tgt)
        {
            double sum;
            int i;
 
            // Обновляем выходы сети
            FeedForwards(array);
 
            // Найти дельту для выходного слоя
            for (i = 0; i < neuronCnt[layerCnt - 1]; i++)
            {
                delta[layerCnt - 1][i] = outNneuron[layerCnt - 1][i] * (1 - outNneuron[layerCnt - 1][i]) * (tgt - outNneuron[layerCnt - 1][i]);
            }
 
            // Найти дельту для скрытых слоев
            for (i = layerCnt - 2; i > 0; i--)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    sum = 0.0;
                    for (int k = 0; k < neuronCnt[i + 1]; k++)
                    {
                        sum += delta[i + 1][k] * weight[i + 1][k][j];
                    }
                    delta[i][j] = outNneuron[i][j] * (1 - outNneuron[i][j]) * sum;
                }
            }
 
            // Просчитать импульс (ничего не делает, если alpha = 0)
            for (i = 1; i < layerCnt; i++)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    for (int k = 0; k < neuronCnt[i - 1]; k++)
                    {
                        weight[i][j][k] += alpha * prevDwt[i][j][k];
                    }
                    weight[i][j][neuronCnt[i - 1]] += alpha * prevDwt[i][j][neuronCnt[i - 1]];
                }
            }
 
            // Коректировать веса связей
            for (i = 1; i < layerCnt; i++)
            {
                for (int j = 0; j < neuronCnt[i]; j++)
                {
                    for (int k = 0; k < neuronCnt[i - 1]; k++)
                    {
                        prevDwt[i][j][k] = beta * delta[i][j] * outNneuron[i - 1][k];
                        weight[i][j][k] += prevDwt[i][j][k];
                    }
                    prevDwt[i][j][neuronCnt[i - 1]] = beta * delta[i][j];
                    weight[i][j][neuronCnt[i - 1]] += prevDwt[i][j][neuronCnt[i - 1]];
                }
            }
        }
    }
}

Вот нашел ещё один класс, который реализует нейросеть, но даже на примере автора сеть все-равно выдает почти одинаковый результат.
(переписано с С++)

Добавлено через 1 минуту
Да и что Вы вообще посоветуете для того, что бы научиться писать нейросети на с#?
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
18.01.2017, 01:44

Заказываю контрольные, курсовые, дипломные и любые другие студенческие работы здесь или здесь.

Нейросеть. Классифицировать (объект), к какому из 3 видов он больше подходит
Какую нейросеть потребуется реализовать для выполнения данной задачи? У меня есть 3 числовых...

Не обучается нейросеть
Пытаюсь написать многослойный перцептрон для решения задачи XOR. Структура простейшая 2 нейрона...

Нейросеть Хопфилда
Всем привет, не знаю в какую тему писать, поэтому сюда. Ищу доступную информацию по реализации сети...

Простая нейросеть
Привет всем! Есть задача: Научить нейросеть ставить диагноз. 1 диагноз - 1 сеть. Сеть 3 слоя:...

Почему не обучается нейросеть?
using System; namespace Нейросеть { class Program { static void...

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


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

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

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