augustin64/tipe
1
1
Fork 0
mirror of https://github.com/augustin64/projet-tipe synced 2025-01-23 23:26:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

Change network->kernel definition

Browse Source
This commit is contained in:
augustin64 2022-09-10 17:17:49 +02:00
parent e280d3e9da
commit 4720fb18e1
3 changed files with 68 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/mnist_cnn/cnn.c
View File

@ -33,32 +33,32 @@ void forward_propagation(Network* network) {
int output_dim, output_depth;
float*** output;
for (int i=0; i < network->size-1; i++) {
if (network->kernel[i].nn==NULL && network->kernel[i].cnn!=NULL) { //CNN
if (network->kernel[i]->nn==NULL && network->kernel[i]->cnn!=NULL) { //CNN
output = network->input[i+1];
output_dim = network->dim[i+1][0];
output_depth = network->dim[i+1][1];
make_convolution(network->input[i], network->kernel[i].cnn, output, output_dim);
choose_apply_function_input(network->kernel[i].activation, output, output_depth, output_dim, output_dim);
make_convolution(network->input[i], network->kernel[i]->cnn, output, output_dim);
choose_apply_function_input(network->kernel[i]->activation, output, output_depth, output_dim, output_dim);
}
else if (network->kernel[i].nn!=NULL && network->kernel[i].cnn==NULL) { //NN
make_fully_connected(network->input[i][0][0], network->kernel[i].nn, network->input[i+1][0][0], network->dim[i][0], network->dim[i+1][0]);
choose_apply_function_input(network->kernel[i].activation, network->input[i+1], 1, 1, network->dim[i+1][0]);
else if (network->kernel[i]->nn!=NULL && network->kernel[i]->cnn==NULL) { //NN
make_fully_connected(network->input[i][0][0], network->kernel[i]->nn, network->input[i+1][0][0], network->dim[i][0], network->dim[i+1][0]);
choose_apply_function_input(network->kernel[i]->activation, network->input[i+1], 1, 1, network->dim[i+1][0]);
}
else { //Pooling
if (network->size-2==i) {
printf("Le réseau ne peut pas finir par une pooling layer");
return;
}
if (network->kernel[i+1].nn!=NULL && network->kernel[i+1].cnn==NULL) {
make_average_pooling_flattened(network->input[i], network->input[i+1][0][0], network->kernel[i].activation/100, network->dim[i][1], network->dim[i][0]);
choose_apply_function_input(network->kernel[i].activation%100, network->input[i+1], 1, 1, network->dim[i+1][0]);
if (network->kernel[i+1]->nn!=NULL && network->kernel[i+1]->cnn==NULL) {
make_average_pooling_flattened(network->input[i], network->input[i+1][0][0], network->kernel[i]->activation/100, network->dim[i][1], network->dim[i][0]);
choose_apply_function_input(network->kernel[i]->activation%100, network->input[i+1], 1, 1, network->dim[i+1][0]);
}
else if (network->kernel[i+1].nn==NULL && network->kernel[i+1].cnn!=NULL) {
make_average_pooling(network->input[i], network->input[i+1], network->kernel[i].activation/100, network->dim[i+1][1], network->dim[i+1][0]);
choose_apply_function_input(network->kernel[i].activation%100, network->input[i+1], network->dim[i+1][1], network->dim[i+1][0], network->dim[i+1][0]);
else if (network->kernel[i+1]->nn==NULL && network->kernel[i+1]->cnn!=NULL) {
make_average_pooling(network->input[i], network->input[i+1], network->kernel[i]->activation/100, network->dim[i+1][1], network->dim[i+1][0]);
choose_apply_function_input(network->kernel[i]->activation%100, network->input[i+1], network->dim[i+1][1], network->dim[i+1][0], network->dim[i+1][0]);
}
else {
printf("Le réseau ne peut pas contenir deux poolings layers collées");
printf("Le réseau ne peut pas contenir deux pooling layers collées");
return;
}
}
@ -71,7 +71,7 @@ void backward_propagation(Network* network, float wanted_number) {
float loss = compute_cross_entropy_loss(network->input[n][0][0], wanted_output, network->dim[n][0]);
for (int i=n; i >= 0; i--) {
if (i==n) {
if (network->kernel[i].activation == SOFTMAX) {
if (network->kernel[i]->activation == SOFTMAX) {
int l2 = network->dim[i][0]; // Taille de la dernière couche
int l1 = network->dim[i-1][0];
for (int j=0; j < l2; j++) {
@ -79,18 +79,18 @@ void backward_propagation(Network* network, float wanted_number) {
}
}
else {
printf("Erreur, seule la fonction softmax est implémentée pour la dernière couche");
printf("Erreur, seule la fonction SOFTMAX est implémentée pour la dernière couche");
return;
}
}
else {
if (network->kernel[i].activation == SIGMOID) {
if (network->kernel[i]->activation == SIGMOID) {
}
else if (network->kernel[i].activation == TANH) {
else if (network->kernel[i]->activation == TANH) {
}
else if (network->kernel[i].activation == RELU) {
else if (network->kernel[i]->activation == RELU) {
}
}
@ -127,8 +127,7 @@ float* generate_wanted_output(float wanted_number) {
}
int main() {
Network* network;
network = create_network_lenet5(0, TANH, GLOROT_NORMAL);
Network* network = create_network_lenet5(0, TANH, GLOROT_NORMAL);
forward_propagation(network);
return 0;
}

96
src/mnist_cnn/creation.c
View File

@ -14,10 +14,11 @@ Network* create_network(int max_size, int dropout, int initialisation, int input
network->initialisation = initialisation;
network->size = 1;
network->input = (float****)malloc(sizeof(float***)*max_size);
network->kernel = (Kernel*)malloc(sizeof(Kernel)*(max_size-1));
network->kernel = (Kernel**)malloc(sizeof(Kernel*)*(max_size-1));
network->dim = (int**)malloc(sizeof(int*)*max_size);
for (int i=0; i < max_size; i++) {
network->dim[i] = (int*)malloc(sizeof(int)*2);
network->kernel[i] = (Kernel*)malloc(sizeof(Kernel));
}
network->dim[0][0] = input_dim;
network->dim[0][1] = input_depth;
@ -26,8 +27,7 @@ Network* create_network(int max_size, int dropout, int initialisation, int input
}
Network* create_network_lenet5(int dropout, int activation, int initialisation) {
Network* network;
network = create_network(8, dropout, initialisation, 32, 1);
Network* network = create_network(8, dropout, initialisation, 32, 1);
add_convolution(network, 6, 5, activation);
add_average_pooling(network, 2, activation);
add_convolution(network, 16, 5, activation);
@ -62,9 +62,9 @@ void add_average_pooling(Network* network, int kernel_size, int activation) {
printf("Impossible de rajouter une couche d'average pooling, le réseau est déjà plein\n");
return;
}
network->kernel[n].cnn = NULL;
network->kernel[n].nn = NULL;
network->kernel[n].activation = activation + 100*kernel_size;
network->kernel[n]->cnn = NULL;
network->kernel[n]->nn = NULL;
network->kernel[n]->activation = activation + 100*kernel_size;
create_a_cube_input_layer(network, n, network->dim[n-1][1], network->dim[n-1][0]/2);
network->size++;
}
@ -75,9 +75,9 @@ void add_average_pooling_flatten(Network* network, int kernel_size, int activati
printf("Impossible de rajouter une couche d'average pooling, le réseau est déjà plein\n");
return;
}
network->kernel[n].cnn = NULL;
network->kernel[n].nn = NULL;
network->kernel[n].activation = activation + 100*kernel_size;
network->kernel[n]->cnn = NULL;
network->kernel[n]->nn = NULL;
network->kernel[n]->activation = activation + 100*kernel_size;
int dim = (network->dim[n-1][0]*network->dim[n-1][0]*network->dim[n-1][1])/(kernel_size*kernel_size);
create_a_line_input_layer(network, n, dim);
network->size++;
@ -91,43 +91,43 @@ void add_convolution(Network* network, int nb_filter, int kernel_size, int activ
}
int r = network->dim[n-1][1];
int c = nb_filter;
network->kernel[n].nn = NULL;
network->kernel[n].cnn = (Kernel_cnn*)malloc(sizeof(Kernel_cnn));
network->kernel[n].activation = activation;
network->kernel[n].cnn->k_size = kernel_size;
network->kernel[n].cnn->rows = r;
network->kernel[n].cnn->columns = c;
network->kernel[n].cnn->w = (float****)malloc(sizeof(float***)*r);
network->kernel[n].cnn->d_w = (float****)malloc(sizeof(float***)*r);
network->kernel[n]->nn = NULL;
network->kernel[n]->cnn = (Kernel_cnn*)malloc(sizeof(Kernel_cnn));
network->kernel[n]->activation = activation;
network->kernel[n]->cnn->k_size = kernel_size;
network->kernel[n]->cnn->rows = r;
network->kernel[n]->cnn->columns = c;
network->kernel[n]->cnn->w = (float****)malloc(sizeof(float***)*r);
network->kernel[n]->cnn->d_w = (float****)malloc(sizeof(float***)*r);
for (int i=0; i < r; i++) {
network->kernel[n].cnn->w[i] = (float***)malloc(sizeof(float**)*c);
network->kernel[n].cnn->d_w[i] = (float***)malloc(sizeof(float**)*c);
network->kernel[n]->cnn->w[i] = (float***)malloc(sizeof(float**)*c);
network->kernel[n]->cnn->d_w[i] = (float***)malloc(sizeof(float**)*c);
for (int j=0; j < c; j++) {
network->kernel[n].cnn->w[i][j] = (float**)malloc(sizeof(float*)*kernel_size);
network->kernel[n].cnn->d_w[i][j] = (float**)malloc(sizeof(float*)*kernel_size);
network->kernel[n]->cnn->w[i][j] = (float**)malloc(sizeof(float*)*kernel_size);
network->kernel[n]->cnn->d_w[i][j] = (float**)malloc(sizeof(float*)*kernel_size);
for (int k=0; k < kernel_size; k++) {
network->kernel[n].cnn->w[i][j][k] = (float*)malloc(sizeof(float)*kernel_size);
network->kernel[n].cnn->d_w[i][j][k] = (float*)malloc(sizeof(float)*kernel_size);
network->kernel[n]->cnn->w[i][j][k] = (float*)malloc(sizeof(float)*kernel_size);
network->kernel[n]->cnn->d_w[i][j][k] = (float*)malloc(sizeof(float)*kernel_size);
}
}
}
network->kernel[n].cnn->bias = (float***)malloc(sizeof(float**)*c);
network->kernel[n].cnn->d_bias = (float***)malloc(sizeof(float**)*c);
network->kernel[n]->cnn->bias = (float***)malloc(sizeof(float**)*c);
network->kernel[n]->cnn->d_bias = (float***)malloc(sizeof(float**)*c);
for (int i=0; i < c; i++) {
network->kernel[n].cnn->bias[i] = (float**)malloc(sizeof(float*)*kernel_size);
network->kernel[n].cnn->d_bias[i] = (float**)malloc(sizeof(float*)*kernel_size);
network->kernel[n]->cnn->bias[i] = (float**)malloc(sizeof(float*)*kernel_size);
network->kernel[n]->cnn->d_bias[i] = (float**)malloc(sizeof(float*)*kernel_size);
for (int j=0; j < kernel_size; j++) {
network->kernel[n].cnn->bias[i][j] = (float*)malloc(sizeof(float)*kernel_size);
network->kernel[n].cnn->d_bias[i][j] = (float*)malloc(sizeof(float)*kernel_size);
network->kernel[n]->cnn->bias[i][j] = (float*)malloc(sizeof(float)*kernel_size);
network->kernel[n]->cnn->d_bias[i][j] = (float*)malloc(sizeof(float)*kernel_size);
}
}
create_a_cube_input_layer(network, n, c, network->dim[n-1][0] - 2*(kernel_size/2));
int n_int = network->dim[n-1][0]*network->dim[n-1][0]*network->dim[n-1][1];
int n_out = network->dim[n][0]*network->dim[n][0]*network->dim[n][1];
initialisation_3d_matrix(network->initialisation, network->kernel[n].cnn->bias, c, kernel_size, kernel_size, n_int+n_out);
initialisation_3d_matrix(ZERO, network->kernel[n].cnn->d_bias, c, kernel_size, kernel_size, n_int+n_out);
initialisation_4d_matrix(network->initialisation, network->kernel[n].cnn->w, r, c, kernel_size, kernel_size, n_int+n_out);
initialisation_4d_matrix(ZERO, network->kernel[n].cnn->d_w, r, c, kernel_size, kernel_size, n_int+n_out);
initialisation_3d_matrix(network->initialisation, network->kernel[n]->cnn->bias, c, kernel_size, kernel_size, n_int+n_out);
initialisation_3d_matrix(ZERO, network->kernel[n]->cnn->d_bias, c, kernel_size, kernel_size, n_int+n_out);
initialisation_4d_matrix(network->initialisation, network->kernel[n]->cnn->w, r, c, kernel_size, kernel_size, n_int+n_out);
initialisation_4d_matrix(ZERO, network->kernel[n]->cnn->d_w, r, c, kernel_size, kernel_size, n_int+n_out);
network->size++;
}
@ -137,23 +137,23 @@ void add_dense(Network* network, int input_units, int output_units, int activati
printf("Impossible de rajouter une couche dense, le réseau est déjà plein\n");
return;
}
network->kernel[n].cnn = NULL;
network->kernel[n].nn = (Kernel_nn*)malloc(sizeof(Kernel_nn));
network->kernel[n].activation = activation;
network->kernel[n].nn->input_units = input_units;
network->kernel[n].nn->output_units = output_units;
network->kernel[n].nn->bias = (float*)malloc(sizeof(float)*output_units);
network->kernel[n].nn->d_bias = (float*)malloc(sizeof(float)*output_units);
network->kernel[n].nn->weights = (float**)malloc(sizeof(float*)*input_units);
network->kernel[n].nn->d_weights = (float**)malloc(sizeof(float*)*input_units);
network->kernel[n]->cnn = NULL;
network->kernel[n]->nn = (Kernel_nn*)malloc(sizeof(Kernel_nn));
network->kernel[n]->activation = activation;
network->kernel[n]->nn->input_units = input_units;
network->kernel[n]->nn->output_units = output_units;
network->kernel[n]->nn->bias = (float*)malloc(sizeof(float)*output_units);
network->kernel[n]->nn->d_bias = (float*)malloc(sizeof(float)*output_units);
network->kernel[n]->nn->weights = (float**)malloc(sizeof(float*)*input_units);
network->kernel[n]->nn->d_weights = (float**)malloc(sizeof(float*)*input_units);
for (int i=0; i < input_units; i++) {
network->kernel[n].nn->weights[i] = (float*)malloc(sizeof(float)*output_units);
network->kernel[n].nn->d_weights[i] = (float*)malloc(sizeof(float)*output_units);
network->kernel[n]->nn->weights[i] = (float*)malloc(sizeof(float)*output_units);
network->kernel[n]->nn->d_weights[i] = (float*)malloc(sizeof(float)*output_units);
}
initialisation_1d_matrix(network->initialisation, network->kernel[n].nn->bias, output_units, output_units+input_units);
initialisation_1d_matrix(ZERO, network->kernel[n].nn->d_bias, output_units, output_units+input_units);
initialisation_2d_matrix(network->initialisation, network->kernel[n].nn->weights, input_units, output_units, output_units+input_units);
initialisation_2d_matrix(ZERO, network->kernel[n].nn->d_weights, input_units, output_units, output_units+input_units);
initialisation_1d_matrix(network->initialisation, network->kernel[n]->nn->bias, output_units, output_units+input_units);
initialisation_1d_matrix(ZERO, network->kernel[n]->nn->d_bias, output_units, output_units+input_units);
initialisation_2d_matrix(network->initialisation, network->kernel[n]->nn->weights, input_units, output_units, output_units+input_units);
initialisation_2d_matrix(ZERO, network->kernel[n]->nn->d_weights, input_units, output_units, output_units+input_units);
create_a_line_input_layer(network, n, output_units);
network->size++;
}

2
src/mnist_cnn/struct.h
View File

@ -37,7 +37,7 @@ typedef struct Network{
int max_size; // Taille maximale du réseau après initialisation
int size; // Taille actuelle du réseau
int** dim; // Contient les dimensions de l'input (width*depth)
Kernel* kernel;
Kernel** kernel;
float**** input;
} Network;