augustin64/tipe
1
1
Fork 0
mirror of https://github.com/augustin64/projet-tipe synced 2025-04-22 13:23:53 +02:00
Code Issues Packages Projects Releases Wiki Activity

Leak repairs in free.c/h

Browse Source
This commit is contained in:
Julien Chemillier 2022-10-02 16:16:14 +02:00
parent dfe7fc7731
commit 8ea6062440
2 changed files with 68 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
src/cnn/free.c
View File

@ -18,69 +18,86 @@ void free_a_line_input_layer(Network* network, int pos) {
free(network->input[pos]);
}
void free_average_pooling(Network* network, int pos) {
free_a_cube_input_layer(network, pos, network->depth[pos-1], network->width[pos-1]/2);
}
void free_average_pooling_flatten(Network* network, int pos) {
free_a_line_input_layer(network, pos);
void free_2d_average_pooling(Network* network, int pos) {
free_a_cube_input_layer(network, pos+1, network->depth[pos-1], network->width[pos-1]/2);
}
void free_convolution(Network* network, int pos) {
int 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->width[pos-1] - 2*(k_size/2));
Kernel_cnn* k_pos = network->kernel[pos]->cnn;
int c = k_pos->columns;
int k_size = k_pos->k_size;
int r = k_pos->rows;
int bias_size = network->width[pos-1]-k_size+1; // Not sure of the value
free_a_cube_input_layer(network, pos+1, c, bias_size);
for (int i=0; i < c; i++) {
for (int j=0; j < k_size; j++) {
free(network->kernel[pos]->cnn->bias[i][j]);
free(network->kernel[pos]->cnn->d_bias[i][j]);
for (int j=0; j < bias_size; j++) {
free(k_pos->bias[i][j]);
free(k_pos->d_bias[i][j]);
}
free(network->kernel[pos]->cnn->bias[i]);
free(network->kernel[pos]->cnn->d_bias[i]);
free(k_pos->bias[i]);
free(k_pos->d_bias[i]);
}
free(network->kernel[pos]->cnn->bias);
free(network->kernel[pos]->cnn->d_bias);
free(k_pos->bias);
free(k_pos->d_bias);
for (int i=0; i < r; i++) {
for (int j=0; j < c; j++) {
for (int 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(k_pos->w[i][j][k]);
free(k_pos->d_w[i][j][k]);
}
free(network->kernel[pos]->cnn->w[i][j]);
free(network->kernel[pos]->cnn->d_w[i][j]);
free(k_pos->w[i][j]);
free(k_pos->d_w[i][j]);
}
free(network->kernel[pos]->cnn->w[i]);
free(network->kernel[pos]->cnn->d_w[i]);
free(k_pos->w[i]);
free(k_pos->d_w[i]);
}
free(network->kernel[pos]->cnn->w);
free(network->kernel[pos]->cnn->d_w);
free(k_pos->w);
free(k_pos->d_w);
free(network->kernel[pos]->cnn);
free(k_pos);
}
void free_dense(Network* network, int pos) {
free_a_line_input_layer(network, pos);
int dim = network->kernel[pos]->nn->output_units;
free_a_line_input_layer(network, pos+1);
Kernel_nn* k_pos = network->kernel[pos]->nn;
int dim = k_pos->input_units;
for (int i=0; i < dim; i++) {
free(network->kernel[pos]->nn->weights[i]);
free(network->kernel[pos]->nn->d_weights[i]);
free(k_pos->weights[i]);
free(k_pos->d_weights[i]);
}
free(network->kernel[pos]->nn->weights);
free(network->kernel[pos]->nn->d_weights);
free(k_pos->weights);
free(k_pos->d_weights);
free(network->kernel[pos]->nn->bias);
free(network->kernel[pos]->nn->d_bias);
free(k_pos->bias);
free(k_pos->d_bias);
free(network->kernel[pos]->nn);
free(k_pos);
}
void free_dense_linearisation(Network* network, int pos) {
free_a_line_input_layer(network, pos+1);
Kernel_nn* k_pos = network->kernel[pos]->nn;
int dim = k_pos->input_units;
for (int i=0; i < dim; i++) {
free(k_pos->weights[i]);
free(k_pos->d_weights[i]);
}
free(k_pos->weights);
free(k_pos->d_weights);
free(k_pos->bias);
free(k_pos->d_bias);
free(k_pos);
}
void free_network_creation(Network* network) {
free_a_cube_input_layer(network, 0, network->depth[0], network->width[0]);
for (int i=0; i<network->max_size; i++)
free(network->kernel[i]);
free(network->width);
free(network->depth);
free(network->kernel);
free(network->input);
@ -90,8 +107,8 @@ void free_network_creation(Network* 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_dense_linearisation(network, 4);
free_average_pooling(network, 3);
free_convolution(network, 2);
free_average_pooling(network, 1);
free_convolution(network, 0);

24
src/cnn/include/free.h
View File

@ -5,41 +5,43 @@
/*
* Libère la mémoire allouée à une couche de type input cube
* Donc free networkt->input[pos][i][j]
*/
void free_a_cube_input_layer(Network* network, int pos, int depth, int dim);
/*
* Libère la mémoire allouée à une couche de type input line
* Donc free networkt->input[pos][0][0]
*/
void free_a_line_input_layer(Network* network, int pos);
/*
* Libère l'espace mémoie et supprime une couche d'average pooling classique
* Libère l'espace mémoire alloué dans 'add_2d_average_pooling' (creation.c)
*/
void free_average_pooling(Network* network, int pos);
void free_2d_average_pooling(Network* network, int pos);
/*
* Libère l'espace mémoie et supprime une couche d'average pooling flatten
*/
void free_average_pooling_flatten(Network* network, int pos);
/*
* Libère l'espace mémoire et supprime une couche de convolution
* Libère l'espace mémoire dans 'add_convolution' (creation.c)
*/
void free_convolution(Network* network, int pos);
/*
* Libère l'espace mémoire et supprime une couche dense
* Libère l'espace mémoire alloué dans 'add_dense' (creation.c)
*/
void free_dense(Network* network, int pos);
/*
* Libère l'espace alloué dans la fonction 'create_network'
* Libère l'espace mémoire alloué dans 'add_dense_linearisation' (creation.c)
*/
void free_dense_linearisation(Network* network, int pos);
/*
* Libère l'espace mémoire alloué dans 'create_network' (creation.c)
*/
void free_network_creation(Network* network);
/*
* Libère l'espace alloué dans la fonction 'create_network_lenet5'
* Libère l'espace mémoire alloué dans 'create_network_lenet5' (creation.c)
*/
void free_network_lenet5(Network* network);