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

// хедер 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 */

// хедер 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 */

// 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));
}
//--------------------------------------------------------------