Phase 5 Submission –

Health Monitoring and

Diagnosis

College code: 9100

College Name : Anna University Regional Campus Madurai
Technology : Artificial Intelligence

Total Number of Students : 5 Students’s

Details Within the Group

Rahul R

Mothilal C

MadhanKumar M

Jayasurya P

Mohammed Taufeeq A

Submitted by,
RAHUL R
Aut6381049559
 Phase 5 Document: Model Development and
Evaluation Metrics for AI-based Health Monitoring
and Diagnosis

Introduction
Health monitoring and diagnosis are critical for improving patient outcomes and
healthcare efficiency. This project aims to develop a robust system utilizing
machine learning for real-time health monitoring and accurate diagnosis of
medical conditions.

Project Objectives

1. Develop a highly accurate model capable of diagnosing medical conditions

with minimal false positives (Type I errors).
2. Enhance healthcare measures by providing insights into evolving health
patterns through model analysis.
3. Integrate seamlessly with existing health monitoring systems for real-time
diagnosis and alerting of potential health issues.

System Requirements

Data:
Historical Health Data: A large, labeled dataset of patient records categorized by
medical condition. The data should encompass:
 Patient information (hashed or anonymized for privacy)
 Clinical details (symptoms, diagnosis, treatment history, lab results)
 Additional relevant features (e.g., device type, sensor data)
Hardware:
 A computer system with sufficient processing power:
 Consider GPUs for deep learning models (e.g., TensorFlow, PyTorch)
 Ample RAM to handle large datasets and complex algorithms

Software:
Machine Learning Libraries:
 scikit-learn (traditional ML algorithms, data preprocessing)
 TensorFlow, PyTorch (deep learning models)

Data Analysis Tools:

pandas, NumPy (data manipulation, feature engineering)

Development Environment: Jupyter Notebook (facilitates code writing,

experimentation, visualization)

Methodology

Data Preprocessing

1. Data Acquisition and Exploration:

 Securely obtain historical health data.
 Explore the data to understand its structure, identify potential issues, and gain
insights into health patterns.
2. Data Cleaning:
 Address missing values using imputation techniques (mean/median
imputation, removal based on impact) or domain-specific knowledge.
 Handle outliers through capping (setting a threshold), winsorization (replacing
extreme values with percentiles), or removal if they significantly deviate from
the normal range.
 Ensure data consistency by checking for formatting errors, invalid entries, and
inconsistencies between features.

3. Data Transformation:
 Encode categorical features (e.g., diagnosis codes, patient demographics) using
techniques like one-hot encoding or label encoding.
 Apply feature scaling (normalization or standardization) for algorithms
sensitive to feature scale.
 Consider feature hashing for high-cardinality categorical features (many unique
values) to reduce dimensionality.

4. Feature Engineering:
Extract relevant features from the health data that can enhance the model's
ability to predict medical conditions:
Clinical Features: Symptom severity, duration, frequency, lab results.
Patient Features: Age, gender, medical history, lifestyle factors.
Temporal Features: Time of symptom onset, seasonality trends in health
conditions.
Derived Features: Ratios (e.g., current lab result to historical average),
differences (e.g., change in symptom severity), statistical summaries (e.g.,
standard deviation of lab results).
Model Selection and Training

Evaluation Criteria: Accuracy (overall correctness), precision (proportion of true

positives), recall (proportion of identified conditions), F1 score (harmonic mean of
precision and recall), cost-sensitive metrics (considering the impact of
misdiagnoses).
Algorithm Selection: Consider a range of machine learning algorithms suitable for
health monitoring and diagnosis.

Model Evaluation

Evaluate the trained model's performance on the unseen testing set using metrics
like:

 Accuracy: Overall percentage of correctly classified conditions.

 Precision: Proportion of flagged diagnoses that are truly accurate (avoiding
false positives).
 Recall: Proportion of actual conditions that are correctly identified (avoiding
false negatives).
o F1 Score: Harmonic mean of precision and recall.
o ROC-AUC: Measure of the model's ability to discriminate between
classes.
o Calibration Metrics: Brier Score, calibration curve.
Existing Work

Existing health monitoring and diagnosis methods draw from various areas.
Traditionally, rule-based systems relied on predefined flags for symptoms, but
their static nature limited their effectiveness. Machine learning offers a more
adaptable approach. Supervised learning algorithms like logistic regression or
random forests analyze labeled data (e.g., diagnosed and undiagnosed conditions)
to learn patterns and classify new cases. Unsupervised learning techniques like
clustering can identify groups of cases with similar patterns, potentially revealing
hidden conditions.

Proposed Work

The core of the project involves the selection and training of machine learning
models. We will leverage a combination of traditional and advanced algorithms,
including Logistic Regression, Random Forest, Gradient Boosting Machines, and
Support Vector Machines. Each algorithm's performance will be meticulously
evaluated using metrics like accuracy, precision, recall, F1 score, and cost-sensitive
metrics. This evaluation process will guide us in selecting the most suitable model
or ensemble of models for optimal health monitoring and diagnosis.

Conclusion

This project aims to develop a robust and effective AI-based health monitoring
and diagnosis system. By leveraging advanced machine learning algorithms and
comprehensive evaluation metrics, we strive to improve patient outcomes and
enhance healthcare efficiency. The insights gained from this project will guide us
in selecting the optimal model for deployment in real-world healthcare scenarios.
Implementation and Explanation of the Code

Below is a Python code implementation using PyTorch to develop a health

monitoring and diagnosis system. This code trains a simple Convolutional Neural
Network (CNN) on image data, which could be representative of medical imaging
data.

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns; sns.set(style='darkgrid')
import copy
import os
import torch
from PIL import Image
from torch.utils.data import Dataset
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import random_split
from torch.optim.lr_scheduler import ReduceLROnPlateau
import torch.nn as nn
from torchvision import utils
from torchvision.datasets import ImageFolder
import splitfolders
from torchsummary import summary
import torch.nn.functional as F
import pathlib
from sklearn.metrics import confusion_matrix, classification_report
import itertools
from tqdm.notebook import trange, tqdm
from torch import optim
import warnings
warnings.filterwarnings('ignore')

# Load and preprocess the dataset

data_dir = 'path_to_your_data'
dataset = ImageFolder(data_dir, transform=transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor()
]))

# Split the dataset into training and validation sets

train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
# Create data loaders
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32,
shuffle=True)
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32,
shuffle=False)

# Define the neural network architecture

class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(32 * 32 * 32, 512)
self.fc2 = nn.Linear(512, 2)

def forward(self, x):

x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 32 * 32 * 32)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x

model = SimpleCNN()
# Summary of the model
summary(model, input_size=(3, 128, 128))

# Define loss function and optimizer

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = ReduceLROnPlateau(optimizer, 'min')

# Training loop
num_epochs = 10
for epoch in range(num_epochs):
model.train()
running_loss = 0.0
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()

model.eval()
val_loss = 0.0
with torch.no_grad():
 for inputs, labels in val_loader:
outputs = model(inputs)
loss = criterion(outputs, labels)
val_loss += loss.item()

scheduler.step(val_loss)
print(f'Epoch {epoch+1}/{num_epochs}, Training Loss:
{running_loss/len(train_loader)}, Validation Loss: {val_loss/len(val_loader)}')

# Evaluate the model

model.eval()
all_preds = []
all_labels = []
with torch.no_grad():
for inputs, labels in val_loader:
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
all_preds.extend(preds.numpy())
all_labels.extend(labels.numpy())

# Confusion matrix and classification report

conf_matrix = confusion_matrix(all_labels, all_preds)
print('Confusion Matrix:')
print(conf_matrix)
class_report = classification_report(all_labels, all_preds)
print('Classification Report:')
print(class_report)
```

Explanation of the Code

1.Importing Libraries:
Import necessary libraries for data manipulation, visualization, and deep
learning using PyTorch.

2. Loading and Preprocessing Data:

Load the dataset using `ImageFolder` and apply transformations such as resizing
and converting images to tensors.
Split the dataset into training and validation sets.

3. Defining the Neural Network Architecture:

Define a simple Convolutional Neural Network (CNN) with two convolutional
layers, max-pooling layers, and fully connected layers.

4. Training the Model:

Define the loss function (`CrossEntropyLoss`) and optimizer (`Adam`).
Implement the training loop to train the model for a specified number of
epochs.
During each epoch, calculate the training loss and validation loss, and adjust the
learning rate based on the validation loss using a learning rate scheduler.
5. Evaluating the Model:
Evaluate the model on the validation set and compute performance metrics
such as the confusion matrix and classification report.

Flowchart

Below is a flowchart outlining the process of data preprocessing, model training,

and evaluation

This flowchart represents the logical sequence of steps from loading and
preprocessing the data to training and evaluating the machine learning model.
Each step corresponds to a section in the code, ensuring a clear and systematic
approach to developing the health monitoring and diagnosis system.

A[Start] --> B[Load and Preprocess Data]

B --> C[Split Data into Training and Validation Sets]
C --> D[Define Neural Network Architecture]
D --> E[Train the Model]
E --> F[Evaluate the Model]
F --> G[Compute Performance Metrics]
G --> H[End]
```