Нейронные сети на C++

@Sukharev_K · Регистрация: 01.05.2019

Студворк — интернет-сервис помощи студентам

Доброго времени суток. Решил начать изучать нейронки, попытался обучить нейросеть с обратным распространением ошибки. Обучение с учителем. Так вот, почему то когда в целевом векторе значение 0, тогда ошибка нейросети уменьшается, а при 1 увеличивается, вроде все как по учебнику делал. ПОмогите разобраться.
Для того чтобы понять правильно ли обучается сеть я решил не загружать много данных, а посмотреть как ведет себя программа на 30 парах, но как я понимаю, она ведет себя не так, как хотелось бы.
в коде много грязи и он не дописан, вплане условий, мне главное сейчас понять, как сделать так, чтобы сеть обучалась правильно, а потом уже буду основательно его переделывать. Что я делаю не правильно на данный момент, подскажите.
Вот код:

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
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
//#include <graphics.h>
#include <conio.h>  // getch
#include <ctype.h>
#include <iostream>
#include <cmath> 
#include <ctime>
using namespace std;
float activ_fun(float NET)
{
    return 1 / (1 + exp(-NET));
}
float proizvod_activ_fun(float OUT)
{
    return OUT*(1 - OUT);
}
int main()
{
    
    float w1_1 = 0.3273, w1_2 = 0.2834, w1_3 = 0.5329;
    float w2_1 = 0.3542, w2_2 = 0.4374, w2_3 = 0.3202;
    float h = 0.6, cel = 0, delta_1 = 0, correctirovka_1 = 0, delta_2 = 0, correctirovka_2 = 0;
    float b1_1 = 0, b1_2 = 0, b1_3 = 0, b2_1 = 0;
    float vxod[27] = { 1.525296838, 0.464641648, 1.730666158, 0.267464594, 1.56444614,
                       0.526441276, 1.708979066, 0.648323876, 1.197653903, 0.075771303, 1.349625674,
                       0.394258738,1.400553145, 0.465213867, 1.525869057, 0.709551285,1.708979066, 
                       0.708406848, 1.709551285,0.647751657, 1.930666158, 0.267464594, 
                       1.56444614,0.197653903, 1.075771303, 0.394258738,1.400553145 };
    float vyxod[27] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    for (int i = 0; i < 27; i++)
    {
        b1_1 = vxod[i] * w1_1;
        b1_2 = vxod[i] * w1_2;
        b1_3 = vxod[i] * w1_3;
        b1_1 = activ_fun(b1_1);
        b1_2 = activ_fun(b1_2);
        b1_3 = activ_fun(b1_3);
        b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
        b2_1 = activ_fun(b2_1);
        //cout << b2_1;
        cel = vyxod[i] - b2_1;
        cout << cel << endl;
        //if (cel > 0.0005)
        //  {
            delta_1 = -cel* proizvod_activ_fun(b2_1);
            correctirovka_1 = -delta_1*h*b1_1;
            w2_1 = w2_1 + correctirovka_1;
            correctirovka_1 = -delta_1*h*b1_2;
            w2_2 = w2_2 + correctirovka_1;
            correctirovka_1 = -delta_1*h*b1_3;
            w2_3 = w2_3 + correctirovka_1;
 
            //vtorye vesa
            delta_2 = proizvod_activ_fun(b1_1)*delta_1*w2_1;
            correctirovka_2 = -delta_2*vxod[i] * h;
            w1_1 = w1_1 + correctirovka_2;
            delta_2 = proizvod_activ_fun(b1_2)*delta_1*w2_2;
            correctirovka_2 = -delta_2*vxod[i] * h;
            w1_2 = w1_2 + correctirovka_2;
            delta_2 = proizvod_activ_fun(b1_3)*delta_1*w2_3;
            correctirovka_2 = -delta_2*vxod[i] * h;
            w1_3 = w1_3 + correctirovka_2;
            //cout << w1_1 << endl;
            //cout << w1_2 << endl;
            //cout << w1_3 << endl;
            //cout << w2_1 << endl;
            //cout << w2_2 << endl;
            //cout << w2_3 << endl;
         // }
        //else
        //{
        //  break;
        //}
        
        //cout << b2_1<< " ";
    }
    float k = 1.56444614;
    b1_1 = k * w1_1;
    b1_2 = k * w1_2;
    b1_3 = k * w1_3;
    b1_1 = activ_fun(b1_1);
    b1_2 = activ_fun(b1_2);
    b1_3 = activ_fun(b1_3);
    b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
    b2_1 = activ_fun(b2_1);
    cout << b2_1;
    return 0;
}

Добавлено через 3 минуты
Сеть у меня с тремя нейронами в скрытом слое и 1 выходным нейроном.

@Albinos · 01.05.2019, 18:53

Сообщение от Sukharev_K

Сеть у меня с тремя нейронами в скрытом слое и 1 выходным нейроном.

Что вы хотите подать на каждый нейрон в качестве входа и какую задачу должна решить нейронка?

@Sukharev_K · 01.05.2019, 19:12 **[ТС]**

На вход будут подаваться числа, аналогичные, что находятся в массиве vxod.
Задача нахождения выбросов, наверно так ее можно описать, тоесть до определенного значения входа выход должен быть 0, а если значение больше, то уже 1.
на вход я пытаюсь подать одно число, после прохода нахожу разность с целевым выходом и пытаюсь подкорректировать веса.
вот такую сеть пытаюсь реализовать.

@Sukharev_K · 01.05.2019, 19:53 **[ТС]**

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

@Albinos · 01.05.2019, 20:11

Сообщение от Sukharev_K

тоесть до определенного значения входа выход должен быть 0, а если значение больше, то уже 1.

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

@Sukharev_K · 01.05.2019, 20:18 **[ТС]**

Да это просто начало, в дальнейшем может быть 3 или 5 состояний, к примеру 0, 0.5 1 в целевом векторе.
Именно поэтому и хочу сейчас попробовать реализовать с сигмоидой, чтобы результат после обучения был 0.99995 к примеру для единицы, ну и с такой же точностью для нуля.
Может на выборке из 27 элементов нельзя судить как идет обучение?

@Albinos · 01.05.2019, 20:19

Сообщение от Sukharev_K

C++
1
delta_1 = -cel* proizvod_activ_fun(b2_1); correctirovka_1 = -delta_1*h*b1_1; w2_1 = w2_1 + correctirovka_1; correctirovka_1 = -delta_1*h*b1_2; w2_2 = w2_2 + correctirovka_1; correctirovka_1 = -delta_1*h*b1_3; w2_3 = w2_3 + correctirovka_1; //vtorye vesa delta_2 = proizvod_activ_fun(b1_1)*delta_1*w2_1; correctirovka_2 = -delta_2*vxod[i] * h; w1_1 = w1_1 + correctirovka_2; delta_2 = proizvod_activ_fun(b1_2)*delta_1*w2_2; correctirovka_2 = -delta_2*vxod[i] * h; w1_2 = w1_2 + correctirovka_2; delta_2 = proizvod_activ_fun(b1_3)*delta_1*w2_3; correctirovka_2 = -delta_2*vxod[i] * h; w1_3 = w1_3 + correctirovka_2;

Корректировки всех весов производятся от младшего к старшему, только после того как вы посчитали все дельты

Сообщение от Sukharev_K

Может на выборке из 27 элементов нельзя судить как идет обучение

Можно, более того, по идее, она должна уметь "переобучиться" в какое-то конкретное значение

@Sukharev_K · 01.05.2019, 20:21 **[ТС]**

Младший это скрытый?
Тоесть сначала считаем все корректировки со старыми весами, а потом уже все их корректируем, правильно понял?)

@Albinos · 01.05.2019, 20:22

Да, сначала скрытые считаем, потом выходной ( т.к изменение в младших весах зависит от старшего слоя, но не наоборот)

@Sukharev_K · 01.05.2019, 20:57 **[ТС]**

Сейчас переделаю и отпишусь, скину, что получилось)

Добавлено через 26 минут

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
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
//#include <graphics.h>
#include <conio.h>  // getch
#include <ctype.h>
#include <iostream>
#include <cmath> 
#include <ctime>
using namespace std;
float activ_fun(float NET)
{
    return 1 / (1 + exp(-NET));
}
float proizvod_activ_fun(float OUT)
{
    return OUT*(1 - OUT);
}
int main()
{
 
    float w1_1 = 0.3273, w1_2 = 0.2834, w1_3 = 0.5329;
    float w2_1 = 0.3542, w2_2 = 0.4374, w2_3 = 0.3202;
    float h = 0.6, cel = 0, delta_1 = 0, correctirovka_1 = 0, delta_2 = 0, correctirovka_2 = 0;
    float correctirovka[6];
    float delta[4];
    float b1_1 = 0, b1_2 = 0, b1_3 = 0, b2_1 = 0;
    float vxod[27] = { 1.525296838, 0.464641648, 1.730666158, 0.267464594, 1.56444614,
        0.526441276, 1.708979066, 0.648323876, 1.197653903, 0.075771303, 1.349625674,
        0.394258738,1.400553145, 0.465213867, 1.525869057, 0.709551285,1.708979066,
        0.708406848, 1.709551285,0.647751657, 1.930666158, 0.267464594,
        1.56444614,0.197653903, 1.075771303, 0.394258738,1.400553145 };
    float vyxod[27] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    for (int i = 0; i < 27; i++)
    {
        b1_1 = vxod[i] * w1_1;
        b1_2 = vxod[i] * w1_2;
        b1_3 = vxod[i] * w1_3;
        b1_1 = activ_fun(b1_1);
        b1_2 = activ_fun(b1_2);
        b1_3 = activ_fun(b1_3);
        b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
        b2_1 = activ_fun(b2_1);
        cel = vyxod[i] - b2_1;
        cout << cel << endl;
        
 
        //vyxodnoi sloi
        delta[0] = -cel* proizvod_activ_fun(b2_1);
        correctirovka[0] = -delta[0]*h*b1_1;
        //w2_1 = w2_1 + correctirovka[1];
        correctirovka[1] = -delta[0]*h*b1_2;
        //w2_2 = w2_2 + correctirovka[1];
        correctirovka[2] = -delta[0]*h*b1_3;
        //w2_3 = w2_3 + correctirovka[1];
 
        // skrytyi sloi + correctirovka vesov
        delta[1] = proizvod_activ_fun(b1_1)*delta[0]*w2_1;
        correctirovka[3] = -delta[2]*vxod[i] * h;
        w1_1 = w1_1 + correctirovka_2;
        delta[2] = proizvod_activ_fun(b1_2)*delta[0]*w2_2;
        correctirovka[4] = -delta[3]*vxod[i] * h;
        w1_2 = w1_2 + correctirovka[5];
        delta[3] = proizvod_activ_fun(b1_3)*delta[0]*w2_3;
        correctirovka[5] = -delta[4]*vxod[i] * h;
        w1_3 = w1_3 + correctirovka[6];
        
        //корректируем веса выходного слоя.
        w2_1 = w2_1 + correctirovka[0];
        w2_2 = w2_2 + correctirovka[1];
        w2_3 = w2_3 + correctirovka[2];
 
    }
    float k = 1.56444614;
    b1_1 = k * w1_1;
    b1_2 = k * w1_2;
    b1_3 = k * w1_3;
    b1_1 = activ_fun(b1_1);
    b1_2 = activ_fun(b1_2);
    b1_3 = activ_fun(b1_3);
    b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
    b2_1 = activ_fun(b2_1);
    cout << b2_1;
    return 0;
}

Вот так вот??

Добавлено через 3 минуты
Тоесть я сначала просто посчитал корректировки для выходного слоя, но не менял пока веса, потом посчитал корректировки во внутреннем слое и сразу пересчитал веса, а уже после этого изменил веса на выходном слое, все так я сделал?)

@Sukharev_K · 01.05.2019, 21:00 **[ТС]**

Теперь чего то вся разность начала увеличиваться, походу я опять что то напутал..

@Albinos · 01.05.2019, 21:31

Сообщение от Sukharev_K

delta[1] = proizvod_activ_fun(b1_1)*delta[0]*w2_1; correctirovka[3] = -delta[2]*vxod[i] * h; w1_1 = w1_1 + correctirovka_2; delta[2] = proizvod_activ_fun(b1_2)*delta[0]*w2_2;

Сначала используете delta[2], потом её считаете? Выглядит сомнительно. С остальными также

@Sukharev_K · 01.05.2019, 21:33 **[ТС]**

ой да, напутал, щас исправлю.

@Kuzia domovenok · 01.05.2019, 21:38

Sukharev_K, не слишком ли велик коефф-т обучения?

@Sukharev_K · 01.05.2019, 21:38 **[ТС]**

Исправил, вроде теперь все правильно должно быть..

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
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
//#include <graphics.h>
#include <conio.h>  // getch
#include <ctype.h>
#include <iostream>
#include <cmath> 
#include <ctime>
using namespace std;
float activ_fun(float NET)
{
    return 1 / (1 + exp(-NET));
}
float proizvod_activ_fun(float OUT)
{
    return OUT*(1 - OUT);
}
int main()
{
 
    float w1_1 = 0.3273, w1_2 = 0.2834, w1_3 = 0.5329;
    float w2_1 = 0.3542, w2_2 = 0.4374, w2_3 = 0.3202;
    float h = 0.6, cel = 0, delta_1 = 0, correctirovka_1 = 0, delta_2 = 0, correctirovka_2 = 0;
    float correctirovka[6];
    float delta[4];
    float b1_1 = 0, b1_2 = 0, b1_3 = 0, b2_1 = 0;
    float vxod[27] = { 1.525296838, 0.464641648, 1.730666158, 0.267464594, 1.56444614,
        0.526441276, 1.708979066, 0.648323876, 1.197653903, 0.075771303, 1.349625674,
        0.394258738,1.400553145, 0.465213867, 1.525869057, 0.709551285,1.708979066,
        0.708406848, 1.709551285,0.647751657, 1.930666158, 0.267464594,
        1.56444614,0.197653903, 1.075771303, 0.394258738,1.400553145 };
    float vyxod[27] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    for (int i = 0; i < 27; i++)
    {
        b1_1 = vxod[i] * w1_1;
        b1_2 = vxod[i] * w1_2;
        b1_3 = vxod[i] * w1_3;
        b1_1 = activ_fun(b1_1);
        b1_2 = activ_fun(b1_2);
        b1_3 = activ_fun(b1_3);
        b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
        b2_1 = activ_fun(b2_1);
        cel = vyxod[i] - b2_1;
        cout << cel << endl;
 
 
        //vyxodnoi sloi
        delta[0] = cel* proizvod_activ_fun(b2_1);
        correctirovka[0] = delta[0] * h*b1_1;
        //w2_1 = w2_1 + correctirovka[1];
        correctirovka[1] = delta[0] * h*b1_2;
        //w2_2 = w2_2 + correctirovka[1];
        correctirovka[2] = delta[0] * h*b1_3;
        //w2_3 = w2_3 + correctirovka[1];
 
        // skrytyi sloi + correctirovka vesov
        delta[1] = proizvod_activ_fun(b1_1)*delta[0] * w2_1;
        correctirovka[3] = delta[1] * vxod[i] * h;
        w1_1 = w1_1 + correctirovka[3];
        delta[2] = proizvod_activ_fun(b1_2)*delta[0] * w2_2;
        correctirovka[4] = delta[2] * vxod[i] * h;
        w1_2 = w1_2 + correctirovka[5];
        delta[3] = proizvod_activ_fun(b1_3)*delta[0] * w2_3;
        correctirovka[5] = delta[3] * vxod[i] * h;
        w1_3 = w1_3 + correctirovka[5];
 
        //корректируем веса выходного слоя.
        w2_1 = w2_1 + correctirovka[0];
        w2_2 = w2_2 + correctirovka[1];
        w2_3 = w2_3 + correctirovka[2];
 
    }
    float k = 1.56444614;
    b1_1 = k * w1_1;
    b1_2 = k * w1_2;
    b1_3 = k * w1_3;
    b1_1 = activ_fun(b1_1);
    b1_2 = activ_fun(b1_2);
    b1_3 = activ_fun(b1_3);
    b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
    b2_1 = activ_fun(b2_1);
    cout << b2_1;
    return 0;
}

так вот?)

@Sukharev_K · 01.05.2019, 21:40 **[ТС]**

Думаете это очень влияет на такое изменение разностей?

@Albinos · 01.05.2019, 21:47

Сообщение от Sukharev_K

Думаете это очень влияет на такое изменение разностей?

Видимо это не единственная ошибка)

Сообщение от Sukharev_K

w1_2 = w1_2 + correctirovka[5]; delta[3] = proizvod_activ_fun(b1_3)*delta[0] * w2_3; correctirovka[5] = delta[3] * vxod[i] * h; w1_3 = w1_3 + correctirovka[5]

В обоих случаях используется корректировка correctirovka[5]

@Sukharev_K · 01.05.2019, 21:53 **[ТС]**

Исправил, извиняюсь за такие глупые ошибки просто глаза уже в кучку, вторые сутки пытаюсь добиться положительного результата..)))

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
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
//#include <graphics.h>
#include <conio.h>  // getch
#include <ctype.h>
#include <iostream>
#include <cmath> 
#include <ctime>
using namespace std;
float activ_fun(float NET)
{
    return 1 / (1 + exp(-NET));
}
float proizvod_activ_fun(float OUT)
{
    return OUT*(1 - OUT);
}
int main()
{
 
    float w1_1 = 0.3273, w1_2 = 0.2834, w1_3 = 0.5329;
    float w2_1 = 0.3542, w2_2 = 0.4374, w2_3 = 0.3202;
    float h = 0.3, cel = 0, delta_1 = 0, correctirovka_1 = 0, delta_2 = 0, correctirovka_2 = 0;
    float correctirovka[6];
    float delta[4];
    float b1_1 = 0, b1_2 = 0, b1_3 = 0, b2_1 = 0;
    float vxod[27] = { 1.525296838, 0.464641648, 1.730666158, 0.267464594, 1.56444614,
        0.526441276, 1.708979066, 0.648323876, 1.197653903, 0.075771303, 1.349625674,
        0.394258738,1.400553145, 0.465213867, 1.525869057, 0.709551285,1.708979066,
        0.708406848, 1.709551285,0.647751657, 1.930666158, 0.267464594,
        1.56444614,0.197653903, 1.075771303, 0.394258738,1.400553145 };
    float vyxod[27] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
    for (int i = 0; i < 27; i++)
    {
        b1_1 = vxod[i] * w1_1;
        b1_2 = vxod[i] * w1_2;
        b1_3 = vxod[i] * w1_3;
        b1_1 = activ_fun(b1_1);
        b1_2 = activ_fun(b1_2);
        b1_3 = activ_fun(b1_3);
        b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
        b2_1 = activ_fun(b2_1);
        cel = vyxod[i] - b2_1;
        cout << cel << endl;
 
 
        //vyxodnoi sloi
        delta[0] = cel* proizvod_activ_fun(b2_1);
        correctirovka[0] = delta[0] * h*b1_1;
        //w2_1 = w2_1 + correctirovka[1];
        correctirovka[1] = delta[0] * h*b1_2;
        //w2_2 = w2_2 + correctirovka[1];
        correctirovka[2] = delta[0] * h*b1_3;
        //w2_3 = w2_3 + correctirovka[1];
 
        // skrytyi sloi + correctirovka vesov
        delta[1] = proizvod_activ_fun(b1_1)*delta[0] * w2_1;
        correctirovka[3] = delta[1] * vxod[i] * h;
        w1_1 = w1_1 + correctirovka[3];
        delta[2] = proizvod_activ_fun(b1_2)*delta[0] * w2_2;
        correctirovka[4] = delta[2] * vxod[i] * h;
        w1_2 = w1_2 + correctirovka[4];
        delta[3] = proizvod_activ_fun(b1_3)*delta[0] * w2_3;
        correctirovka[5] = delta[3] * vxod[i] * h;
        w1_3 = w1_3 + correctirovka[5];
 
        //корректируем веса выходного слоя.
        w2_1 = w2_1 + correctirovka[0];
        w2_2 = w2_2 + correctirovka[1];
        w2_3 = w2_3 + correctirovka[2];
 
    }
    float k = 1.56444614;
    b1_1 = k * w1_1;
    b1_2 = k * w1_2;
    b1_3 = k * w1_3;
    b1_1 = activ_fun(b1_1);
    b1_2 = activ_fun(b1_2);
    b1_3 = activ_fun(b1_3);
    b2_1 = b1_1*w2_1 + b1_2*w2_2 + b1_3*w2_3;
    b2_1 = activ_fun(b2_1);
    cout << b2_1;
    return 0;
}

@Albinos · 01.05.2019, 21:58

Не по теме:

Сообщение от Sukharev_K

вторые сутки пытаюсь добиться положительного результата

Из моего опыта, это только начало)))

Только сейчас пришло в голову- зачем три нейрона с одинаковым значением входа? Возможно она неправильно работает из-за неправильной архитектуры

@Sukharev_K · 01.05.2019, 21:58 **[ТС]**

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

Новые блоги и статьи Все статьи Все блоги /
Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Programma_Boinc 23.12.2025 Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Рецензия / Мнение Это мой обзор планшета X220 с точки зрения школьника. Недавно я решила попытаться уменьшить свой. . .	PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Как объединить две одинаковые БД Access с разными данными VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .
От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .	Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 19:12 [ТС]
	На вход будут подаваться числа, аналогичные, что находятся в массиве vxod. Задача нахождения выбросов, наверно так ее можно описать, тоесть до определенного значения входа выход должен быть 0, а если значение больше, то уже 1. на вход я пытаюсь подать одно число, после прохода нахожу разность с целевым выходом и пытаюсь подкорректировать веса. вот такую сеть пытаюсь реализовать. Миниатюры 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 19:53 [ТС]
	Я попытался вывести информацию о разнице между целевым вектором и выходом сети. Видно что для 1 в целевом векторе ошибка уменьшается, а для нуля увеличивается. последнее значения на скриншоте не учитывается, это я уже попробовал подать на сеть значение. Миниатюры 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 20:18 [ТС]
	Да это просто начало, в дальнейшем может быть 3 или 5 состояний, к примеру 0, 0.5 1 в целевом векторе. Именно поэтому и хочу сейчас попробовать реализовать с сигмоидой, чтобы результат после обучения был 0.99995 к примеру для единицы, ну и с такой же точностью для нуля. Может на выборке из 27 элементов нельзя судить как идет обучение? 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 20:21 [ТС]
	Младший это скрытый? Тоесть сначала считаем все корректировки со старыми весами, а потом уже все их корректируем, правильно понял?) 0

@Albinos 21 / 16 / 5 Регистрация: 22.06.2015 Сообщений: 68
	01.05.2019, 20:22
	Да, сначала скрытые считаем, потом выходной ( т.к изменение в младших весах зависит от старшего слоя, но не наоборот) 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 21:00 [ТС]
	Теперь чего то вся разность начала увеличиваться, походу я опять что то напутал.. Миниатюры 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 21:33 [ТС]
	ой да, напутал, щас исправлю. 0

@Kuzia domovenok 4268 / 3327 / 926 Регистрация: 25.03.2012 Сообщений: 12,531 Записей в блоге: 1
	01.05.2019, 21:38
	Sukharev_K, не слишком ли велик коефф-т обучения? 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 21:40 [ТС]
	Думаете это очень влияет на такое изменение разностей? Миниатюры 0

@Sukharev_K 0 / 0 / 0 Регистрация: 01.05.2019 Сообщений: 40
	01.05.2019, 21:58 [ТС]
	Есть у меня еще подозрения, что может там где то в формулка минус нужно поставить, я прошарил инет где в дельта ставится, где то нет, я попробовал, но результата положительного не получилось. И еще один вариант был попробовать как то сделать на подобии этого, что на фото, типо если разница отрицательна, то я вычитал коректировку, если положительна, то прибавлял, но это должного результата так же не принесло.. Миниатюры 0