Detection of renal cell hydronephrosis in ultrasound kidney images: a study on the efficacy of deep convolutional neural networks

Data collection and preprocessing

First, ultrasound images of the kidney area to look for signs of renal cell hydronephrosis. Kaggle provided the public dataset used for this study. The images were preprocessed to get rid of noise, improve contrast, and standardize intensities. The creation of a deep convolutional neural network (DCNN) is necessary for the automation of the detection of renal cell hydronephrosis in ultrasound images of the kidneys. A Kaggle dataset was used for this study’s analysis. There are 1,057 256 × 256 pixel grayscale photos included. Preprocessing the dataset is the initial stage in converting the grayscale photos to RGB. This is essential since the dual route DCNN architecture used in this research can only process RGB images. After the data has been cleaned and processed, an 80/20 split is used to separate the dataset into a training set and a testing set. Before training the model, we supplement the data to boost its generalization capabilities and training efficiency. To be more explicit, we generate new training images by randomly rotating, zooming, flipping horizontally, and flipping vertically. Figure 2 shows the percentage of outcome class frequency in the collected data.

Data augmentation

The image is rotated by an arbitrary amount (between −20 and 20 degrees) and then mirrored. The equation for the resulting rotated image, labelled I’, is: (1)${\displaystyle I^{\prime }\left(x^{\prime },y^{\prime }\right)=I\left(x,y\right)}$ where (x, y) are the pixel coordinates before the rotation, and (x’, y’) are the pixel coordinates after the rotation. The following formulae can be used to determine them: (2)${\displaystyle x^{{}^{\prime }}=\left(x-cente{r}_x\right)\ast cos\left(\theta \right)-\left(y-cente{r}_y\right)\ast sin\left(\theta \right)+cente{r}_x{y}^{{}^{\prime }}=\left(x-cente{r}_x\right)\ast sin\left(\theta \right)+\left(y-cente{r}_y\right)\ast cos\left(\theta \right)+cente{r}_y}$ the image’s centre is located at coordinates $\left(cente{r}_x,cente{r}_y\right)$.

Zooming: When zooming, the image may be zoomed in or out by a factor of up to 0.2 at random. Image I’ represents the newly zoomed in version and is defined as: (3)${\displaystyle I^{{}^{\prime }}\left(x^{{}^{\prime }},y^{{}^{\prime }}\right)=I\left(\frac{x}{zoo{m}_{factor}},\frac{y}{zoo{m}_{factor}}\right)}$ where (x, y) are the unzoomed pixel positions and (x’, y’) are the rescaled positions. The range of the zoom_factor is 0–2.

Flipping the image horizontally with a probability of 0.5 is called a horizontal flip. The equation denoting the inverted version of the picture, I’, is: (4)${\displaystyle I{\stackrel{ˆ}{}}^{\prime }\left(x{\stackrel{ˆ}{}}^{\prime },y{\stackrel{ˆ}{}}^{\prime }\right)=I\left(width-x-1,y\right)}$

where (x, y) are the pixel’s original coordinates, and (x’, y’) are the pixel’s new flipped coordinates. The image’s breadth, or width.

In a vertical flip, the image is flipped vertically with a probability of 50%. The equation denoting the inverted version of the picture, I’, is: (5)${\displaystyle I{\stackrel{ˆ}{}}^{\prime }\left(x{\stackrel{ˆ}{}}^{\prime },y{\stackrel{ˆ}{}}^{\prime }\right)=I\left(x,height-y-1\right)}$ where (x, y) are the original pixel coordinates, and (x’, y’) are the new flipped pixel coordinates. height is the height of the image.

During each training epoch, these transformations are randomly performed to each image in the training set. The enhanced image collection that results is utilized to train a dual pathway deep convolutional neural network model, which helps to expand the dataset and enhance model generalization.

Novel deep convolutional neural networks architecture

To better detect renal cell hydronephrosis in ultrasound images, we propose a unique deep convolutional neural network architecture in this study. There are two main components to the structure: feature extraction and categorization.

Three convolutional layers, two max pooling layers, and a batch normalization layer make up the feature extraction pipeline. The information gained from the third convolutional layer is then used to make classifications. The Rectified Linear Unit (ReLU) activation function is used in each convolutional layer, and it is defined as: (6)${\displaystyle f\left(x\right)=max\left(0,x\right)}$ where x is the input to the activation function. The ReLU activation function is commonly used in deep learning models to circumvent the vanishing gradient issue.

There are three layers involved in the classification process: a dropout layer, a batch normalization layer, and a third fully-connected layer. Dropout layers, which randomly remove neurons during training, assist prevent overfitting. The last fully connected layer’s output is fed into a sigmoid activation function, which in turn yields a probability between 0 and 1 indicating whether or not the input image contains renal cell hydronephrosis. Figure 3 shows the proposed DCNN architecture.

Important features are initially extracted from the input photos via the feature extraction pathway. Flattening the output of the third convolutional layer, the classification pathway labels input images as normal or with renal cell hydronephrosis.

The model is optimized during training with binary cross-entropy loss, which is defined as: (7)${\displaystyle L\left(y,y_{hat}\right)=-\left(y\ast log\left(y_{hat}\right)+\left(1-y\right)\ast log\left(1-y_{hat}\right)\right)}$ where y is the true label (either 0 or 1) and y_hat is the predicted probability according to the sigmoid activation function.

The proposed deep convolutional neural network design concludes with a feature extraction pathway and a classification pathway. The model was fine-tuned through the use of binary cross-entropy loss during training. The architecture was designed to effectively detect renal cell hydronephrosis in ultrasound images by using dropout layers and batch normalization layers, both of which serve to reduce overfitting.

Our Novel DCNN is a deep convolutional neural network specifically designed for disease detection in kidney ultrasound images. It comprises multiple convolutional layers, followed by batch normalization and rectified linear unit (ReLU) activation functions. We employ max-pooling layers to reduce spatial dimensions and mitigate overfitting. The exact architecture consists of 10 convolutional layers with varying filter sizes (ranging from 3 × 3 to 5 × 5) and three fully connected layers. Dropouts are strategically placed to enhance model generalization.

We can get the pseudocode for the recommended DCNN here:

1. Create a random set of weights and biases for the DCNN model.

2. Define the loss function (binary cross-entropy is one example).

3. Specify the optimizer (using terms like stochastic gradient descent).

4. For every iteration of training:

   1. Mix up the training data

   2. For each set of images and the labels that go with them:

      1. Data augmentation is performed on the collected photos, and then the images are normalized so that their mean is zero and their standard deviation is one.

      2. To acquire predictions,

      3. feed the augmented and normalized images into a deep convolutional neural network model.

      4. Find the percentage of error between the predicted and actual labels.

      5. Using backpropagation, find the loss’s gradients with respect to the model’s parameters.

      6. Update the model parameters using the optimizer

   3. Evaluate the performance of the model on the validation set

   4. If the validation loss stops improving, stop training and save the model

5. Evaluate the performance of the trained model on the test set

The convolution layer of a deep convolutional neural network (DCNN) applies a series of filters to the input picture to generate feature maps. Specifically, given an input image x and a filter w, we may define the convolution process between the two as: (8)${\displaystyle y\left(i,j\right)=\sum \underset{\left\{m=1\right\}}{\overset{\left\{M\right\}\sum \underset{\left\{n=1\right\}}{\overset{\left\{N\right\}x\left(m,n\right)w\left(i-m,j-n\right)}{m}}}{m}}+b}$

The output feature map is denoted by y(i, j), the input image pixel by $x\left(m,n\right)$, the filter coefficient by w(i − m, j − n), and the bias term b is denoted by b. The filter is slid over the full input image, the dot product between the filter and the corresponding patch of the image at each place is calculated, and a bias term is added to complete the convolution operation. The result is a “feature map” where each node indicates the filter’s reaction to a specific pixel in the input image.

Non-linearity is introduced to the DCNN by the application of the ReLU activation function. All input negative values are reset to zero by the ReLU activation function, while positive values are unmodified. Here is how we can characterize the ReLU activation function: (9)${\displaystyle f\left(x\right)=max\left(0,x\right).}$ where, f(x) represents the result of applying the activation function to the data represented by x.

Using a max operation on non-overlapping rectangular sections of the feature map, the max pooling layer shrinks the spatial size of the feature maps. Maximal pooling is defined mathematically as: (10)${\displaystyle y\left(i,j\right)=max\left(x\left(i\times stride:i\times stride+poo{l}_{size},j\times stride:j\times stride+poo{l}_{size}\right)\right)}$

The output feature map at coordinates (i,j) is denoted by y(i,j), the input feature map is denoted by x, the pooling window size is denoted by pool_size, and the stride length is denoted by stride. Using the maximum response in each pooling window, the max pooling process coarsens the feature map while keeping the most relevant data.

The feature maps from many channels are combined at the concatenation layer by stringing them together along the channel axis. Concatenation, in mathematical terms, is defined as: (11)${\displaystyle y=\left[x_1,x_2,\dots ,x_n\right]}$

In this case, x₁, x₂, …, x_n are the input feature maps, and y is the desired output.

In a network with a completely connected layer, every input neuron is linked to every output neuron. The mathematical definition of the output of a completely connected layer is: (12)${\displaystyle y=f\left(Wx+b\right)}$

In the table below, we can see the activation function f, the weight matrix W, the input vector x, the bias vector b, and the final output y.

Performance evaluation

An external test set was used to evaluate the trained models in terms of their precision, recall, accuracy, and area under the receiver operating characteristic curve (AUC-ROC). Models were tested against human experts in a classification task involving renal cell hydronephrosis found in ultrasound images of the kidney. Accuracy, precision, recall, and F1-score are used to rank the recommended DCNN model for automatic detection of Renal Cell Hydronephrosis in ultrasound images. These indicators are used to determine the efficacy of a model. Listed below is an explanation of each of these KPIs:

Accuracy: The fraction of test photos with the right classifications.

Precision: The percentage of confirmed positive cases relative to total positive cases correctly recognized.

Recall: The percentage of true positive instances that were detected accurately.

F1-score: The symphonic method of specificity and memory.

These measures of model performance assess how well the model can distinguish between normal and renal cell hydronephrosis near kidneys ultrasound images. The model’s ability to identify renal cell hydronephrosis in the vicinity of the kidneys in ultrasound images is supported by high levels of accuracy, precision, recall, and F1-score. The formulas and corresponding performance metrics are listed in the Table 1:

where:

TP = true positives

TN = true negatives

FP = false positives

FN = false negatives

A “true positive” ultrasound image is one that has been correctly identified as having renal cell hydronephrosis near the kidneys, while a “true negative” ultrasound image is one that has been correctly identified as normal in the context of automated detection of renal cell hydronephrosis near the kidneys. An image is considered a false positive if it is wrongly labeled as showing renal cell hydronephrosis near the kidneys, and a false negative if it is labeled as normal when it truly does. Image analysis for the presence of renal cell hydronephrosis close to the kidneys is prone to both of these mistakes.

VGG16

VGG16 is a classic architecture known for its simplicity and effectiveness. It consists of 16 layers with small 3 × 3 convolutional filters and max-pooling layers for spatial down sampling. Fully connected layers follow the convolutional layers for classification. As a result of feeding the output of the final fully connected layer of the VGG16 architecture into a dense layer and flattening the output, we get a 4,096-dimensional feature vector. The feature vector is then converted into a 1,000-dimensional probability vector for each class in a second dense layer.

The structure of VGG16 is composed of five distinct parts. Convolutional layers make up the first two segments, whereas the last segment is a max pooling layer. After the first four convolutional layers, the third part employs a max pooling layer. The fourth layer is a max pooling layer, which is used after two convolutional layers. The fifth part is broken up into three sequential but related phases.

A 2242243 RGB image is sent to the VGG16 system. The ReLU activation function is used as the final step after each convolutional layer. Prior to being passed on to the fully linked layers, the output of the final convolutional layer is normalized. A softmax activation function is utilized to determine class probabilities in the final fully linked layer.

The VGG16 architecture is described in detail by the following set of equations at each layer:

on generate feature maps, a convolutional layer applies a series of filters on the input image. The mathematical definition of a combined input picture (x) and filter (w) is: (14)${\displaystyle y\left(i,j,k\right)=f\left(bias\left(k\right)+sum\left(sum\left(sum\left(x\left(m,n,p\right)\ast w\left(i-m,j-n,p,k\right)\right)\right)\right)\right)}$ where x(m, n, p) is the input image pixel at position (m,n,p), w(i-m,j-n,p,k) is the filter coefficient at position (i − m, j − n, p, k),  bias(k) is a bias term for the k − th filter, and f is the activation function.

Activation function of the ReLU: All negative input values are converted to zero by the ReLU activation function, while positive values are left unmodified. To explain what the ReLU activation function is, we can say: (15)${\displaystyle f\left(x\right)=max\left(0,x\right)}$

where f(x) represents the activation function’s result when fed the value x.

Maximum layer of pooling: By performing a max operation on non-overlapping rectangular portions of the feature map, the spatial size of the feature maps is reduced by a max pooling layer. Maximal pooling is defined mathematically as:

(16)${\displaystyle y\left(i,j,k\right)=max\left(x\left(istride:istride+poo{l}_{size},jstride:jstride+poo{l}_{size},k\right)\right)}$

where x is the input feature map, pool_size is the size of the pooling window, and stride is the stride length, and y(i, j, k) is the output feature map at location (i, j, k).

All of the neurons in the input layer are linked to all of the neurons in the output layer, forming a completely connected layer. The mathematical definition of the output of a completely connected layer is: (17)${\displaystyle y=f\left(Wx+b\right)}$ output (y), input (x), weight matrix (W), bias vector (b), activation function (f).

Because of its computational complexity, the VGG16 architecture contains 138 million trainable parameters. But it excels at a wide variety of computer vision tasks, such as object recognition and detection, image segmentation, and image captioning.

Accuracy and confusion matrices for the diagnosis of renal cell hydronephrosis near the kidneys using VGG 16 are shown in Figs. 4 and 5, respectively.

ResNet50

ResNet50 is a variant of the ResNet architecture, renowned for its deep layer capacity. It includes 50 convolutional layers with residual connections. Each residual block contains multiple convolutional layers and batch normalization. Global average pooling is followed by fully connected layers for classification.

ResNet50 uses a dense layer to generate a 2048-dimensional feature vector from the flattened output of the last convolutional layer. A second dense layer receives this feature vector as input and generates a 1,000-dimensional vector to represent the anticipated class probabilities.

In ResNet50, a binary classification layer receives the results of the final average pooling layer. The equation for classifying data looks like this: (18)${\displaystyle Y=sigmoid\left(W2\ast ReLU\left(W1\ast X+b1\right)+b2\right)}$

In this formula, X represents the input image, W1 and b1 represent the average pooling layer’s learned weights and biases, ReLU represents the rectified linear unit activation function, W2 and b2 represent the binary classification layer’s learned weights and biases, and Y represents the predicted probability of X belonging to the positive class.

W1 and b1 represent the first dense layer’s weights and biases, and W2 and b2 represent the second dense layer’s weights and biases. The softmax function is f, and the input picture is X. Accuracy and confusion matrix for detecting renal cell hydronephrosis near kidneys using ResNet50 are shown in Figs. 6 and 7, respectively.

Novel DCNN

The suggested Novel DCNN has the following classification equation:

Imagine that we have an image input (x), a label (y), and a mapping (F) that the model has learned. For some input x, the model yields an output of: (19)${\displaystyle y_{hat}=argmax\left(F\left(x;W\right)\right)}$

where W is the model’s trainable parameters and argmax is a function that delivers the most likely classification. It can be shown how to calculate the mapping F(x; W):

The equation F(x; W) represents the mapping function in the model, which can be summarized as follows: (20)${\displaystyle F\left(x;W\right)=Softmax\left(FC\left(Dropout\left(Flat\left(Concat\left(P2\left(C2\left(P1\left(C1\left(x\right)\right)\right)\right)\right),P4\left(C4\left(P3\left(C3\left(x\right)\right)\right)\right)\right)\right)\right)\right)}$

In this equation, x represents the input image, W represents the model’s trainable parameters, and the operations within the parentheses denote the different layers of the model. The conv1, conv2, conv3, and conv4 represent the convolutional layers, while pool1, pool2, pool3, and pool4 represent the max pooling layers. The concat operation concatenates the outputs of the pooling layers, and the flat operation flattens the concatenated output. The fully-connected layer connects all the flattened neurons, and the dropout layer helps prevent overfitting. Finally, the softmax function is applied to obtain the predicted class probabilities.

For the sake of avoiding overfitting, the proposed Novel DCNN employs a dual pathway design featuring parallel convolutional layers, followed by a fully connected network featuring a dropout layer. The output layer of the model, which was trained to distinguish between renal cell hydronephrosis and malignancies of the kidneys, makes class probability predictions using a softmax activation function. Figure 8 shows the confusion matrix for DCNN while Fig. 9 shows the DCNN performance. Figure 10 shows the Accuracy vs Epochs perofrmance using the DCNN model. While Fig. 11 shows the Loss vs Epochs performance using DCNN model.

Hyperparameter selection

The hyperparameters for the proposed Novel DCNN model, including learning rate, batch size, and dropout rate, were selected through a systematic and iterative process. Here’s how these choices were made:

Learning rate: We conducted a learning rate search by training the model with a range of learning rates, starting from a relatively small value (e.g., 0.001) and increasing gradually. We monitored the model’s training and validation curves to identify the learning rate that resulted in stable training behavior and improved convergence. The selected learning rate was 0.001.

Batch size: Batch size significantly affects training dynamics and memory requirements. We experimented with different batch sizes, including 16, 32, and 64. Ultimately, we chose a batch size of 32, as it struck a balance between computational efficiency and training stability.

Dropout rate: Dropout is a regularization technique that helps prevent overfitting. We performed a grid search over dropout rates, including 0.2, 0.3, and 0.4, to find the optimal dropout rate. A dropout rate of 0.3 was selected as it demonstrated improved generalization.

Influence on model performance:

The careful selection of hyperparameters and the use of 5-fold cross-validation contributed to the robustness and generalization ability of the proposed Novel DCNN model. The chosen hyperparameters helped the model converge effectively during training, prevent overfitting, and generalize well to unseen data. This is reflected in the model’s outstanding performance with a training accuracy of 99.8% and a testing accuracy of 98%.

Comparison

The following table compares the performance of various models on the job of detecting renal cell hydronephrosis close to the kidneys. We look at Novel DCNN, InceptionV3, ResNet50, and VGG16 to see how they stack up. The training optimizer is also specified for each model. Percentages indicate the proportion of test photos that were properly identified relative to the total number of test images. Results showed that Novel DCNN had the highest accuracy at 99.8%, followed by InceptionV3, ResNet50, and VGG16 in that order (90, 89, 85). All models utilized the same input data and preprocessing methods, but they vary in terms of their architecture and optimizer.

Figures 12 and 13 shows the accuracy precision, recall and F1 Score and testing loss for each model, respectively.

Figure 14 shows the accuracy comparison of different models. The results demonstrate that the proposed Novel DCNN model outperforms the other state-of-the-art models in this task, achieving nearly perfect accuracy. We explain that ADAM is often preferred for its adaptive learning rate capabilities, which allow it to dynamically adjust learning rates for each parameter. This adaptability often leads to faster convergence and improved performance, particularly for complex models like deep neural networks. We also mention that ADAM has been widely adopted in the deep learning community and has demonstrated success in various applications. we briefly compare it to other optimizers like RMSProp and SGD, outlining scenarios where one optimizer might be more suitable than the others. This provides readers with insights into the considerations involved in selecting the appropriate optimizer for a given task, while Table 2 shows the comparison.