2.4.

4 Proposed AI Model Architecture and Implementation Plan

Conceptual Framework for the Proposed Project

The proposed AI model architecture for the Type-2 Diabetes Mellitus (T2DM) diagnostic system
centers around a Feedforward Neural Network (FFNN), designed to analyze diagnostic
variables and predict the probability of T2DM. The model incorporates advanced machine
learning techniques, interpretability tools, and web-based deployment to ensure real-time
usability, accuracy, and transparency. This section outlines the structure of the model, its
components, and an actionable implementation plan.

1. Model Architecture Overview

The architecture of the proposed FFNN model consists of the following key components:

1. Input Layer: Receives diagnostic variables (e.g., glucose levels, BMI, age).
2. Hidden Layers: A series of dense layers that extract patterns and relationships from the
input data.
3. Output Layer: Outputs the probability of T2DM as a binary classification.
4. Regularization Techniques: Includes methods like L2 regularization, dropout, and batch
normalization to mitigate overfitting and improve generalization.
5. Interpretability Tools: Implements SHAP values to enhance the explainability of
predictions.

2. Detailed Model Structure

a. Input Layer

 The input layer processes a feature vector x i=[ x 1 , x 2 , x 3 , x 4 … . x n ]

 where xi represents individual diagnostic variables such as glucose levels, BMI, and age.
 Preprocessing steps include:
o Handling Missing Values: Missing data is imputed using techniques like mean
imputation or predictive algorithms.
o Normalization: Diagnostic variables are scaled to have a mean of 0 and a
standard deviation of 1, ensuring numerical stability for the model:

' x i−μ i
x=
σi

Where:

xi: Original value of the i-th feature.

μi: Mean of the i-th feature in the training dataset.

σi: Standard deviation of the i-th feature.

b. Hidden Layers

Regularization techniques are critical for ensuring the success of deep learning models in real-
world applications. By incorporating methods like L2 regularization, dropout, and batch
normalization, the proposed T2DM diagnostic system achieves robust generalization and reliable
performance, making it well-suited for deployment in healthcare environments.

 Structure:
o The FFNN contains multiple dense (fully connected) layers, each consisting of
neurons connected to every neuron in the preceding layer.
o Each dense layer applies ReLU (Rectified Linear Unit) activation to capture
non-linear relationships:

ReLU (z)=max(0 , z )

Where z is the weighted sum of inputs plus a bias term.

 Hyperparameters:
o The number of hidden layers and neurons per layer is determined through
hyperparameter optimization (e.g., grid search, random search).
 Regularization Techniques:
o L2 Regularization (Weight Decay):

Definition: L2 regularization, also known as weight decay, discourages large weight values in
the model by adding a penalty term to the loss function. This ensures that the weights remain
small, reducing the likelihood of overfitting.

The L2-regularized loss function is given by:

n
Loss total=Loss original + λ ∑ w2i
i=2

Where:

 Loss total: The original loss function (e.g., binary cross-entropy loss).
 λ: Regularization strength (hyperparameter controlling the importance of the penalty
term).
 wi: Weight of the i-th parameter.
 n: Total number of weights in the model.
 n
The penalty term λ ∑ wi encourages smaller weight magnitudes, making the model less
2

i=2
complex and less likely to overfit.

Impact:

 Reduces overfitting by penalizing large weights.

 Improves generalization by ensuring the model does not overly rely on any single feature.

Implementation in TensorFlow/Keras:

python
from tensorflow.keras import regularizers
model.add(Dense(64, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))

In this code, regularizers.l2(0.01) applies L2 regularization with λ(lambda) = 0.01.

 Dropout: Randomly deactivates neurons during training to promote redundancy and

improve generalization.

Definition: Dropout is a stochastic regularization technique that randomly "drops" (sets to zero)
a fraction of the neurons during training. This forces the network to learn redundant and
independent features, making it more robust.

Mathematical Insight: During training, each neuron is either retained with a probability p or
1
dropped with a probability 1−p. The retained outputs are scaled by during training to maintain
p
consistent output magnitudes.

Impact:

 Reduces overfitting by preventing co-adaptation of neurons.

 Encourages feature independence and robustness.

Implementation in TensorFlow/Keras:

python
from tensorflow.keras.layers import Dropout
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5)) # Dropout rate of 50%

In this example, Dropout(0.5) randomly deactivates 50% of the neurons in the layer during
each training iteration.
  Batch Normalization: Normalizes intermediate layer outputs to stabilize and accelerate
training.

Definition: Batch normalization normalizes the inputs to each layer, ensuring they have a mean
of zero and a standard deviation of one. This reduces internal covariate shift, stabilizing the
training process.

Mathematical Formulation: For a batch of inputs xx, the normalized values x^\hat{x} are
calculated as:

x−μ
x̂ =
σ
x

Where: x

 μ: Mean of the mini-batch.

 σ: Standard deviation of the mini-batch.

Centering: Subtracting the batch mean μ centers the feature values around 0. This ensures
the inputs are aligned around a consistent central value.

Scaling (Dividing by 𝜎): Dividing by the batch standard deviation 𝜎 scales the input
values so that they have unit variance (a standard deviation of 1). This ensures the
features are on the same scale.

After applying this formula, the batch of inputs 𝑥 is transformed into normalized values x̂
which have a mean of 0 and a standard deviation of 1.

The normalized inputs are then scaled and shifted using learnable parameters γ and β

y = γ x̂ + β

3. Scaling and Shifting

Once normalized, the inputs x̂ are adjusted using learnable parameters

𝛾 (scale) and 𝛽 (shift):

𝑦=𝛾 x̂ +𝛽

Where:
𝛾: A scaling factor that allows the network to learn the appropriate scale for the inputs.

𝛽: A shifting factor that allows the network to learn the appropriate offset for the inputs.

𝑦: The final output of the batch normalization process.

Explanation:

Purpose of Scaling (𝛾):

While normalization fixes the inputs to have zero mean and unit variance, this may not always be
optimal for the neural network. The scaling parameter

allows the network to learn a different standard deviation if needed.

Purpose of Shifting (𝛽):

Similarly,

allows the network to learn a new mean for the inputs after normalization, as the optimal mean may
not always be 0.

Thus,

and

reintroduce flexibility into the network, making batch normalization adaptable for a wide range of tasks.

Impact:

 Reduces sensitivity to weight initialization.

 Accelerates training by stabilizing gradients.

Implementation in TensorFlow/Keras:

python
from tensorflow.keras.layers import BatchNormalization
model.add(Dense(64, activation='relu'))
model.add(BatchNormalization())
c. Output Layer

 The output layer generates the final prediction using a sigmoid activation function:

1
σ (z)= −z
1+e

 The output ŷ represents the probability of T2DM, where:

o ŷ ≥0.5: Positive diagnosis (T2DM).
o ŷ <0.5: Negative diagnosis (no T2DM).

d. Loss Function

 The model minimizes a binary cross-entropy loss function during training:

N
1
Loss=
N
∑ ( y i log ( ŷ i ) +( 1− y i ) log ( 1− ŷ i ) )
I=1

Where:

 N: Number of samples in the batch.

 yi: True label (0 or 1).
 ŷi: Predicted probability of T2DM for the ii-th sample.

e. Interpretability with SHAP Values

 SHAP (SHapley Additive exPlanations) values are used to quantify the contribution of
each diagnostic variable to the prediction.
 Mathematical Insight:

|S|! (|N|−|S|−1 ) !
∅ i= ∑ |N|!
( f ( S ∪ { i }−f ( S )) )
S ⊆ N ¿ {i¿}

Where:

 ∅ i: SHAP value for feature xi

 N: Set of all features.
 S: Subset of features excluding i.
 f(S): Model prediction based on the subset S.

The SHAP values satisfy the property:

 n
ŷ=∅ 0 + ∑ ∅ i
i=1
 where:
 ∅ 0 is the base value (average prediction over the dataset.
 ∅ i represents the contribution of the i-th feature to the prediction.
 Implementation in Python:

python

import shap
explainer = shap.DeepExplainer(model, X_train)
shap_values = explainer.shap_values(X_test)

1. Key performance metrics.

The following metrics form the foundation for evaluating the T2DM evaluation system

a. Accuracy

 Definition: Accuracy measures the percentage of correct predictions made by the model
out of all predictions.
 Formula:

TP+TN
TP+ TN + FP+ FN

 Explanation:

TP: True Positives (correctly predicted diabetes cases).

TN: True Negatives (correctly predicted non-diabetes cases).
FP: False Positives (non-diabetes cases incorrectly predicted as diabetes).
FN: False Negatives (diabetes cases incorrectly predicted as non-diabetes).

 Use Case:

Accuracy provides a high-level overview of the model’s performance but may not
fully represent its effectiveness in imbalanced datasets where one class is dominant.

b. Precision

 Definition: Precision measures how many of the predicted positive cases were correctly
classified as true positives.
 Formula:
 TP
Precision =
TP+ FP

 Explanation:

A high precision indicates that the model has a low false positive rate.

 Use Case:

Precision is crucial in scenarios where false positives carry significant

consequences (e.g., diagnosing a healthy patient as diabetic).

c. Recall (Sensitivity or True Positive Rate)

 Definition: Recall measures how well the model identifies actual positive cases.
 Formula:

TP
Recall =
TP+ FN

 Explanation:
o A high recall means the model misses very few actual positive cases.
 Use Case:
o Recall is critical when the cost of false negatives is high (e.g., failing to diagnose
a diabetic patient).

d. F1-Score

 Definition: The F1-score is the harmonic mean of precision and recall, providing a single
measure to balance false positives and false negatives.
 Formula:

Precision x Recall
F1 score = 2 X
Precision+ Recall

 Use Case:
o Useful when dealing with imbalanced datasets, where optimizing both precision
and recall is important.

e. Confusion Matrix

 Definition: A confusion matrix is a tabular representation of the model's predictions

compared to the actual labels, showing true positives, true negatives, false positives, and
false negatives.
 Structure:
 Use Case:
 o The confusion matrix provides a detailed view of the model's errors, helping to
identify patterns in misclassification.

f. Error Rates

 Definition: Error rates measure the proportion of incorrect predictions out of all
predictions.
 Types:
1. False Positive Rate (FPR):

FP
FPR =
FP+TN

 Indicates the proportion of non-diabetes cases incorrectly classified as diabetes.

2. False Negative Rate (FNR):

FN
FNR =
TP+ FN

 Represents the proportion of diabetes cases missed by the model.

g. ROC Curve and AUC

 Definition:
o The Receiver Operating Characteristic (ROC) curve plots the true positive rate
(recall) against the false positive rate at various thresholds.
o The Area Under the Curve (AUC) represents the model’s ability to differentiate
between classes.
 Use Case:
o The ROC-AUC metric is particularly useful for evaluating the trade-off between
sensitivity and specificity, especially in imbalanced datasets.

3. Application in the Proposed T2DM Diagnostic System

The proposed FFNN-based system applies these metrics as follows:

1. Training and Validation:

During the training phase, accuracy, precision, recall, and F1-score are monitored
to evaluate the model’s fit on both training and validation data.

2. Testing and Evaluation:

After training, the model is tested on a separate dataset to compute the confusion
matrix, FPR, FNR, and AUC.
 3. Error Analysis:

Errors such as false positives and false negatives are analyzed using the confusion
matrix.

4. Interpretability:

SHAP values complement traditional metrics by explaining the contributions of

individual features to the predictions.

Practical Example

The WHO (2021) features are as follows:

1. Pregnancies: Number of times pregnant.

2. Glucose: Plasma glucose concentration after a 2-hour oral glucose tolerance test.

3. Blood Pressure: Diastolic blood pressure (mm Hg).

4. Skin Thickness: Triceps skinfold thickness (mm).

5. Insulin: 2-hour serum insulin (mu U/ml).

6. BMI: Body mass index (weight in kg/(height in m)^2).

7. Diabetes Pedigree Function: A score indicating family history of diabetes.

8. Age: Age of the patient (years).

Scenario:

A patient provides the following diagnostic inputs:

- Pregnancies: 3

- Glucose: 120 mg/dL

- Blood Pressure: 70 mm Hg

- Skin Thickness: 30 mm

- Insulin: 90 mu U/ml

- BMI: 28.4

- Diabetes Pedigree Function: 0.627

- Age: 35 years
Step-by-Step Workflow:

1. Input Representation:

-The diagnostic data is collected as the following feature vector:

x=[3 , 120 , 70 ,30 , 90 , 28.4 , 0.627 , 35]

---

2. Data Preprocessing:

- Normalization:

Each feature xi is normalized using the formula:

' x i−μ i
x=
σi
Where:

μi : Mean of the \( i \)-th feature in the training dataset.

σ i: Standard deviation of the \( i \)-th feature in the training dataset.

- After normalization, the feature vector becomes:

x '=[0.25 ,0.5 ,−0.1 , 0.2, 0.3 , 0.1 , 0.4 , 0.15]

(Values are illustrative and depend on the actual dataset statistics.)

---

3. FFNN Prediction:

- The normalized feature vector x ' is fed into the neural network.

- Model Computation:
 The output ŷ, representing the probability of T2DM, is calculated using the formula:

ŷ=σ ( W L . hL−1+ b L )

\]

Where:

ŷ : Predicted probability of T2DM.

W L: Weight matrix for the output layer.

h L−1 : Output vector from the previous hidden layer.

b L: Bias vector for the output layer.

1
σ ( z )= − z : Sigmoid activation function, ensuring the output is a probability between 0 and 1.
1+e

- Prediction:

The model computes ŷ = 0.78, indicating a 78% probability that the patient has T2DM.

---

4. Interpretability with SHAP Values:

- SHAP Analysis:

SHAP values are computed to quantify the contribution of each feature to the prediction. For this
case:

- Glucose: +0.50 (50% contribution)

- BMI: +0.15 (15% contribution)

- Diabetes Pedigree Function: +0.10 (10% contribution)

- Age: +0.08 (8% contribution)

- Pregnancies: +0.07 (7% contribution)

- Other features (Blood Pressure, Skin Thickness, Insulin): Contribute marginally.

- Interpretation:
 The SHAP analysis shows that glucose levels are the most significant feature driving the prediction,
followed by BMI and the diabetes pedigree function.

---

5. Personalized Recommendations:

- Based on the prediction and SHAP analysis, the following recommendations are generated:

1. Lifestyle Changes:

- Adopt a low-sugar diet.

- Engage in regular physical activity (e.g., walking, yoga).

2. Medical Advice:

- Schedule a follow-up oral glucose tolerance test.

- Consult a dietitian for a personalized meal plan.

3. Health Monitoring:

- Begin routine blood glucose monitoring to track changes.

---

Conclusion

Using all eight features from the Pima Indians dataset, the system successfully predicted a 78%
probability of T2DM for the patient. The interpretability provided by SHAP values allowed for a
transparent explanation of the prediction, highlighting the critical role of glucose levels, BMI, and family
history in the diagnosis. Personalized recommendations were tailored to address the patient's specific
risk factors, empowering them to take proactive steps in managing their health.

4. Benefits of Using Comprehensive Metrics

 Transparency: Provides multiple perspectives on the model’s performance, ensuring its

reliability and trustworthiness.
 Holistic Evaluation: Combines various metrics to assess the system's strengths and
weaknesses comprehensively.
 Continuous Improvement: Guides iterative refinement of the model by highlighting
areas for improvement.
Database metrics
1. Data Storage and Retrieval Efficiency
A critical aspect of database storage involves calculating the time complexity
of data operations such as insertion, deletion, and retrieval. For example:
- Time Complexity for searching a record in a structured database:
\[
T(n) = \log(n)
\]
Where:
- \( T(n) \) is the time it takes to search for a record.
- \( n \) is the number of records in the database.
- A binary search or indexed structure is assumed, ensuring efficient
access.

For healthcare systems, indexed databases with key-value pairs or relational

schemas reduce the time needed to fetch patient records by using lookup tables
or primary keys.

2. Database Storage Size

To estimate the storage requirements of a database storing patient diagnostic
data, you can use the formula:
\[
S = N \cdot (d_1 + d_2 + \dots + d_m)
\]
Where:
- \( S \): Total storage size needed.
- \( N \): Number of patient records.
- \( d_1, d_2, \dots, d_m \): Size of each data attribute (e.g., glucose
level, BMI, or lab results) in bytes.

# Example:
If a database stores 10,000 patient records, each with 8 attributes (such as
glucose, BMI, age, etc.), and each attribute takes 10 bytes on average:
\[
S = 10,000 \cdot (10 \times 8) = 800,000 \, \text{bytes} = 800 \, \text{KB}
\]

This simple formula helps with storage planning and ensuring the database
infrastructure has sufficient capacity.

3. Redundancy and Backup Costs

For fault-tolerant systems, redundancy is implemented through replication or
backup strategies. If a database employs \( r \)-fold redundancy for safety:
\[
S_{\text{redundant}} = r \cdot S
\]
Where:
- \( S_{\text{redundant}} \): Total storage with redundancy.
- \( S \): Original storage size without redundancy.
- \( r \): Number of copies (e.g., \( r = 3 \) for triple redundancy).

This ensures data is duplicated across servers for disaster recovery or high
availability.
 4. Query Optimization and Response Time
When designing query structures (e.g., SQL queries for healthcare databases),
optimization ensures minimal execution time. The query execution cost \
( Q_c \) can be estimated as:
\[
Q_c = \sum_{i=1}^n f_i \cdot c_i
\]
Where:
- \( f_i \): Frequency of access for the \( i \)-th table or index.
- \( c_i \): Access cost for the \( i \)-th table or index.

Efficient query design leverages indexing, caching, and normalization to

minimize \( Q_c \).

5. Scalability in Distributed Databases

For distributed systems storing healthcare records, the storage and latency
are evaluated using formulas such as:
\[
L = D + T
\]
Where:
- \( L \): Latency (time to retrieve data).
- \( D \): Time for distributed query execution (depends on network speed).
- \( T \): Time to fetch data from storage.

Distributed databases often apply sharding or partitioning to balance storage

loads across nodes, ensuring scalability.

6. Security and Encryption

To secure sensitive data (e.g., patient records), encrypted databases are
used. The overhead caused by encryption can be calculated as:
\[
S_{\text{encrypted}} = S + O_{\text{encryption}}
\]
Where:
- \( S_{\text{encrypted}} \): Total size of encrypted storage.
- \( S \): Original storage size.
- \( O_{\text{encryption}} \): Additional storage overhead for encryption
metadata.

Encryption ensures compliance with healthcare privacy regulations like HIPAA

while adding a small storage and computational cost.

Conclusion
While there isn't a single formula for database storage in healthcare systems,
various mathematical principles and models, such as those outlined above,
guide the design and management of secure, scalable, and efficient databases.
These formulas ensure the system can handle massive datasets, protect
sensitive information, and provide real-time access to patient records for
diagnostic and decision-making purposes

3. Implementation Plan

a. Data Collection and Preprocessing

1. Collect historical patient data containing diagnostic variables and outcomes.

2. Handle missing values and normalize features.
3. Split the dataset into training, validation, and test sets.

b. Model Development

1. Define Architecture:
o Design the FFNN using TensorFlow/Keras.
o Add dense layers, activation functions, regularization techniques, and the output
layer.
2. Train the Model:
o Use the training data to optimize model weights.
o Monitor performance on the validation set using metrics such as accuracy,
precision, recall, and F1-score.
3. Evaluate Performance:
o Test the model on unseen data to ensure generalization.

c. Interpretability and Deployment

1. Use SHAP values to explain individual predictions.

2. Deploy the trained model as a web application using frameworks like Flask or Django.
3. Enable real-time user interaction for healthcare providers and patients.

4. Benefits of the Proposed Model

 High Accuracy: The FFNN accurately predicts T2DM based on historical patient data.
 Transparency: SHAP values enhance explainability, fostering trust among healthcare
professionals.
 Scalability: The web-based platform can handle diverse datasets and users.
 Personalized Care: Provides patient-specific recommendations based on model
predictions and interpretability insights.

Conclusion

The proposed AI model architecture employs a robust Feedforward Neural Network (FFNN)
to predict diabetes risk with high accuracy and transparency. By integrating advanced
regularization techniques, interpretability tools, and web-based deployment, the system delivers
actionable insights for healthcare providers, paving the way for personalized, data-driven
healthcare solutions.