Как убрать утечку памяти?

Question

[syxme]

class Layer
{
public:
	Layer();
	Layer(int size,int nextSize);
	int size;
	int nextSize;
	double* neurons;
	double* biases;
	double** weights;
};

void NeuralNetwork::backpropagation(double *targets)
{
    double* errors = new double[layers[layer_count - 1].size];
    for (int i = 0; i < layers[layer_count - 1].size; i++) {
        errors[i] = ( layers[layer_count - 1].neurons[i]- targets[i]);
    }
    for (int k = layer_count - 2; k >= 0; k--) {
        Layer* left= &layers[k];
        Layer* right = &layers[k + 1];
        double* errorsNext = new double[left->size];
        double *w_d = new double[right->size];
        double* w_err = new double[right->size];

        for (int i = 0; i < right->size; i++) {
            w_d[i] = errors[i] * derivative(right->neurons[i]);
            w_err[i] = w_d[i];
            w_d[i] *= learningRate;
        }
        double** deltas = new double*[right->size];
        for (int i = 0; i < right->size; i++) {
            deltas[i] = new double[left->size];
        }
        for (int i = 0; i < right->size; i++) {
            for (int j = 0; j < left->size; j++) {
                deltas[i][j] = w_d[i] * left->neurons[j];
            }
        }
        double **weightsNew = new double *[left->size];
        for (int i = 0; i < left->size; i++) {
            weightsNew[i] = new double[right->size];
        }

        for (int i = 0; i < right->size; i++) {
            for (int j = 0; j < left->size; j++) {
                weightsNew[j][i] = left->weights[j][i] - deltas[i][j];
            }
        }

        for (int i = 0; i < right->size; i++) {
            delete[] deltas[i];
        }
        for (int i = 0; i < layers[k].nextSize; i++) {
           delete [] layers[k].weights[i];
        }

        delete[]layers[k].weights;
        layers[k].weights = nullptr;
        delete[] deltas;
      
        layers[k].weights = weightsNew;
        int sizxx = sizeof(weightsNew);
        int sizxt = sizeof(weightsNew[0]);


        for (int i = 0; i < left->size; i++) {
            errorsNext[i] = 0;
            for (int j = 0; j < right->size; j++) {
                errorsNext[i] += weightsNew[i][j] * w_err[j];
            }
        }
       
        delete []errors;
        errors = new double[left->size];
        memcpy(errors, errorsNext, left->size * sizeof(double));
        for (int i = 0; i < right->size; i++) {
            right->biases[i] += w_d[i];
        }
        delete[]errorsNext;
        delete[]w_d;
        delete[]w_err;
          
    }
    delete[]errors;
}

Через профилирование кучи я понял что утечка в weightsNew.
В коде мне нужно сделать очистить layers[k].weights и заменить на weightsNew.
На сколько я понимаю я очищаю память в layers[k].weights и записываю указатель на weightsNew но как то получается утечка.
Подскажите, как с ней справиться?

Comments

[Евгений Шатунов]

syxme , коротко, утечку такого уровня можно легко убрать перестав писать на Ц с крестиками. Именно в таком стиле у тебя выполнен код. Пользователи C++ такого не одобряют. :)
Но я не о решении. Мне пока нужны детали.

Почему ты используешь double** weights? Хранить веса в массиве массивов - это крайне неэффективно для работы нейросети. У тебя строки весов могут быть разного размера?
Ты этот код пробовал трассировать? Что трассировка показывает?
Какой из наборов адресов выпадает из удаления: с текущей итерации метода или с какой-либо из прошлых?

Я вижу layers[k].weights = weightsNew;, перед которым идет delete[]layers[k].weights;, а где у тебя удаляются строки layers[k].weights, что ранее были выделены в этом цикле?

for (int i = 0; i < left->size; i++) {
   weightsNew[i] = new double[right->size];
}

[syxme]

Евгений Шатунов, Нашел утечку, дело было в очистке

for (int i = 0; i < layers[k].nextSize; i++) { // я пытался очистить внутри массива весов размером самих весов 
           delete [] layers[k].weights[i];
 }
 delete [] layers[k].weights;

for (int i = 0; i < layers[k].size; i++) { // просто size это количество нейронов а nextSize количество весов 
           delete [] layers[k].weights[i];
 }
 delete [] layers[k].weights;

Теперь после 250к эпох 700кб и не меняется))

Я в c++ пришел с js -> nodejs -> java -> с++
Так что не знаю еще как правильно делать ))
Буду рад совету как это сделать быстрее и практичнее)

[res2001]

syxme, Можно еще убрать

memcpy(errors, errorsNext, left->size * sizeof(double));

Вместо этого сделать просто присвоение указателей:
errors = errorsNext;
И освобождение errorsNext уже делать не надо.

Вообще двумерные массивы в таком виде - зло. Лучше выделять память одним большим куском сразу для всего массива. Плюсы:
1.код будет быстрее так как: меньше выделений/освобождений памяти, память для однородных элементов будет выделена в одном блоке, что теоретически увеличит попадания в кэш (хотя применительно к вашему конкретному случаю вряд ли будет большое ускорение из-за кэша).
2.меньше проблем с утечками и проще отлаживать
Минусы:
1.индексация [i][j] работать не будет.
Но это можно обойти перейдя на стиль итераторов.
Или конвертировать указатель в указатель на массив (пример тут). Правда массивов переменной длинны в стандарте С++ нет. Но если вы собираете с помощью gcc/clang с включенными расширениями (по умолчанию) то это то же будет работать. На микросовтовском компиляторе наверняка не соберется.

Вообще, конечно, нужно исопльзовать std::vector для динамических массивов.

[Евгений Шатунов]

syxme, совет простой. Используй std::vector вместо голых массивов. Голый массив не дает о себе никакой информации.
Вместе с этим, не стоит использовать многомерные массивы или вектора векторов если ты реализуешь представление регулярного многомерного пространства. Позиция регулярного многомерного пространства легко может быть отображена на позицию одномерного пространства - т.е. того же вектора.
При этом, линейный проход по вектору от начала и до конца является довольно быстрым, т.к. требуемая для этого память однозначно предсказывается и своевременно догружается в кэш процессора, не заставляя твой алгоритм вставать на синхронизацию с памятью кэша процессора.
Несравнимым плюсом работы с вектором будет и простота его перестройки, которая гарантированно не приведет к утечкам.

Например.

struct Layer final
{
	std::vector<double> neurons;
	std::vector<double> biases;
	std::vector<double> weights;
	size_t size = 0;
	szie_t next_size = 0;
	
	Layer() = default;
	Layer( int size,int nextSize );
	
	double& AccessWeight(const size_t x, const size_t y);
	const double GetWeight(const size_t x, const size_t y) const;
};

Тебе не нужен class если ты не пользуешься областями видимости. Тебе не нужен struct если ты областями видимости пользуешься.

[syxme]

Спасибо огромное )) Буду оптимизировать)

Answer 1

[Александр Ананьев]

В c++ рекомендуется использование std::vector для динамических массивов. Тогда и проблем с утечкой памяти не будет.