0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
1

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

01.05.2019, 17:22. Показов 3232. Ответов 71
Метки нет (Все метки)

Доброго времени суток. Решил начать изучать нейронки, попытался обучить нейросеть с обратным распространением ошибки. Обучение с учителем. Так вот, почему то когда в целевом векторе значение 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 выходным нейроном.
0

Помощь в написании контрольных, курсовых и дипломных работ здесь.

Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
01.05.2019, 17:22
Ответы с готовыми решениями:

Нейронные сети (адаптивные сети)
нужен исходник 3д или 2д адаптивной сетки для небольшого использования в своей работе...

Нейронные сети
Добрый вечер, товарищи. Прошу у вас помощи по нейронным сетям. Есть обучающие выборка, там...

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

Нейронные сети
Добрый вечер! Можете подсказать где есть много примеров по нейронным сетям...? Хотелось бы...

71
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
01.05.2019, 22:00  [ТС] 21
А как тогда мне сделать так, чтобы в скрытом слое у меня было 3 нейрона хотя бы при одном входе?
Или что, пытаться обучать тройками?
0

Помощь в написании контрольных, курсовых и дипломных работ здесь.

21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
01.05.2019, 22:16 22
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
for(int j = 0; j < 10000; ++j)
    {
        cel = 0;
        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) * (vyxod[i] - b2_1);
        
 
             //vyxodnoi sloi
            delta[0] = -2 * (vyxod[i] - b2_1) * proizvod_activ_fun(b2_1);
            //w2_3 = w2_3 + correctirovka[1];
 
            // skrytyi sloi + correctirovka vesov
            delta[1] = 2 * proizvod_activ_fun(b1_1)*delta[0] * w2_1;
            delta[3] = 2 * proizvod_activ_fun(b1_3)*delta[0] * w2_3;
            delta[2] = 2 * proizvod_activ_fun(b1_2)*delta[0] * w2_2;
        
            correctirovka[3] = -delta[1] * vxod[i] * h;
            correctirovka[4] = -delta[2] * vxod[i] * h;
            correctirovka[5] = -delta[3] * vxod[i] * h;
 
            w1_1 = w1_1 + correctirovka[3];
            w1_2 = w1_2 + correctirovka[4];
            w1_3 = w1_3 + correctirovka[5];
        
            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_1 = w2_1 + correctirovka[0];
            w2_2 = w2_2 + correctirovka[1];
            w2_3 = w2_3 + correctirovka[2];
 
        }
        cout << cel/27 << endl;
    }
Я чутка поменял ваш цикл, заменил функцию ошибки на квадратичную, насчёт коэффицента 2 перед дельтами не уверен- может не нужен, это надо внимательнее почитать алогритм.
Верхний цикл отвечает за количество эпох, нижний за выбор элемента из набора
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
01.05.2019, 22:43  [ТС] 23
это восхитительно!
А теперь у меня вопросики, чтобы понять как вы это сделали)))
- А зачем cel делить на 27 я не могу понять?..
C++
1
2
3
4
5
6
7
8
9
            //корректируем веса выходного слоя.
            w2_1 = w2_1 + correctirovka[0];
            w2_2 = w2_2 + correctirovka[1];
            w2_3 = w2_3 + correctirovka[2];
 
        }
        cout << cel / 27 << endl;
    }
    float k = 0.56444614;
- получается мы возводили в квадрат ошибку только для себя? Ведь дальше везде не используется квадрат ошибки, как я вижу, там просто "delta[0] = -2 * (vyxod[i] - b2_1) * proizvod_activ_fun(b2_1);"?

- "cel += (vyxod[i] - b2_1) * (vyxod[i] - b2_1);" равносильно cel =cel + (vyxod[i] - b2_1) * (vyxod[i] - b2_1);??)))

-По сути получается мы прогоняем дофига раз по кругу 27 значений, включая второй цикл? Для этого да он написан??

- Насчет вот двойки, на которую умножаем дельту, и вот квадратичная разность ошибки, как это, где это найти? просто я с таким не сталкивался для нейронок, как правильно это погуглить)

Вы просто лучший!!!
0
Миниатюры
Нейронные сети на C++  
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
01.05.2019, 22:58 24
Цитата Сообщение от Sukharev_K Посмотреть сообщение
- А зачем cel делить на 27 я не могу понять?..
Для каждой выборки мы вычисляем среднеквадратичную ошибку, и прибавляем к итоговой. Когда мы делим на количество элементов в выборке - мы берем среднее арифметическое.
Цитата Сообщение от Sukharev_K Посмотреть сообщение
- получается мы возводили в квадрат ошибку только для себя?
Да, показатель ошибки обычно позволяет понять как проходит обучение нейронки
Цитата Сообщение от Sukharev_K Посмотреть сообщение
"cel += (vyxod[i] - b2_1) * (vyxod[i] - b2_1);" равносильно cel =cel + (vyxod[i] - b2_1) * (vyxod[i] - b2_1);??)))
Ага)
Цитата Сообщение от Sukharev_K Посмотреть сообщение
По сути получается мы прогоняем дофига раз по кругу 27 значений, включая второй цикл? Для этого да он написан??
По сути - да. При обучении нейронки есть два этапа: это количество элементов в выборке и количество эпох. каждый раз когда мы подаём выборку на сеть - это называется эпохой. В зависимости от задачи, количество эпох будет разным.

Цитата Сообщение от Sukharev_K Посмотреть сообщение
- Насчет вот двойки, на которую умножаем дельту, и вот квадратичная разность ошибки, как это, где это найти? просто я с таким не сталкивался для нейронок, как правильно это погуглить)
Я ориентировался сейчас на статью "метод обратного распространения" на википедии))

Не по теме:

Цитата Сообщение от Sukharev_K Посмотреть сообщение
Вы просто лучший!!!
Приятно иметь дело:D

1
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
01.05.2019, 23:08  [ТС] 25
Я просто в шоке,честное слово!)
Вы просто... Спасибище!
Я тему закрывать пока не буду, так как продолжу реализовывать нейронку, в течение всей недели, буду вам признателен, если будете иногда помогать советами!)
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 14:14  [ТС] 26
Я решил переписать нейронку, новая задача заключается в том, чтобы на вход подавать 30 данных сразу ну и получать и 1 выход соответственно (1или 0). Переписав код, нечего теперь не работает, не могу найти свою ошибку, помогите пожалуйста..)
схема нейронки осталась такой же, 3 нейрона в скрытом слое, и 1 в выходном. если что то в коде не понятно что я делаю, то объясню. Очень нужна ваша помощь!)
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
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>  
#include <ctype.h>
#include <iostream>
#include <cmath> 
#include <ctime>
#include "StdAfx.h"
#include <fstream>
#include <iostream>
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[30], w1_2[30], w1_3[30];
    ifstream kf1("kf1.txt");
    ifstream kf2("kf2.txt");
    ifstream kf3("kf3.txt");
    for (int i = 0; i<30; i++)
    {
        kf1 >> w1_1[i];
        kf2 >> w1_2[i];
        kf3 >> w1_3[i];
        //cout << w1_1[i] << " " << w1_2[i] << " " << w1_3[i] << endl;
 
    }
    //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.01, cel = 0;
    float correctirovka[3];
    float delta[4];
    float b1_1 = 0, b1_2 = 0, b1_3 = 0, b2_1 = 0;
    float cor1_1[30], cor1_2[30], cor1_3[30];
    ifstream inp("input.txt");
    ifstream output("output.txt");
    float vxod[720], vyxod[24];
    for (int i = 0; i < 720; i++)
    {
        inp >> vxod[i];
        //cout << vxod[i] << endl;
    }
    for (int i = 0; i < 24; i++)
    {
        output >> vyxod[i];
        //cout << vyxod[i] << endl;
    }
    for (int j = 0; j < 100; ++j)
    {
        int f = 0;
        cel = 0;
        for (int i = 0; i < 720; i = i + 30)
        {
            b1_1 = 0;
            b1_2 = 0;
            b1_3 = 0;
            for (int k = i; k - i<30; k++)
            {
                b1_1 = b1_1 + vxod[k] * w1_1[k];
                b1_2 = b1_2 + vxod[k] * w1_2[k];
                b1_3 = b1_3 + vxod[k] * w1_3[k];
            }
            //  b1_1 = vxod[i] * w1_1;
            //  b1_2 = vxod[i] * w1_2;
            //  b1_3 = vxod[i] * w1_3;
            //cout << b1_1 << " " << b1_2 << " " << b1_3 << endl;
            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[f] - b2_1) * (vyxod[f] - b2_1);
 
            //cout << vyxod[f]<<endl;
 
            //
            delta[0] = -2 * (vyxod[f] - b2_1) * proizvod_activ_fun(b2_1);
 
 
            // 
            delta[1] = 2 * proizvod_activ_fun(b1_1)*delta[0] * w2_1;
            delta[3] = 2 * proizvod_activ_fun(b1_3)*delta[0] * w2_3;
            delta[2] = 2 * proizvod_activ_fun(b1_2)*delta[0] * w2_2;
            //cout << delta[0] << " " << delta[1] << " " << delta[2] << " " << delta[3] << endl;
            // 
            //  correctirovka[3] = -delta[1] * vxod[i] * h;
            //  correctirovka[4] = -delta[2] * vxod[i] * h;
            //  correctirovka[5] = -delta[3] * vxod[i] * h;
            for (int q = 0; q<30; q++)
            {
                cor1_1[q] = -delta[1] * vxod[i + q] * h;
                cor1_2[q] = -delta[2] * vxod[i + q] * h;
                cor1_3[q] = -delta[3] * vxod[i + q] * h;
                //cout << cor1_1[q] << " " << cor1_2[q] << " " << cor1_3[q] << endl;
            }
            //
            //w1_1 = w1_1 + correctirovka[3];
            //w1_2 = w1_2 + correctirovka[4];
            //w1_3 = w1_3 + correctirovka[5];
            for (int w = 0; w<30; w++)
            {
                w1_1[w] = w1_1[w] + cor1_1[w];
                w1_2[w] = w1_2[w] + cor1_2[w];
                w1_3[w] = w1_3[w] + cor1_3[w];
                //cout << w1_1[w] << " " << w1_2[w] << " " << w1_3[w] << endl;
            }
            // 
            correctirovka[0] = -delta[0] * h*b1_1;
            correctirovka[1] = -delta[0] * h*b1_2;
            correctirovka[2] = -delta[0] * h*b1_3;
 
            //
            w2_1 = w2_1 + correctirovka[0];
            w2_2 = w2_2 + correctirovka[1];
            w2_3 = w2_3 + correctirovka[2];
            f++;
        }
        //cout << cel / 24 << endl;
        if ((cel / 24) < 0.0002)
            break;
 
    }
    cout << w1_1 << " " << w1_2 << " " << w1_3 << endl;
    cout << w2_1 << " " << w2_2 << " " << w2_3 << endl;
    // 
    float test[114996];
    ifstream testirovanie("test.txt");
    for (int i = 0; i < 114996; i++)
    {
        testirovanie >> test[i];
        //cout << test[i] << endl;
    }
    ofstream fout("testik.txt");
    //for (int i = 0; i < 114996; i++)
    //  {
    //      b1_1 = test[i] * w1_1;
    //  b1_2 = test[i] * w1_2;
    //  b1_3 = test[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);
    //  fout << b2_1 << endl;
    //cout << b2_1 << endl;
    //  }
    for (int i = 0; i<113996; i = i + 30)
    {
        b1_1 = 0;
        b1_2 = 0;
        b1_3 = 0;
        for (int j = i; j - i<30; j++)
        {
            b1_1 = b1_1 + vxod[j] * w1_1[j];
            b1_2 = b1_2 + vxod[j] * w1_2[j];
            b1_3 = b1_3 + vxod[j] * w1_3[j];
        }
        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);
        fout << b2_1 << endl;
    }
    fout.close();
    return 0;
}
0
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 15:02 27
Цитата Сообщение от Sukharev_K Посмотреть сообщение
нечего теперь не работае
Как определить, что ничего не работает?) Какую задачу пытаетесь решить и откуда данные соответственно?
Цитата Сообщение от Sukharev_K Посмотреть сообщение
#include "stdafx.h" #include <stdlib.h> #include <stdio.h> #include <conio.h> #include <ctype.h> #include <iostream> #include <cmath> #include <ctime> #include "StdAfx.h" #include <fstream> #include <iostream>
Зачем столько инклудов? И дважды включение "stdafx". Он вообще вам нужен?
Цитата Сообщение от Sukharev_K Посмотреть сообщение
kf1 >> w1_1[i]; kf2 >> w1_2[i]; kf3 >> w1_3[i];
Не лучше веса инициализировать прям в программе с помощью случайного малого числа?
Без ваших входных данных я её не продебажу
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 16:02  [ТС] 28
Так, по порядку, на данный момент пытаюсь сделать так, чтобы нейронка выдвала результат, пусть даже и не правильный, потому что для правильного результата у меня еще не сформирована выборка.
Сейчас я хочу подавать на вход сразу 30 значений из выборки, а на выход даю одно значение.
вот этому хочу научить.
Инклуды в принципе не должны же влиять на работу??
Входные данные:
input - входные данные
output - целевой вектор
test - файл с тестовыми значениями
kf1-веса для первого нейрона в скрытом слое
kf2-веса для второго нейрона в скрытом слое
kf3-веса для третьего нейрона в скрытом слое
насчет инициализации весов, может и лучше, но я пока не смог разобраться с рандомом не целых чисел от нуля до единицы, и поэтому решил ввести в ручную..
0
Вложения
Тип файла: txt input.txt (9.1 Кб, 3 просмотров)
Тип файла: txt output.txt (72 байт, 3 просмотров)
Тип файла: txt kf1.txt (238 байт, 2 просмотров)
Тип файла: txt kf2.txt (238 байт, 2 просмотров)
Тип файла: txt kf3.txt (238 байт, 2 просмотров)
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 17:55 29
Цитата Сообщение от Albinos Посмотреть сообщение
Как определить, что ничего не работает?)
И всё же?)
Цитата Сообщение от Sukharev_K Посмотреть сообщение
cout << w1_1 << " " << w1_2 << " " << w1_3 << endl;
Вот здесь вы что хотите увидеть? У вас w1_1|w1_2|w1_3 - Это массивы по 30 элементов. Он выведет указатель на начало.
Цитата Сообщение от Sukharev_K Посмотреть сообщение
for (int k = i; k - i<30; k++)
65ая строчка - почему такое условие работы цикла?
Цитата Сообщение от Sukharev_K Посмотреть сообщение
Инклуды в принципе не должны же влиять на работу??
Не должны, но лучше лишнее убирать
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 18:25  [ТС] 30
так так.
1) Определяю что ничего не работает по тестированию, в файл записывается вот это, что на прикрепленной фотке, по моей логике в нем должны быть нормальные цифры, ну я так думаю..))
2) Это нужно закоментить, осталось от предыдущей версии, уже закоментил)
3)Задача сводится к тому, чтобы из входного массива брать по 30 элементов и сразу подавать на вход. И получается в этом цикле мы суммируем 30 входных данных перемноженных на веса для каждого события. Тоесть в первый проход берутся 1-30 значений, в следующий проход по этому циклу берутся 30-60 значения, понятно объясняю?))
4) Хорошо, уберу в конце, когда все будет работать, но если это хоть немного это может повлиять на результат, то сделаю сейчас))
0
Миниатюры
Нейронные сети на C++  
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 18:31 31
Цитата Сообщение от Sukharev_K Посмотреть сообщение
в файл записывается вот это, что на прикрепленной фотке,
А входные данные откуда?)
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 18:35  [ТС] 32
Из файла test, который прикрепил выше, ну для тестирования которые)
0
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 18:36 33
Цитата Сообщение от Sukharev_K Посмотреть сообщение
3)Задача сводится к тому, чтобы из входного массива брать по 30 элементов и сразу подавать на вход. И получается в этом цикле мы суммируем 30 входных данных перемноженных на веса для каждого события. Тоесть в первый проход берутся 1-30 значений, в следующий проход по этому циклу берутся 30-60 значения, понятно объясняю?))
C++
1
2
3
4
5
6
            for (int k = i; k<30; k++)
            {
                b1_1 += vxod[k + i] * w1_1[k];
                b1_2 += vxod[k + i] * w1_2[k];
                b1_3 += vxod[k + i] * w1_3[k];
            }
Цитата Сообщение от Sukharev_K Посмотреть сообщение
Из файла test, который прикрепил выше, ну для тестирования которые)
Не вижу среди прикреплённых
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 18:38  [ТС] 34
аа, я его не прикрепил, сори,он весит 20 мб, там 100000 значений)

Добавлено через 1 минуту
Могу на мыло скинуть.)
0
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 18:39 35
Цитата Сообщение от Sukharev_K Посмотреть сообщение
Могу на мыло скинуть.)
Можно ссылкой на диск) Ну либо функцию с помощью которой генерили
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 18:39  [ТС] 36
Цитата Сообщение от Albinos Посмотреть сообщение
3)Задача сводится к тому, чтобы из входного массива брать по 30 элементов и сразу подавать на вход. И получается в этом цикле мы суммируем 30 входных данных перемноженных на веса для каждого события. Тоесть в первый проход берутся 1-30 значений, в следующий проход по этому циклу берутся 30-60 значения, понятно объясняю?))
C++
1
2
3
4
5
6
* * * * * * for (int k = i; k<30; k++)
* * * * * * {
* * * * * * * * b1_1 += vxod[k + i] * w1_1[k];
* * * * * * * * b1_2 += vxod[k + i] * w1_2[k];
* * * * * * * * b1_3 += vxod[k + i] * w1_3[k];
* * * * * * }
Ну можно и так))
0
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 18:41 37
Цитата Сообщение от Sukharev_K Посмотреть сообщение
Ну можно и так))
В оригинале она будет выходить за границы w1_1 и т.д.
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 18:44  [ТС] 38
https://cloud.mail.ru/public/4DJh/3A1JegPPv

Их не генерировали, они взяты с датчика, для которого я пытаюсь написать нейросеть.)
На данный момент задача заключается в том, чтобы нейросеть могла распознавать события, дважды в секунду снимаются показатели, которые находятся в файле test, ну вот задача сводится закидывать в нейросеть 30 значений и чтобы она определяла есть ли кавитационный момент или нет на этом промежутке времени) ну тоесть там если значения выше 6 будут на этом промежутке то типо 1 должен выдавать, если просто к примеру один скачок был, либо вообще не выходило за макисмум, то 0. ВОт что я хочу сделать)
0
21 / 16 / 5
Регистрация: 22.06.2015
Сообщений: 68
19.05.2019, 18:51 39
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
#include <ctime>
#include <fstream>
#include <iostream>
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()
{
    srand(time(NULL));
    float w1_1[30], w1_2[30], w1_3[30];
    ifstream kf1("kf1.txt");
    ifstream kf2("kf2.txt");
    ifstream kf3("kf3.txt");
    for (int i = 0; i<30; i++)
    {
        w1_1[i] = 1 / (rand()%100 +1);
        w1_2[i] = 1 / (rand()%100 +1);
        w1_3[i] = 1 / (rand()%100 +1);
 
    }
    float w2_1 = 1 / (rand()%100 +1), w2_2 = 1 / (rand()%100 +1), w2_3 = 1 / (rand()%100 +1);
    float h = 0.01, cel = 0;
    float correctirovka[3];
    float delta[4];
    float b1_1 = 0, b1_2 = 0, b1_3 = 0, b2_1 = 0;
    float cor1_1[30], cor1_2[30], cor1_3[30];
    ifstream inp("input.txt");
    ifstream output("output.txt");
    float vxod[720], vyxod[24];
    for (int i = 0; i < 720; i++)
    {
        inp >> vxod[i];
    }
    for (int i = 0; i < 24; i++)
    {
        output >> vyxod[i];
    }
    for (int j = 0; j < 100; ++j)
    {
        int f = 0;
        cel = 0;
        for (int i = 0; i < 720; i = i + 30)
        {
            b1_1 = 0;
            b1_2 = 0;
            b1_3 = 0;
            for (int k = i; k<30; k++)
            {
                b1_1 += vxod[k + i] * w1_1[k];
                b1_2 += vxod[k + i] * w1_2[k];
                b1_3 += vxod[k + i] * w1_3[k];
            }
            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[f] - b2_1) * (vyxod[f] - b2_1);
 
            //
            delta[0] = -2 * (vyxod[f] - b2_1) * proizvod_activ_fun(b2_1);
 
 
            // 
            delta[1] = 2 * proizvod_activ_fun(b1_1)*delta[0] * w2_1;
            delta[3] = 2 * proizvod_activ_fun(b1_3)*delta[0] * w2_3;
            delta[2] = 2 * proizvod_activ_fun(b1_2)*delta[0] * w2_2;
            for (int q = 0; q<30; q++)
            {
                cor1_1[q] = -delta[1] * vxod[i + q] * h;
                cor1_2[q] = -delta[2] * vxod[i + q] * h;
                cor1_3[q] = -delta[3] * vxod[i + q] * h;
            }
            for (int w = 0; w<30; w++)
            {
                w1_1[w] = w1_1[w] + cor1_1[w];
                w1_2[w] = w1_2[w] + cor1_2[w];
                w1_3[w] = w1_3[w] + cor1_3[w];
            }
            // 
            correctirovka[0] = -delta[0] * h*b1_1;
            correctirovka[1] = -delta[0] * h*b1_2;
            correctirovka[2] = -delta[0] * h*b1_3;
 
            //
            w2_1 = w2_1 + correctirovka[0];
            w2_2 = w2_2 + correctirovka[1];
            w2_3 = w2_3 + correctirovka[2];
            f++;
        }
        if ((cel / 24) < 0.0002)
            break;
 
    }
    cout << w2_1 << " " << w2_2 << " " << w2_3 << endl;
    // 
    float test[114996];
    ifstream testirovanie("test.txt");
    for (int i = 0; i < 114996; i++)
    {
        testirovanie >> test[i];
    }
    ofstream fout("testik.txt");
   
    for (int i = 0; i<113996; i = i + 30)
    {
        b1_1 = 0;
        b1_2 = 0;
        b1_3 = 0;
        for (int k = i; k<30; k++)
        {
            b1_1 += test[k + i] * w1_1[k];
            b1_2 += test[k + i] * w1_2[k];
            b1_3 += test[k + i] * w1_3[k];
        }
        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);
        fout << b2_1 << endl;
    }
    fout.close();
    return 0;
}
В последнем инициализирующем цикле - опять выход за границу и не глядя скопировали предыдущий кусок. Вы же данные записываете в массив test, а не vxod, верно?)
0
0 / 0 / 0
Регистрация: 01.05.2019
Сообщений: 40
19.05.2019, 18:56  [ТС] 40
При тестировании я записываю данные в массив test, а потом выгружаю выходные данные в файл testik)
Не понял немного вашего вопроса..
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
19.05.2019, 18:56

Помощь в написании контрольных, курсовых и дипломных работ здесь.

Книги по С++ и нейронные сети
Уважаемые форумчане, может кто посоветовать книги (или статьи в интернете) по созданию нейронных...

Капсульные нейронные сети
Здравствуйте! Подскажите, подходит ли фреймворк JUCE для реализации капсульной нейронной сети на...

Нейронные сети(персептрон)
Привет всем. Недавно начал изучать нейронные сети. Понравилось, очень интересно. Хочу...

Нейронные сети. Перцептрон Розенблата
Здравствуйте! Помогите разобраться в коде (напишите комментарии). Уже несколько дней пытался...


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

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

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