Convolutional Neural Networks (CNNs) are a class of neural networks primarily used for analyzing, recognizing, and classifying images [23] . It comprises an input layer, several hidden layers, and an output layer (see Figure 1 ).

The input layer is responsible for receiving raw data, such as images, and passing it into the network.

The hidden layers include the convolutional, pooling, activation, and fully connected layers, each fulfilling a distinct role. They are the essential layers [25] , collaborating to enable CNNs to learn and identify patterns in data, making these networks highly effective for tasks like image recognition, object detection, and more.

The convolution layer detects features by applying filters (kernels) to the input data to extract local patterns like edges, textures, or shapes from images. It performs convolution operations, a mathematical process that combines two signals to produce a third one [26] . This operation measures the effect of one signal on another, influenced by the shape of the second signal. The computation is outlined below.

$\left(p\times q\right)\left[s\right]={\displaystyle {\sum }_{r=-\infty }^{\infty }p\left[r\right]q\left[s-r\right]}$ (1)

where, $p$ and $q$ are functions that can be either discrete or continuous, and $s$ is the position of the output signal. For discrete signals, the equation is adjusted to

$\left(p\times q\right)\left[s\right]={\displaystyle {\sum }_{r=-\infty }^{\infty }p\left[r\right]q\left[s-r\right]\Delta r}$ (2)

with $\Delta r$ the sampling interval. For continuous one, the equation takes the form:

$\left(p\times q\right)\left[u\right]={\displaystyle {\int }_{-\infty }^{\infty }p\left(\sigma \right)q\left(u-\sigma \right)\text{d}\sigma }$ (3)

Here, $u$ denotes the position of the output signal.

The pooling layer, placed between convolutional layers is intended to reduce the spatial dimensions (width and height) of the feature maps produced by the convolutional layer [23] . It enhances the robustness of feature extraction and decreases the risk of overfitting. Generally used pooling operations include average pooling, max pooling and global pooling [27] .

To enable the model to capture complex and non-linear patterns found in real-world scenarios, an activation layer is necessary, which performs activation functions. Common activation functions found in the literature include the Sigmoid activation function, the Hyperbolic Tangent (Tanh) activation function, and the Rectified Linear Unit (ReLU) activation function. ReLU is commonly used in hidden layers due to its simplicity and efficiency [28] . Several variations of the ReLU activation function have been proposed to enhance its performance, such as the Leaky ReLU and Parametric ReLU (PReLU) activation functions.

The normal ReLU neutralizes negative values while preserving positive values unchanged, a Leaky ReLU is variant that allows a small, non-zero gradient when the input is negative. It is computing as follow:

$\text{Leaky}\text{ReLU}\left(x\right)=\{\begin{array}{ll}x\hfill & \text{if}x>0\hfill \\ \alpha x\hfill & \text{if}x\le 0\hfill \end{array}$ (4)

where $\alpha$ is a small constant for example $\alpha =0.001$. $x$ is range from $-\infty$ to $+\infty$. PReLU is similar to Leaky ReLU but $\alpha$ a learnable slope for negatives values.

The fully connected layer, used in the final stages to generate the output, is a layer where each neuron is connected to every neuron in the previous layer [29] . it is in charge of integrating features extracted from input data by previous layers. Fully connected layers can learn non-linear combinations of input features, allowing them to capture complex relationships between these features. Once the features are effectively combined, the fully connected layer produces outputs used for classification in classification tasks or for predicting continuous values in regression tasks.

To develop an optimal architecture, we tested various configurations by adjusting the number of layers, filter sizes, stride, and activation functions. We then selected the parameter values that led to the highest accuracy. The results obtained are presented in Table 1 .

As shown in Table 1 , our proposal includes four convolutional layers, each producing an output that applies the ReLU activation function, followed by a pooling layer with a 2 × 2 filter and a stride of 2. The first convolutional layer uses 16 filters, each with a 3 × 3 pixel matrix. After this, a pooling layer with a 2 × 2 filter and a stride of 2 is applied. The second convolutional layer uses 32 filters, the third layer uses 64 filters, and the final layer uses 128 filters. Figure 2 , the convolution part, shows that the four convolutional layers are preceded by the input layer and followed by the fully connected layer.

To enhance the efficiency of feature discrimination in the convolutional phases, the fully connected section is trained using two distinct sub-networks (see Figure 3 ). The first subnetwork has 1024 neurons as input, followed by 512, 256 and 128 neurons respectively in the next three layers. The second subnetwork has 512 neurons as input, followed by 128 neurons in each of the three successive layers. Both subnetworks have an identical number of fully connected layers, and their outputs are concatenated in the fourth layer to extract the most discriminative features. This approach allows for the exploration of high-dimensional features using two distinct architectures. Each fully connected layer carries out complex computations to transform inputs into meaningful outputs, enhancing the model’s ability to learn and generalize from the training data. The final layer is a SoftMax loss layer with 128 inputs.

We optimize the weights of convolutional neural networks using the gradient descent algorithm. This iterative process fine-tunes key parameters, such as the base learning rate. We employed the cyclic learning rate method [30] , which involves varying the learning rate within a range of values over a specific number of iterations. Adadelta optimizer was applied with a learning rate ranging from 1∙e⁻⁶ to 1∙e⁻¹. As recommended by [31] , we optimize the learning rate and batch size by experimenting with different values while keeping other hyperparameters constant. The specified hyperparameter space can then be explored further through random sampling, allowing us to select the parameters that yield the best results on the validation set. Following this approach, we have listed the other hyperparameter values used in the network in Table 2 .

In this study, we used publicly available data from kaggle.com [32] , which consists of 3264 magnetic resonance imaging (MRI) images of brain tumors. The images are categorized into four classes: meningioma tumor, pituitary tumor, glioma tumor, and no tumor. Table 3 presents a detailed partitioning of the dataset.

Figure 4 (inspired from [17] ) illustrates brain magnetic resonance images categorized by the different types of tumors.

To predict brain tumors, we follow these steps. First, we collect the data. Next, we conduct a data pre-processing phase, where we apply various techniques to eliminate noise and improve data quality. The second step involves splitting the data into training and validation datasets. 80% of the images from each type of brain tumor listed in Table 2 are used for training, while the remaining images are used for validation. The third step consist of applying deep learning model based on our proposed CNN architecture with training dataset to perform brain tumor classification followed by the using of validation dataset. For comparison purpose we also user another CNN architecture like GoogLeNet, ShuffleNet, DenseNet and ResNet. For practical reasons, we decided to name our own proposed CNN architecture KKDNet. The output determines whether the input image is categorized as a meningioma tumor, pituitary tumor, glioma tumor, or no tumor. The final step of our framework involves evaluating performance by calculating accuracy, recall, AUC, and loss. Figure 5 illustrates the processing steps of the proposed framework.

Figure 6 shows the training and validation loss. We can observe that the training loss curve and validation loss curve decrease over the epochs. Figure 7 presents the training and validation curves of the accuracy over the epochs. Training curve. The curve reaches a fairly high accuracy value quickly; by epoch 15, we surpass 90% accuracy. However, it is noted that the validation curve does not achieve equivalent performance in terms of accuracy. Until epoch 25, it remains below 80%.

To evaluate our model’s performance in terms of execution time and memory consumption, we represented, in Figure 8 , the execution time in seconds of several models, including ours (KKDNet), in the form of a histogram. We observe that KKDNet achieves the best execution time compared to the other models, with an approximate time of around 500 seconds. The model closest in terms of execution time, GoogLeNet, has a time of about 700 seconds. In contrast, the model with the highest execution time reaches approximately 17,000 seconds, which is about 34 times the time required for our model (KKDNet).

The pie chart in Figure 9 represents the memory consumption of different architectures. We observe that the memory requirements for ShuffleNet, DenseNet, and GoogLeNet are lower than those of our model. In contrast, ResNet’s memory consumption is more than three times higher than that of our model.

The final representation ( Figure 10 ) is a histogram illustrating the performance of different architectures based on the accuracy metric. Our model, KKDNet, ranks among the top two, achieving performance levels comparable to ResNet, with an accuracy exceeding 90%.

Figure 6 shows the training and validation loss. We can observe that the training loss curve decreases over the epochs, indicating that the model is gradually improving during training. The validation loss curve also decreases over the epochs, which suggests that the model is not experiencing overfitting and may continue to improve if the number of epochs is increased.

In Figure 8 , the curve reaches a fairly high accuracy value quickly; by epoch 15, we surpass 90% accuracy. However, it is noted that the validation curve does not achieve equivalent performance in terms of accuracy. Until epoch 25, it remains below 80%. We can explain this situation by referring to the observation made in Figure 6 , which shows that the model continues to improve without falling into overfitting. This means that if we increase the number of epochs, the validation accuracy curve could reach performance levels close to those of the training phase, surpassing 90%.

Regarding Figure 8 , the significant gain in execution time of our model can be attributed to its architecture. Indeed, we have designed an architecture with fewer layers (a total of 4 layers). Although the number of filters used in each layer may be high, having fewer layers [33] , combined with the optimization techniques we applied (see Table 1 and Table 2 ), accounts for this considerable time gain compared to ResNet and ShuffleNet. Moreover, with an architecture having fewer layers, it is logical that the memory required is reduced (see Figure 9 ). Although other factors influence memory consumption, the number of layers is one of the most determining factors.

Finally, although our model requires less execution time and relatively less memory space, it achieves high accuracy similar to ResNet, whose execution time is ten times longer than that of our model (see Figure 10 ). Additionally, its memory consumption is three times higher than that of our model (KKDNet). We attribute these results to the optimization techniques employed and the use of a cyclic learning rate in the architecture design.