Форум программистов, компьютерный форум, киберфорум
Наши страницы
Konst2016
Войти
Регистрация
Восстановить пароль
Оценить эту запись

Си нейросеть строит график обучения через Python

Запись от Konst2016 размещена 13.11.2019 в 15:34

Здравствуйте!Показываю код нейросети на Си,где она обучается логическому XOR(эпохи и коэффициент обучения берет из командной строки),и выводит график посредством Python matplotlib через то что называется встраивание Python в C/C++ приложение.Здесь Python можно назвать плагином.Еще примерно 6 месяцев назад не мог толком отрефакторить код,который я взял с гитхаб и не был уверен что встрою Python.Но все получилось!)Собирал с Mingw(не Msys2) для 32битного Python,там есть файлы инклудов и линковки(с расширением a).Потом нужно было добавить в переменную path bin от MingW,иначе не запускалось,писала ошибку 0x000007b(не windows образ).Понять обратное распространение нужно имея некоторое математическое понимание.
Итак:
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
// хедер henNN.h
/* 
 * File:   hedNN.h
 * Author: papa
 *
 * Created on 9 ноября 2019 г., 23:23
 */
#ifndef HEDNN_H
#define HEDNN_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>
  // Представляет из себя слой
    typedef struct {
      int in;  // сенсоры данного слоя
      int out;// связи-выходы-данного-слоя-синапсы
      float** matrix;// матрица весов данного слоя
      float* hidden;// что получилось при функции активации
      float* errors;// ошибки данного слоя,их можно сразу наложить на матрицу весо-подправить
    } nnLay;
  //------------------прототипы для обучения-----------------
    float
    sigmoida(float val);
    float
    sigmoidasDerivate(float val);
    void
    backPropagate();
    void
    feedForwarding(bool ok);
    void
    train(float *in, float *targ);
    void
    query(float *in);
    int
    getInCount(nnLay *curLay);
    int
    getOutCount(nnLay *curLay);
    float **
    getMatrix(nnLay *curLay);
    void
    updMatrix(nnLay *curLay, float *enteredVal);
    void 
    calcHidZeroLay(nnLay* zeroLay, float* targets);
    void
    setIO(nnLay *curLay, int inputs, int outputs);
    void
    init(float lr);
    void
    fit(int _epochs);
    void
    makeHidden(nnLay *curLay, float *inputs);
    float*
    getHidden(nnLay *curLay);
    void
    calcOutError(nnLay *curLay, float *targets);
    void
    calcHidError(nnLay *curLay, float *targets, float *enteredVals);
    float*
    getErrors(nnLay *curLay);
    float
    getMinimalSquareError(float *vec, int size_vec);
    void
    destruct();
  //----------------------------------------------------
#ifdef __cplusplus
}
#endif
#endif /* HEDNN_H */
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
// хедер hedPy.h
/* 
 * File:   hedPy.h
 * Author: papa
 *
 * Created on 10 ноября 2019 г., 20:08
 */
#ifndef HEDPY_H
#define HEDPY_H
extern "C" {
#include <Python.h>
}
PyObject *pName = NULL, *pModule = NULL;
PyObject *pDict = NULL, *pObjct = NULL, *pVal = NULL;
PyObject* sys = NULL;
PyObject* sys_path = NULL;
PyObject* folder_path = NULL;
PyObject *
python_init(char *);
void
python_clear();
void
python_func_get_str(char *val);
int
python_func_get_val(char *val);
int
do_custum_func(const char* func, PyObject* pArgs);
#endif  /* HEDPY_H */
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
// main.cpp
#include "hedNN.h"
#include "hedPy.h"
#include <vector>
using namespace std;
//------------------Basic NeiroNet Structures--------------------dddddddd
typedef struct {
    nnLay *list;
  int inputNeurons;// количество выходных нейронов
  int outputNeurons;// количество входных нейронов
  int nlCount;// количество слоев
    vector<int> epochs;
    vector<float>mse;
    float *inputs;
    float *targets;
  float lr;// коэффициент обучения
} whole_NN_params;
whole_NN_params * NN;
//------------------------------------------------------------------
//==================================================================
int main(int argc, char * argv[])
{
    float lr; 
    int epochs;
    // получить аргументы из командной строки
    if (argv[1] != NULL && argv[2] != NULL) {
        lr = (float) atof(argv[1]);
        epochs = atoi(argv[2]);
    }
    if (!python_init((char*) "plot")) {
        puts("python_init error");
        return -1;
    }
    //---------Объекты Python-а-------------
    PyObject* py_tup = NULL;
    PyObject * py_lst_x = NULL;
    PyObject * py_lst_y = NULL;
        //----------запускаем нейросеть----------
    init(lr);
    fit(epochs);
    //---------------------------------------
    //-----------В Python строим график------
    py_lst_x = PyList_New(NN->epochs.size());
    py_lst_y = PyList_New(NN->mse.size());
    py_tup = PyTuple_New(2);
    for (int i = 0; i < NN->epochs.size(); i++) {
        PyList_SetItem(py_lst_x, i, Py_BuildValue("i", NN->epochs[i]));
    }
    for (int i = 0; i < NN->mse.size(); i++) {
        PyList_SetItem(py_lst_y, i, Py_BuildValue("f", NN->mse[i]));
    }
    PyTuple_SetItem(py_tup, 0, py_lst_x);
    PyTuple_SetItem(py_tup, 1, py_lst_y);
    do_custum_func("plot_graphic_by_x_and_y", py_tup);
    Py_XDECREF(py_lst_x);
    Py_XDECREF(py_lst_y);
    python_clear();
    //------------------------------------------
    destruct();
    return 0;
}
//==================================================================
//---------------------Python as Plugin part------------------------
/*
 * Загрузка интерпритатора python и модуля "-//-" в него.
 */
PyObject *
python_init(char * py_module_name)
{
    // Инициализировать интерпретатор Python
    Py_Initialize();
    do {
        // Загрузка модуля sys
        // Но переменную среды PYTHONHOME не меняем,
        // пусть плагин из этой переменной находит Lib и DLLs
        sys = PyImport_ImportModule("sys");
        sys_path = PyObject_GetAttrString(sys, "path");
        // Путь до наших исходников python
        // То,что строит график лежит в <где exe-шник>/src/python/plot.py
        folder_path = PyUnicode_FromString((const char*) "./src/python");
        PyList_Append(sys_path, folder_path);
        // Создание Unicode объекта из UTF-8 строки
        pName = PyUnicode_FromString(py_module_name);
        if (!pName) {
            break;
        }
        // Загрузить модуль client
        pModule = PyImport_Import(pName);
        if (!pModule) {
            break;
        }
        // Словарь объектов содержащихся в модуле
        pDict = PyModule_GetDict(pModule);
        if (!pDict) {
            break;
        }
        return pDict;
    } while (0);
    // Печать ошибки
    PyErr_Print();
}
/*
 * Освобождение ресурсов интерпритатора python
 */
void
python_clear()
{
    // Вернуть ресурсы системе
    Py_XDECREF(pDict);
    Py_XDECREF(pModule);
    Py_XDECREF(pName);
    Py_XDECREF(folder_path);
    Py_XDECREF(sys_path);
    Py_XDECREF(sys);
    // Выгрузка интерпритатора Python
    Py_Finalize();
}
int
do_custum_func(const char* func, PyObject * pArgs)
{
    pObjct = PyDict_GetItemString(pDict, (const char *) func);
    if (!pObjct) {
        return -1;
    }
    do {
        {
            // Проверка pObjct на годность.
            if (!PyCallable_Check(pObjct)) {
                break;
            }
            pVal = PyObject_CallObject(pObjct, pArgs);
            if (pVal != NULL) {
                Py_XDECREF(pVal);
            } else {
                PyErr_Print();
            }
        }
    } while (0);
    PyErr_Print();
    return 0;
}
//----------------------------------------------------------------
//---------------------Init,Fit and Destroy NeiroNet--------------
void
init(float lr)
{
    NN = (whole_NN_params*) malloc(sizeof(whole_NN_params));
    NN->inputNeurons = 2;
    NN->outputNeurons = 1;
    NN->nlCount = 3;
    NN->list = (nnLay*) malloc((NN->nlCount) * sizeof(nnLay));
    NN->lr = lr;
}
void
destruct()
{
    free(NN);
    free(NN->list);
}
void
fit(int epochs)
{
    // для обучения
    setIO(&NN->list[0], 2, 2);
    setIO(&NN->list[1], 2, 2);
    setIO(&NN->list[2], 2, 1);
    float *matrix_learn;
    int inputNeurons = NN->inputNeurons; // 2 входа сети
    int outputNeurons = NN->outputNeurons; // 1 выход сети
    int learn_matr_heig = 4;
    // Тренеруем логическое XOR
    // матрица(как лента) в 4 ряда с кейсами обучения,задачами для логического XOR
    matrix_learn = (float*) malloc(inputNeurons * learn_matr_heig * sizeof(float));
    // set
    matrix_learn[0] = 1.0;
    matrix_learn[1] = 1.0;
    matrix_learn[2] = 1.0;
    matrix_learn[3] = 0.0;
    matrix_learn[4] = 0.0;
    matrix_learn[5] = 1.0;
    matrix_learn[6] = 0.0;
    matrix_learn[7] = 0.0;
    // матрица(как лента) в 4 ряда с кейсами ответами для задач логического XOR
    float *matrix_target;
    matrix_target = (float*) malloc(learn_matr_heig * sizeof(float));
    matrix_target[0] = 0.0;
    matrix_target[1] = 1.0;
    matrix_target[2] = 1.0;
    matrix_target[3] = 0.0;
    // итерации,обучение
    int nEpoch = epochs;
    int epocha = 0;
    // временные вектора для процесса обучения
    float * tmp_vec_learn = (float *) malloc(inputNeurons * sizeof(float));
    float * tmp_vec_targ = (float *) malloc(outputNeurons * sizeof(float));
    float mse;
    int learn_matr_wid = inputNeurons;
    while (epocha < nEpoch) {
        printf("num Epoch: %d\n", epocha + 1);
        for (int row = 0; row < learn_matr_heig; row++) {
            printf("Vec row:[");
            for (int elem = 0; elem < inputNeurons; elem++) {
                tmp_vec_learn[elem] = *(matrix_learn + row * learn_matr_wid + elem);
                printf("%f,", tmp_vec_learn[elem]);
            }
            printf("] ; Targ row:[");
            for (int targ_row = 0; targ_row < outputNeurons; targ_row++) {
                tmp_vec_targ[targ_row] = *(matrix_target + row);
                printf("%f", tmp_vec_targ[targ_row]);
            }
            printf("]\n");
            train(tmp_vec_learn, tmp_vec_targ);
            printf("mse: %f\n", mse);
            mse = getMinimalSquareError(getHidden(&NN->list[NN->nlCount - 1]), NN->outputNeurons);
        }
        NN->mse.push_back(mse);
        epocha++;
        NN->epochs.push_back(epocha);
    }
    // деструкторы
    free(matrix_learn);
    free(matrix_learn);
    free(tmp_vec_learn);
    free(tmp_vec_targ);
}
//===============================================================
//--------------------Basic Functions for Learn------------------
void
backPropagate()
{
    //-------------------------------ERRORS-----CALC---------
    calcOutError(&NN->list[NN->nlCount - 1], NN->targets);
    calcHidError(&NN->list[NN->nlCount - 1], getErrors(&NN->list[NN->nlCount - 1]), getHidden(&NN->list[NN->nlCount - 2]));
    for (int i = NN->nlCount - 2; i > 0; i--)
        calcHidError(&NN->list[i], getErrors(&NN->list[i + 1]), getHidden(&NN->list[i - 1]));
    // последнему слою не нужны входа т.к. у них нет функции активации
    calcHidZeroLay(&NN->list[0], getErrors(&NN->list[1]));
    //-------------------------------UPD-----WEIGHT---------
    for (int i = NN->nlCount - 1; i > 0; i--)
        updMatrix(&NN->list[i], getHidden(&NN->list[i - 1]));
    updMatrix(&NN->list[0], NN->inputs);
}
//---------------------------------------------
//---------------------Learn-------------------
/*
обучение с учителем с train set
@param in инфо
@param targ правильный ответ от учител¤
 */
void
train(float *in, float *targ)
{
    NN->inputs = in;
    NN->targets = targ;
    feedForwarding(false);
}
void
feedForwarding(bool ok)
{
    // если ok = true - обучаемся, перед этим выполним один проход по сети
    makeHidden(&NN->list[0], NN->inputs); 
    // для данного слоя получить то что отдал пред-слой
    {
        for (int i = 1; i < NN->nlCount; i++)
            //получаем отдачу слоя и передаем ее следующему  справа как аргумент
            makeHidden(&NN->list[i], getHidden(&NN->list[i - 1]));
    }
    if (ok) {
        printf("Feed Forward: ");
        for (int out = 0; out < NN->outputNeurons; out++) { // при спрашивании сети - отпечатаем вектор последнего сло¤
            printf("%f ", NN->list[NN->nlCount - 1].hidden[out]);
        }
        return;
    } else {
        backPropagate();
    }
}
int
getInCount(nnLay *curLay)
{
    return curLay->in;
}
int
getOutCount(nnLay *curLay)
{
    return curLay->out;
}
float **
getMatrix(nnLay *curLay)
{
    return curLay->matrix;
}
void
updMatrix(nnLay *curLay, float *enteredVal)
{
    for (int row = 0; row < curLay->in; row++) {
        for (int elem = 0; elem < curLay->out; elem++) {
            curLay->matrix[row][elem] += (NN->lr * curLay->errors[elem] * enteredVal[elem]);
        }
    }
}
#define randWeight(out) (( ((float)rand() / (float)RAND_MAX) - 0.5)* pow(out,-0.5))
void
setIO(nnLay *curLay, int outputs, int inputs)
{
    {
        // сенсоры
        curLay->in = inputs;
        // нейроны-выходы-синапсы
        curLay->out = outputs;
        // отдача нейронов
        curLay->hidden = (float*) malloc((curLay->out) * sizeof(float));
        curLay->matrix = (float**) malloc((curLay->out) * sizeof(float));
    }
    for (int row = 0; row < curLay->out; row++) {
        curLay->matrix[row] = (float*) malloc(curLay->in * sizeof(float));
    }
    for (int row = 0; row < curLay->out; row++) {
        for (int elem = 0; elem < curLay->in; elem++) {
            curLay->matrix[row][elem] = randWeight(curLay->in);
        }
    }
}
void
makeHidden(nnLay *curLay, float *inputs)
{
    for (int row = 0; row < curLay->out; row++) {
        float tmpS = 0.0;
        for (int elem = 0; elem < curLay->in; elem++) {
            tmpS += curLay->matrix[row][elem] * inputs[elem];
        }
        curLay->hidden[row] = sigmoida(tmpS);
    }
}
float*
getHidden(nnLay *curLay)
{
    return curLay->hidden;
}
void
calcOutError(nnLay *curLay, float *targets)
{
    {
        curLay->errors = (float*) malloc((curLay->out) * sizeof(float));
    }
    for (int row = 0; row < curLay->out; row++) {
        curLay->errors[row] = (targets[row] - curLay->hidden[row]) * sigmoidasDerivate(curLay->hidden[row]);
    }
}
void
calcHidError(nnLay *curLay, float *targets, float *enteredVals)
{
    {
        curLay->errors = (float*) malloc((curLay->in) * sizeof(float));
    }
    for (int elem = 0; elem < curLay->in; elem++) {
        {
            curLay->errors[elem] = 0.0;
        }
        for (int row = 0; row < curLay->in; row++) {
            curLay->errors[elem] += targets[row] * curLay->matrix[row][elem];
            curLay->errors[elem] *= sigmoidasDerivate(enteredVals[elem]);
        }
    }
}
void
calcHidZeroLay(nnLay* zeroLay, float * targets)
{
    {
        zeroLay->errors = (float*) malloc((zeroLay->in) * sizeof(float));
    }
    for (int elem = 0; elem < zeroLay->in; elem++) {
        {
            zeroLay->errors[elem] = 0.0;
        }
        for (int row = 0; row < zeroLay->out; row++) {
            zeroLay->errors[elem] += targets[row] * zeroLay->matrix[row][elem];
        }
    }
}
float*
getErrors(nnLay *curLay)
{
    return curLay->errors;
}
float
getMinimalSquareError(float *vec, int size_vec)
{
    float sum;
    for (int row = 0; row < size_vec; row++) {
        sum += vec[row];
    }
    float mean = sum / size_vec;
    float square = pow(mean, 2);
    return square;
}
float
sigmoida(float val)
{
    return(1.0 / (1.0 + exp(-val)));
}
float
sigmoidasDerivate(float val)
{
    return(val * (1.0 - val));
}
//--------------------------------------------------------------
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# <относительно exeшника> ./src/python/plot.py
import sys;sys.argv = ['test'] # Здесь обязательно указываем имя скрипта,что бы Matplotlib работал 
import matplotlib.pyplot as plt
def plot_graphic_by_x_and_y(*args): 
  fig,ax=plt.subplots() 
  ax.plot(args[0],args[1])
  ax.grid()
  ax.set_xlabel("epocha",
          fontsize=15,
          color='red',
          bbox={'boxstyle':'rarrow',
              'pad':0.1,
              'edgecolor':'red',
              'linewidth':3})
  ax.set_ylabel("mse",
          fontsize=15,
          color='red',
          bbox={'boxstyle':'rarrow',
              'pad':0.1,
              'edgecolor':'red',
              'linewidth':3})
  fig.set_figwidth(9)
  fig.set_figheight(9)       
  plt.show()
Сам график:
Нажмите на изображение для увеличения
Название: Figure_1.png
Просмотров: 1629
Размер:	42.7 Кб
ID:	5706
Сделал небольшое видео по основе:https://www.youtube.com/watch?v=Nn1OA7U-q2o&t=197s,https://www.youtube.com/watch?v=gNAbVDhn8Is
До свидания!)
Размещено в Без категории
Просмотров 98 Комментарии 0
Всего комментариев 0
Комментарии
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.