tipe/src/mnist_cnn/free.c

#include <stdlib.h>
#include <stdio.h>
#include "free.h"

void free_a_cube_input_layer(Network* network, int pos, int depth, int dim) {
    int i, j, k;
    for (i=0; i<depth; i++) {
        for (j=0; j<dim; j++) {
            free(network->input[pos][i][j]);
        }
        free(network->input[pos][i]);
    }
    free(network->input[pos]);
}

void free_a_line_input_layer(Network* network, int pos) {
    free(network->input[pos][0][0]);
    free(network->input[pos][0]);
    free(network->input[pos]);
}

void free_average_pooling(Network* network, int pos) {
    free_a_cube_input_layer(network, pos, network->dim[pos-1][1], network->dim[pos-1][0]/2);
}

void free_average_pooling_flatten(Network* network, int pos) {
    free_a_line_input_layer(network, pos);
}

void free_convolution(Network* network, int pos) {
    int i, j, k, c = network->kernel[pos].cnn->columns;
    int k_size = network->kernel[pos].cnn->k_size;
    int r = network->kernel[pos].cnn->rows;
    free_a_cube_input_layer(network, pos, c, network->dim[pos-1][0] - 2*(k_size/2));
    for (i=0; i<c; i++) {
        for (j=0; j<k_size; j++) {
            free(network->kernel[pos].cnn->bias[i][j]);
            free(network->kernel[pos].cnn->d_bias[i][j]);
        }
        free(network->kernel[pos].cnn->bias[i]);
        free(network->kernel[pos].cnn->d_bias[i]);
    }
    free(network->kernel[pos].cnn->bias);
    free(network->kernel[pos].cnn->d_bias);

    for (i=0; i<r; i++) {
        for (j=0; j<c; j++) {
            for (k=0; k<k_size; k++) {
                free(network->kernel[pos].cnn->w[i][j][k]);
                free(network->kernel[pos].cnn->d_w[i][j][k]);
            }
            free(network->kernel[pos].cnn->w[i][j]);
            free(network->kernel[pos].cnn->d_w[i][j]);
        }
        free(network->kernel[pos].cnn->w[i]);
        free(network->kernel[pos].cnn->d_w[i]);
    }
    free(network->kernel[pos].cnn->w);
    free(network->kernel[pos].cnn->d_w);

    free(network->kernel[pos].cnn);
}

void free_dense(Network* network, int pos) {
    free_a_line_input_layer(network, pos);
    int i, dim = network->kernel[pos].nn->output_units;
    for (int i=0; i<dim; i++) {
        free(network->kernel[pos].nn->weights[i]);
        free(network->kernel[pos].nn->d_weights[i]);
    }
    free(network->kernel[pos].nn->weights);
    free(network->kernel[pos].nn->d_weights);

    free(network->kernel[pos].nn->bias);
    free(network->kernel[pos].nn->d_bias);

    free(network->kernel[pos].nn);
}

void free_network_creation(Network* network) {
    free_a_cube_input_layer(network, 0, network->dim[0][1], network->dim[0][0]);

    for (int i=0; i<network->max_size; i++) {
        free(network->dim[i]);
    }
    free(network->dim);

    free(network->kernel);
    free(network->input);

    free(network);
}

void free_network_lenet5(Network* network) {
    free_dense(network, 6);
    free_dense(network, 5);
    free_dense(network, 4);
    free_average_pooling_flatten(network, 3);
    free_convolution(network, 2);
    free_average_pooling(network, 1);
    free_convolution(network, 0);
    free_network_creation(network);
    if (network->size != network->max_size) {
        printf("Attention, le réseau LeNet5 n'est pas complet");
    }
}