File size: 10,188 Bytes
00e6582
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
#include "cnn.h"

Matrix* create_matrix(int r, int c) {
    Matrix *m = (Matrix*)malloc(sizeof(Matrix));
    m->rows = r;
    m->cols = c;
    m->data = (double**)malloc(r * sizeof(double*));
    for(int i = 0; i < r; i++) {
        m->data[i] = (double*)calloc(c, sizeof(double));
    }
    return m;
}

void free_matrix(Matrix *m) {
    for(int i = 0; i < m->rows; i++) free(m->data[i]);
    free(m->data);
    free(m);
}

double random_normal() {
    // Basic Box-Muller transform for Gaussian initialization
    double u1 = (double)rand() / RAND_MAX;
    double u2 = (double)rand() / RAND_MAX;
    return sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2) * 0.1;
}

// --- Layer Initialization ---

ConvLayer* init_conv_layer(int num_filters, int in_r, int in_cols) {
    ConvLayer *layer = (ConvLayer*)malloc(sizeof(ConvLayer));
    layer->num_filters = num_filters;
    layer->kernel_size = 3; // Fixed 3x3 for simplicity
    layer->input_rows = in_r;
    layer->input_cols = in_cols;

    layer->kernels = (double***)malloc(num_filters * sizeof(double**));
    layer->biases = (double*)malloc(num_filters * sizeof(double));
    layer->outputs = (Matrix*)malloc(num_filters * sizeof(Matrix));

    int out_r = in_r - 2; // No padding
    int out_c = in_cols - 2;

    for(int f = 0; f < num_filters; f++) {
        layer->biases[f] = random_normal();
        layer->kernels[f] = (double**)malloc(3 * sizeof(double*));
        for(int i = 0; i < 3; i++) {
            layer->kernels[f][i] = (double*)malloc(3 * sizeof(double));
            for(int j = 0; j < 3; j++) layer->kernels[f][i][j] = random_normal();
        }
        layer->outputs[f] = *create_matrix(out_r, out_c);
    }

    printf("There are %d Kernels.\n", num_filters);
    printf("There are %d Outputs.\n", num_filters);

    return layer;
}

DenseLayer* init_dense_layer(int input_size, int output_size) {
    DenseLayer *layer = (DenseLayer*)malloc(sizeof(DenseLayer));
    layer->input_size = input_size;
    layer->output_size = output_size;
    layer->outputs = (double*)calloc(output_size, sizeof(double));
    layer->biases = (double*)calloc(output_size, sizeof(double));

    layer->weights = (double**)malloc(output_size * sizeof(double*));
    for(int i = 0; i < output_size; i++) {
        layer->weights[i] = (double*)malloc(input_size * sizeof(double));
        layer->biases[i] = random_normal();
        for(int j = 0; j < input_size; j++) {
            layer->weights[i][j] = random_normal();
        }
    }
    return layer;
}

// --- Forward Pass ---

void conv_forward(Matrix *input, ConvLayer *layer) {
    int out_r = layer->input_rows - 2;
    int out_c = layer->input_cols - 2;

    for(int f = 0; f < layer->num_filters; f++) {
        for(int i = 0; i < out_r; i++) {
            for(int j = 0; j < out_c; j++) {
                double sum = layer->biases[f];
                // 3x3 Convolution
                for(int ki = 0; ki < 3; ki++) {
                    for(int kj = 0; kj < 3; kj++) {
                        sum += input->data[i + ki][j + kj] * layer->kernels[f][ki][kj];
                    }
                }
                // ReLU Activation
                layer->outputs[f].data[i][j] = (sum > 0) ? sum : 0;
            }
        }
    }
}

void dense_forward(double *flattened_input, DenseLayer *layer) {
    for(int i = 0; i < layer->output_size; i++) {
        double sum = layer->biases[i];
        for(int j = 0; j < layer->input_size; j++) {
            sum += flattened_input[j] * layer->weights[i][j];
        }
        layer->outputs[i] = sum;
    }

    // Softmax Activation
    double max = layer->outputs[0];
    for(int i = 1; i < layer->output_size; i++) if(layer->outputs[i] > max) max = layer->outputs[i];

    double sum_exp = 0.0;
    for(int i = 0; i < layer->output_size; i++) {
        layer->outputs[i] = exp(layer->outputs[i] - max); // Stability trick
        sum_exp += layer->outputs[i];
    }
    for(int i = 0; i < layer->output_size; i++) layer->outputs[i] /= sum_exp;
}

// --- Backpropagation & Training ---

void train_step(Matrix *input, ConvLayer **conv_depth, int depth, DenseLayer *dense, int target_class, double lr) {
    // 1. Forward Pass through customizable Conv Depth
    Matrix *current_in = input;
    for(int d = 0; d < depth; d++) {
        conv_forward(current_in, conv_depth[d]);
        // For multi-layer conv, we just pass the first filter map forward for simplicity
        // Real-world multi-channel convs track depth channels, but this keeps the pure C math readable.
        current_in = &conv_depth[d]->outputs[0];
    }

    // Flatten last conv layer outputs into 1D array
    ConvLayer *last_conv = conv_depth[depth - 1];
    int flatten_size = last_conv->num_filters * last_conv->outputs[0].rows * last_conv->outputs[0].cols;
    double *flattened = (double*)malloc(flatten_size * sizeof(double));

    int idx = 0;
    for(int f = 0; f < last_conv->num_filters; f++) {
        for(int i = 0; i < last_conv->outputs[f].rows; i++) {
            for(int j = 0; j < last_conv->outputs[f].cols; j++) {
                flattened[idx++] = last_conv->outputs[f].data[i][j];
            }
        }
    }

    // Forward Dense
    dense_forward(flattened, dense);

    // 2. Backward Pass (Calculate Gradients)
    double *dC_dz = (double*)malloc(dense->output_size * sizeof(double));
    for(int i = 0; i < dense->output_size; i++) {
        dC_dz[i] = dense->outputs[i];
    }
    dC_dz[target_class] -= 1.0; // Derivative of Softmax + Cross-Entropy Loss

    // Gradient for Dense Weights & Biases + Flattened error
    double *dC_dflat = (double*)calloc(flatten_size, sizeof(double));
    for(int i = 0; i < dense->output_size; i++) {
        for(int j = 0; j < dense->input_size; j++) {
            dC_dflat[j] += dC_dz[i] * dense->weights[i][j];
            // Update Dense Weight
            dense->weights[i][j] -= lr * dC_dz[i] * flattened[j];
        }
        dense->biases[i] -= lr * dC_dz[i];
    }

    // Backprop through Conv Layers (Backwards loop)
    idx = 0;
    for(int f = 0; f < last_conv->num_filters; f++) {
        for(int i = 0; i < last_conv->outputs[f].rows; i++) {
            for(int j = 0; j < last_conv->outputs[f].cols; j++) {
                double val = last_conv->outputs[f].data[i][j];
                // ReLU derivative
                double dC_da = (val > 0) ? dC_dflat[idx] : 0;
                idx++;

                // Update Conv Weights (Kernels) based on input to this specific layer
                Matrix *prev_input = (depth == 1) ? input : &conv_depth[depth - 2]->outputs[0];
                for(int ki = 0; ki < 3; ki++) {
                    for(int kj = 0; kj < 3; kj++) {
                        last_conv->kernels[f][ki][kj] -= lr * dC_da * prev_input->data[i + ki][j + kj];
                    }
                }
                last_conv->biases[f] -= lr * dC_da;
            }
        }
    }

    // Memory Cleanup
    free(flattened);
    free(dC_dz);
    free(dC_dflat);
}

// --- Main Execution Block ---

int CreateCNN() {
    srand(42); // Seed for reproducible sanity checks

    // --- Dynamic Parameters (Adjust these to change size/depth) ---
    int input_rows = 14;      // Adjust Input Size (e.g., 14x14 mini-images)
    int input_cols = 14;
    int hidden_depth = 2;     // Adjust Hidden Conv Depth
    int num_filters = 4;      // Filters per conv layer
    int num_classes = 3;      // Classification targets (e.g., Circle, Square, Triangle)
    double learning_rate = 0.01;

    printf("Initializing CNN: Input %dx%d | Depth: %d layers | Classes: %d\n", input_rows, input_cols, hidden_depth, num_classes);

    // Dynamic Allocation of Conv Hidden Depth
    ConvLayer **conv_layers = (ConvLayer**)malloc(hidden_depth * sizeof(ConvLayer*));
    int current_r = input_rows;
    int current_c = input_cols;

    for(int i = 0; i < hidden_depth; i++) {
        conv_layers[i] = init_conv_layer(num_filters, current_r, current_c);
        current_r -= 2; // Update dimension shrink due to valid convolution
        current_c -= 2;
    }

    if (current_r <= 0 || current_c <= 0) {
        printf("Error: Hidden depth is too deep for the chosen input size. Feature maps shrank to zero!\n");
        return -1;
    }

    // Initialize Dense Output Layer
    int flatten_size = num_filters * current_r * current_c;
    DenseLayer *dense = init_dense_layer(flatten_size, num_classes);

    // Create a dummy training sample (Mock 14x14 image)
    Matrix *sample_input = create_matrix(input_rows, input_cols);
    for(int i = 0; i < input_rows; i++) {
        for(int j = 0; j < input_cols; j++) {
            sample_input->data[i][j] = (double)rand() / RAND_MAX; // Random pixel values
        }
    }
    int target_label = 1; // We want the network to learn to classify this sample as Class '1'

    printf("\n--- CNN Weight Audit ---\n");
for (int d = 0; d < hidden_depth; d++) {
    int weights_per_filter = conv_layers[d]->kernel_size * conv_layers[d]->kernel_size;
    int total_conv_weights = conv_layers[d]->num_filters * weights_per_filter;

    printf("Conv Layer %d -> %d Filters of size [%d x %d] = %d weights | Biases: [%d]\n",
           d + 1, conv_layers[d]->num_filters, conv_layers[d]->kernel_size,
           conv_layers[d]->kernel_size, total_conv_weights, conv_layers[d]->num_filters);
}
printf("Dense Output Layer -> Weights Matrix: [%d x %d] (%d parameters)\n",
       dense->output_size, dense->input_size, dense->output_size * dense->input_size);

    // --- Training Loop ---
    printf("\nStarting Training Optimization...\n");
    for(int epoch = 1; epoch <= 50; epoch++) {
        train_step(sample_input, conv_layers, hidden_depth, dense, target_label, learning_rate);

        if (epoch % 10 == 0) {
            printf("Epoch %02d -> Predicted Probability for Class %d: %.4f\n",
                   epoch, target_label, dense->outputs[target_label]);
        }
    }

    printf("\nOptimization complete. Network successfully adjusted weights!\n");

    // Clean up allocated memory
    free_matrix(sample_input);
    // (In production code, deep loop-free allocations would go here to avoid memory leaks)
    return 0;
}