Automated Detection of Knee Osteoarthritis Using CNN with Adaptive Moment Estimation

This study is dedicated to the task of classifying the severity of osteoarthritis through a detailed analysis of knee X-ray images. Osteoarthritis, a degenerative joint disease, can lead to significant pain and mobility issues, and accurately determining its severity is crucial for effective treatment planning. Image classification plays a vital role in this process, as it involves the sorting and categorization of images based on specific characteristics that define various degrees of osteoarthritis severity [10]. These characteristics can include factors such as joint space narrowing, bone spurs, and other radiographic indicators evident in the X-rays. To create a highly accurate classification model for the digital images, it is essential to utilize an effective algorithm capable of processing the intricate details present in the X-ray images [11].

In this research, we implemented both traditional image classification architectures, which have been widely used in past studies, and modern deep learning architectures, which offer advanced capabilities in feature extraction and pattern recognition. To enhance the performance of these models, we applied the Adam Optimizer, known for its efficiency and effectiveness in training neural networks [12, 13]. By leveraging both conventional and state-of-the-art approaches, this study aims to improve the accuracy and reliability of knee X-ray image classifications. Ultimately, this research not only seeks to provide clearer insights into the severity of osteoarthritis but also to contribute to better patient outcomes through more informed clinical decision-making.

2.1 CNN

A CNN is an essential architecture in deep learning, specifically engineered for the recognition and analysis of patterns in structured data, particularly images. CNNs are highly adept at automatically learning spatial hierarchies of features, which makes them exceptionally effective for image classification and object detection. The evolution of CNN architectures has been significant, leading to the development of groundbreaking variants that enhance both performance and efficiency. These advancements have driven major breakthroughs in deep learning, resulting in precise applications across critical fields like computer vision, healthcare, and autonomous systems. With each new variant, CNNs continue to push the limits of what artificial intelligence can achieve [14, 15]. The CNN-modeling has following two parts, feature learning and classification.

2.1.1 Feature learning

Feature learning empowers machines to automatically discover and harness the unique characteristics of input images, transforming raw data into insightful knowledge [16]. In CNN, the features are extracted through two components: convolution layer and pooling layer.

Convolution layer

The convolution layer serves as a powerful tool for feature extraction. By applying the convolution function followed by an activation function, it unlocks the potential of data. With multiple convolution layers, we harness deeper insights and elevate the art of feature extraction [17]. In the convolution operation, a fundamental technique used in signal processing and image analysis, we employ a linear function known as the kernel function to effectively extract features from the input data. This kernel function, which can also be referred to as the filter, acts as a sliding window, moving across the input data to identify important patterns and structures. By applying the kernel to various regions of the data, we generate a new representation that highlights specific features, such as edges or textures, which are crucial for further analysis and interpretation. This process is essential in computer vision, where it helps in tasks like object detection and image classification. Suppose we have an input image described by tensor I of dimension $m_1 * m_2 * m_c$, where,

$m_1=$ height of image

$m_2=$ width of image

$m_c=$ number of channels

We apply a filter which is also a tensor of dimension ($n_1 * n_2 * n_c$). The kernel is designed to have the same number of channels as the input image. As the filter traverses the image from left to right, it performs a multiplication operation between the corresponding sections of the image (I) and the kernel (K), summing the resulting products. The stride parameter specifies the increment by which the filter shifts as it scans the image. The resultant of I and K is another tensor of dimension $\left(m_1-n_1+1\right) *\left(m_2-n_2+1\right) * 1$.

$\begin{aligned} & \operatorname{dim} \text { of } I=m_1 * m_2 * m_c \\ & \operatorname{dim} \text { of } K=n_1 * n_2 * n_c \\ & \operatorname{dim} \text { of } F=\left(m_1-n_1+1\right) *\left(m_2-n_2+1\right) * 1\end{aligned}$

And,

$F[i, j]=(I * K)_{[i, j]}$

The ij-th entry of the feature map is given as below:

$f[i, j]=\sum_x^{m_1} \sum_y^{m_2} \sum_z^{m_c} K_{[x, y, z]} I_{[i+x-1, j+y-1, z]}$

We have taken the following example of a 5×5×1 dimensional image being convoluted with a kernel of 3×3×1 and the stride s=1 has been used (Figure 1).

1.png

Figure 1. Feature extraction in convolution operation

The ij-th entry of feature map is given by following general formula in case of single channel:

$f[i, j]=(I * K)_{[i, j]}=\sum_x^{m_1} \sum_y^{m_2} K_{[x, y]} I_{[i-x, j-y]}$

The remaining entries can be derived utilizing the specified formula. This process is repeated by applying a variety of filters that extract distinct features from the image, such as blur and sharpness. It is important to note that multiple filters may be employed concurrently, which illustrates the concept of stride.

Padding

The procedure outlined previously has a significant limitation: the filters applied during processing tend to concentrate their effects more on the central areas of the image rather than on the corners. This uneven distribution of attention can lead to incomplete or distorted representations of the entire image, particularly affecting the areas that are not at the center. To address this issue, padding can be utilized. Padding is a technique that involves adding extra pixels around the edges of the input tensor before processing it with filters. Zero padding, in particular, is a widely used method in which a row and a column of zeros are added to each side—top, bottom, left, and right—of the input tensor. This approach not only helps maintain the dimensionality of the output but also ensures that the filters can adequately analyze and capture features located near the corners of the image, thereby improving overall image quality and feature detection.

Activation function

Typically, a bias term denoted as b is incorporated into the convolutional component prior to the application of the activation function.

$\begin{aligned} & c=F+b \\ & c=I * K+b \\ & \operatorname{Conv}(I, K)=\phi_a(c)=\phi_a(I * K+b)\end{aligned}$

where, $\phi_a$ is an activation function.

There are a variety of activation functions utilized in neural networks, including sigmoid, tangent, and hyperbolic tangent functions. Among these, the Rectified Linear Unit (ReLU) activation function is the most prevalent due to its efficiency in eliminating negative values:

$R(x)=\max (0, x)$

Pooling layer

In the pooling layer, the spatial dimensions of the features obtained from the convolution layer are intentionally reduced. This reduction process emphasizes the most prominent features of the image, allowing for a more efficient analysis. The pooling function is applied to the output produced by the convolution layer to facilitate this transformation.

Let us assume that:

$\begin{aligned} & \operatorname{Conv}(\boldsymbol{I}, \boldsymbol{K})=C \\ & P=\phi_p(C)\end{aligned}$

where, $\phi_p$ is a pooling function.

The dimension of pooled part is given as:

$\operatorname{dim} o f P=\left(\frac{m_1+2 p-n_1}{s}\right) *\left(\frac{m_2+2 p-n_2}{s}\right) * m_c$

where,

$\begin{aligned} & m_1 * m_2={ the \,dimension\, of \,input\, image, } \\ & n_1 * n_2={ the\, dimension\, of\, padding\, kernel, } \\ & s={ stride\, and\, p } ={ padding } .\end{aligned}$

There are several types of pooling methods utilized in deep learning, including sum pooling, average pooling, and max pooling. An illustration of max pooling is provided below. In this approach, max pooling is performed on 2×2 patches, selecting the maximum value from each patch.

2.1.2 Classification

To effectively extract features from the input data, multiple hidden layers are employed, specifically a combination of convolutional layers and pooling layers. These layers work together to identify and isolate important patterns and characteristics within the data. Upon the completion of the feature extraction process, the resulting multidimensional data is systematically transformed into a single one-dimensional vector through a process known as flattening. The optimized vector is utilized as the input for the fully connected layer, which is responsible for executing the final classification of the data based on the features that have been extracted [18, 19].

Fully connected layer

The fully connected layer plays a crucial role in processing the flattened vector, which is the output of the previous layer in a neural network. This layer transforms the input into another vector, allowing the model to learn complex relationships and representations within the data. In machine learning, it's common for different classes to be represented unevenly; some may occur more frequently than others, leading to potential bias in the model's predictions. To mitigate this imbalance, balanced weights are introduced in conjunction with the pooled data, ensuring that all classes are fairly represented. Furthermore, a bias term is added to stabilize the learning process, and this is followed by the application of an activation function, which introduces non-linearity and helps the model better fit the underlying patterns in the data.

The mathematical description is as below:

$\begin{aligned} & X=\sum_i w_i P_i+b \\ & z=g(X)\end{aligned}$

where, g is an activation function for the fully connected layer.

In this approach, each layer incorporates the weights associated with the pooled segments, enhancing the data representation. After the weights are applied, the activation function is activated, introducing non-linearity into the model. Several hidden layers are employed, allowing for complex feature extraction and transformation. In the final layer, a specific activation function is utilized to carry out the classification task, calculating the probabilities for each class and determining the most likely category for the input data [20].

2.2 Optimizer

The Adam algorithm represents a significant advancement in the field of optimization techniques. It was introduced by Sadu et al. [21]. This algorithm functions as a robust tool for stochastic optimization, recognized for its effectiveness in identifying optimal solutions even in the presence of randomness. One of the standout features of Adam is its requirement for only first-order gradients, making it remarkably efficient in terms of computational resources while utilizing minimal memory [21]. To grasp the concept of stochastic optimization more clearly, it's helpful to compare it to the well-known Stochastic Gradient Descent (SGD) method. SGD is highly effective for tasks that involve large datasets and a multitude of parameters. At each iteration, this method estimates the gradient by drawing a random subset of the data, known as a mini-batch. This approach allows SGD to converge toward optimal solutions more quickly compared to traditional Gradient Descent, which relies on evaluating the gradient using the entire dataset at every step. Consequently, SGD can handle large volumes of data efficiently, making it a popular choice in various machine-learning applications [22, 23].

The algorithm to optimize an objective function $f(\theta)$, with parameters $\theta$ (weights and biases).

Adam should incorporate the relevant hyperparameters: $\alpha$, $\beta 1$ (from Momentum), $\beta 2$ (from RMSProp).

Initialize:

$m=0$, this document presents the first moment vector, which is examined within the framework of momentum.

$v=0$, this represents the second moment vector, approached in a manner analogous to the RMSProp technique.

$t=0$

On iteration $t$:

Update $t, t=t+1$

Calculate the gradients or derivatives $(g)$ in relation to $t$. In this context, $g$ is equivalent to $d w$ and $d b$, respectively

$g_t=\operatorname{grad}\left(\theta_{t-1}\right)$

Update the first moment $m_t$

Update the second moment $v_t$

$\begin{aligned} & m_t=\beta_1 * m_{t-1}+\left(1-\beta_1\right) * g_t \\ & v_t=\beta_2 * v_{t-1}+\left(1-\beta_2\right) * g_t^2\end{aligned}$

Calculate the bias-corrected value $m_t$ (Implementing bias correction enhances the accuracy of estimates for moving averages).

Compute the bias-corrected $v_t$

$\begin{aligned} & \widehat{m}_t=\frac{m_t}{\left(1-\beta_1^2\right)} \\ & \hat{v}_t=\frac{v_t}{\left(1-\beta_2^2\right)}\end{aligned}$

Update the parameters $\theta$

$\theta_t=\theta_{t-1}-\alpha * \frac{\widehat{m}_t}{\sqrt{\hat{v}_t+\epsilon}}$

The loop will continue to execute until Adam successfully arrives at a solution.

Adam is widely recognized as one of the leading optimization algorithms in the field of machine learning, although it does have some limitations. Below are some of the key advantages and disadvantages associated with the Adam optimizer handling Sparse Gradients. Adam excels in managing sparse gradients, which often occur in noisy datasets. This makes it particularly effective for problems where data can be irregular or inconsistent. Robust Default Hyperparameters, one of the standout features of Adam is its default hyperparameter values, which tend to yield good results for a variety of machine learning tasks without the need for extensive tuning.

Computational Efficiency, algorithm 1 is designed to be computationally efficient, making it suitable for training models quickly, even on complex tasks. For adaptive methods, we assume:

Adam: $\beta_1, \beta_2 \in[0,1)$ with $\beta_1<\sqrt{\beta_2}$

Memory efficiency, Adam utilizes memory effectively, requiring only a small footprint. This makes it an excellent option for environments with limited memory resources [24-26]. Performance on large datasets, the optimizer performs exceptionally well when applied to large datasets, enabling faster training times and the ability to work with more complex models. These characteristics make Adam a popular choice among practitioners looking for an effective optimization method in their machine learning projects.

The knee OA dataset comprises five distinct labels and is intended for multi-class classification within this study. A confusion matrix is generated through the classification process, which employs various architectural models. In a multi-class confusion matrix, the classification results are organized such that each element's predicted class (denoted by columns) is compared with its actual class (denoted by rows). Correctly classified elements are reflected on the diagonal, where the predicted class aligns with the true class, while non-diagonal elements represent the instances of misclassification. A greater count in the diagonal entries indicates superior performance of the classifier. Notably, the EfficientNetV2 CNN architecture demonstrated the highest number of correctly classified elements when compared to other conventional CNN architectures.

4.1 Convergency classification model

Overfitting is a significant issue encountered in model training, where excessive specialization of the training data adversely affects the model's capacity to generalize to new, unseen data. This phenomenon results in an escalation of generalization error, which can be accurately assessed through the model's performance on a validation data set. In this study, the utilization of the Adam optimizer is intended to facilitate the development of the most effective classifier model.

Figure 5 illustrates that both the training loss and validation loss demonstrate a consistent downward trend, subsequently stabilizing at a designated point. This observation indicates that the AlexNet architecture is a suitable fit for the data being analyzed.

5.png

Figure 5. Loss training and validation AlexNet

6.png

Figure 6. Loss training and validation ResNext50

In contrast to AlexNet, the training and validation loss metrics for ResNet50 (Figure 6) generally indicate that the model is experiencing overfitting and is unable to generalize effectively to new data. Specifically, the model demonstrates strong performance on the training dataset, while exhibiting weak performance on the validation set. Notably, there exists a point at which the validation loss decreases, only to subsequently increase once more.

Figure 7 illustrates the training loss and validation loss associated with each convolutional neural network (CNN) architecture utilized in this study. The graph reveals that an effective model is characterized by both the training and validation losses exhibiting a decline until they reach a stable point, with a minimal disparity between their final values.

7.png

Figure 7. Loss training and validation MobileNet v2

Training loss and validation loss are critical metrics utilized to evaluate a model's performance and its capacity for generalization. Training loss represents the error associated with the data on which the model was trained. In contrast, validation loss assesses the error on previously unseen data, providing insights into the model's performance beyond the training dataset. By analyzing both metrics, one can gain a comprehensive understanding of the model's effectiveness.

Figures 7 and 8 illustrate that the graphs for MobileNet and ShuffleNet exhibit notable similarities, which suggest an optimal fit for both models. This indicates that neither model is experiencing overfitting nor underfitting.

8.png

Figure 8. Loss training and validation ShuffleNet v2

It is essential to acknowledge that the model loss consistently demonstrates lower values on the training dataset compared to the validation dataset. Consequently, some degree of separation between the learning curves of the training and validation losses is to be anticipated; this difference is commonly referred to as the "generalization gap."

9.png

Figure 9. Loss training and validation EfficientNet v2

In Figure 9, EfficientNet v2 exhibits a considerable degree of fitness, which suggests that it achieves an optimal fit—indicating that the model neither overfits nor underfits the data. Among the five CNN classifier architectures evaluated, EfficientNet demonstrates superior performance. A learning curve is deemed to reflect a successful match if: - The training loss continually decreases and subsequently stabilizes. - The validation loss similarly decreases, stabilizes, and maintains a minor gap relative to the training loss. Among the five architectures examined, EfficientNet demonstrates the most advantageous performance in comparison to the others.

4.2 Classification performance matric

CNN classifiers depend on the utilization of metrics to assess and evaluate model performance. These metrics serve as an objective means to determine the effectiveness with which a model learns patterns from the training dataset and applies them to previously unobserved data, such as validation and testing datasets. Furthermore, metrics are instrumental in facilitating the comparison of performance across various models or methodologies, thereby aiding in the selection of the model that best meets the specified requirements and objectives.

Table 1 indicates that the highest values across all metrics are observed in non-traditional architectures, specifically ShuffleNet and EfficientNet, both of which attained a score of 95% for each metric evaluated.

10.png

Figure 10. Models’ performance metrics

The findings of this study are comprehensively illustrated in Figure 10, where we analyze five key performance metrics: accuracy, precision, recall, and F1-score. These metrics are crucial for assessing the effectiveness of the models in classification tasks. In our evaluation, we examined five distinct CNN architectures, each designed with unique features and training strategies. Among these, ShuffleNet and EfficientNet emerged as the top performers, consistently attaining the highest scores across all metrics evaluated.

The high accuracy of these architectures indicates their ability to correctly classify a significant proportion of the data. Moreover, their impressive precision reflects a low rate of false positives, showcasing their reliability in making positive identifications. The strong recall scores suggest that both models are highly effective at identifying true positive cases, minimizing false negatives. Lastly, the balanced F1-scores display an overall robust performance, highlighting their suitability for tasks requiring both high precision and recall. Overall, the results suggest that ShuffleNet and EfficientNet are not only efficient in their computational designs but also excel in practical applications where performance metrics are critical for success.

From the results of the experiments that have been carried out and referring to the performance metrics, the performance of the ShuffleNet architecture can be described as follows. ShuffleNet is characterized by a sophisticated architecture that utilizes pointwise group convolutions and channel shuffle operations to enhance efficiency while maintaining accuracy. This advanced design results in fewer parameters and lower computational complexity compared to traditional neural network architectures. With a computational cost of 10 to 150 MFLOPs, ShuffleNet achieves approximately a 13-fold speedup without compromising accuracy. Furthermore, it exhibits improved performance metrics in classification tasks while necessitating significantly fewer resources. These attributes make ShuffleNet particularly suitable for deployment in environments with constrained resources.

The recall score is an important metric that indicates the number of correct predictions made by the model relative to the total number of data points positively diagnosed with the disease. As illustrated in Figure 11, the ShuffleNet CNN architecture demonstrates the highest recall score among the evaluated models. This indicates that it exhibits superior performance in prediction tasks. The significance of the precision score in relation to the recall score is contingent upon the specific application at hand. For instance, within the context of a medical diagnosis system, achieving high recall is often paramount. This approach prioritizes the identification of as many positive cases of diseases as possible, even if it results in some false positives, which may lead to unnecessary testing.

11.png

Figure 11. Recall score for ShuffleNet and EfficientNet

The results of this study are visually represented in Figure 10, which emphasizes the recall scores derived from the analysis of the knee OA dataset. This dataset is crucial for understanding the prevalence and characteristics of knee OA, as it encompasses a range of patient data and clinical outcomes. In examining the results, it becomes evident that both ShuffleNet and EfficientNet have emerged as the leading models, demonstrating exceptional performance with a recall score of 95%. This remarkable figure indicates that these models are highly proficient at identifying true positive cases, thereby effectively minimizing false negatives. The ability to accurately detect cases of knee OA is essential for timely diagnosis and intervention, underscoring the significance of these models in enhancing clinical decision-making and improving patient outcomes.

The implementation of CNNs in clinical workflows presents several challenges that must be addressed for successful deployment. CNNs require substantial volumes of high-quality, accurately annotated datasets for training. However, in clinical environments, the availability of such data can be quite limited. Additionally, acquiring image data poses its own difficulties, as varying patient conditions may lead to suboptimal image quality. This impact on data quality necessitates comprehensive preprocessing, which can be time-consuming and resource-intensive. Furthermore, data interoperability issues can emerge, given that different healthcare systems may utilize incompatible formats or standards. Another significant concern is algorithmic bias and the generalization of CNN models. The performance of these models can be adversely affected by biases present in the training datasets, potentially limiting their effectiveness across diverse patient populations and clinical scenarios. Therefore, ensuring that the model maintains the ability to generalize across various demographic groups is essential for its clinical applicability and utility.