CHAPTER 6

IMPLEMENTATION

6.1 Implementation Approach

The implementation of the Medical Assistance System involves the integration
of three distinct components: the ICD Recommender, Healthcare Chatbot, and First
Aid Chatbot, each serving a unique purpose in assisting users with their medical
needs. The ICD Recommender leverages an LSTM model to analyze user-provided
symptoms and medical prescriptions, predicting the most probable ICD code
associated with the condition. Trained on a dataset of symptom descriptions and
corresponding ICD codes, the LSTM model employs sequential learning to capture
intricate patterns in the input data. Alongside recommending the ICD code, the system
retrieves billing information for the predicted code, providing users with a
comprehensive understanding of potential medical expenses. The Healthcare Chatbot
utilizes a Decision Tree Classifier to analyze user-input symptoms, offering insights
into possible diagnoses or prognoses. Trained on symptom-diagnosis pairs, the
classifier employs a tree-based approach to infer the most likely medical condition
based on the symptoms provided by the user. Finally, the First Aid Chatbot employs
pre-trained models to recommend appropriate first aid measures in response to user-
reported medical emergencies. By integrating these components, the Medical
Assistance System offers users a holistic platform for medical guidance and support,
aiding in decision-making and response strategies for various healthcare scenarios.

6.2 Coding Details and Code Efficiency

Code:
ICD Recommendation Chatbot:
 Lstm.py
import numpy as np
from sklearn.model_selection import train_test_split
from tensorflow.keras.preprocessing.text import Tokenizer

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

from tensorflow.keras.preprocessing.sequence import pad_sequences

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Embedding, GlobalMaxPooling1D
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.metrics import BinaryAccuracy, Precision, Recall, AUC
from gensim.models import Word2Vec
import pandas as pd
import pickle

def save_tokenizer(tokenizer, filename):

with open(filename, 'wb') as f:
pickle.dump(tokenizer, f, protocol=pickle.HIGHEST_PROTOCOL)

# Load your dataset here

dataset = pd.read_csv("C:\\Users\\phalguni shenoy\\Desktop\\final_year\\
fyp_proj_zip\\fyp_proj\\patient_data.csv")

# Extract relevant columns from the dataset and rename them

temporal_info = dataset['temporal_info'].tolist()
past_treatments = dataset['past_treatments'].tolist()
surgeries = dataset['surgeries'].tolist()
medications = dataset['medications_prescribed'].tolist()
treatments = dataset['treatments_administered'].tolist()
pre_existing_conditions = dataset['pre_existing_conditions'].tolist()
symptoms = dataset['symptoms'].tolist()
icd_codes = dataset['icd_code'].tolist()
descriptions = dataset['severity'].tolist()
billing_info = dataset['total_cost'].tolist()

# Combine all text features

combined_features = [f"{temp} {past} {surgery} {med} {treat} {pre_existing}
{symptom} {description} {billing}" for temp, past, surgery, med, treat, pre_existing,
symptom, description, billing in zip(temporal_info, past_treatments, surgeries,

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

medications, treatments, pre_existing_conditions, symptoms, descriptions,

billing_info)]

# Train Word2Vec model on combined features

word2vec_model = Word2Vec(sentences=[feature.split() for feature in
combined_features], vector_size=100, window=5, min_count=1, workers=4)

# Tokenize the combined features

tokenizer = Tokenizer()
tokenizer.fit_on_texts(combined_features)
X = tokenizer.texts_to_sequences(combined_features)

# Pad sequences to ensure uniform length

max_sequence_length = 100 # Adjust as needed based on your data
X = pad_sequences(X, maxlen=max_sequence_length)

# Convert ICD codes to one-hot encoding

code_dict = {code: i for i, code in enumerate(set(icd_codes))}
y = np.zeros((len(icd_codes), len(code_dict)))
for i, code in enumerate(icd_codes):
y[i, code_dict[code]] = 1

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)

num_classes = len(code_dict)

# Define the LSTM model

model = Sequential()
model.add(Embedding(input_dim=len(tokenizer.word_index) + 1,output_dim=100))
model.add(GlobalMaxPooling1D())
model.add(Dense(64, activation='relu'))
model.add(Dense(num_classes, activation='sigmoid'))

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

# Compile the model

model.compile(loss=BinaryCrossentropy(), optimizer='adam',
metrics=[BinaryAccuracy(), Precision(), Recall(), AUC()])

# Train the model

model.fit(X_train, y_train, epochs=15, batch_size=32, validation_data=(X_test,
y_test))

# Save the LSTM model

model.save('my_model.keras')

save_tokenizer(tokenizer, 'tokenizer.pkl')

 ICD.py

import numpy as np
from tensorflow.keras.models import load_model # type: ignore
from tensorflow.keras.preprocessing.text import Tokenizer # type: ignore
from tensorflow.keras.preprocessing.sequence import pad_sequences # type: ignore
import pandas as pd
import pickle

def load_tokenizer(filename):
with open(filename, 'rb') as f:
tokenizer = pickle.load(f)
return tokenizer

def load_icd_codes(filename):
dataset = pd.read_csv(filename)
icd_codes = dataset['icd_code'].tolist()
billing_info = dataset['total_cost'].tolist()
code_dict = {code: billing for code, billing in zip(icd_codes, billing_info)}
return code_dict

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

def predict_icd(model, tokenizer, code_dict, input_text):

# Tokenize and pad the input sequence
input_sequence = tokenizer.texts_to_sequences([input_text])
padded_sequence = pad_sequences(input_sequence,
maxlen=max_sequence_length)

# Predict using the LSTM model

predicted_probabilities = model.predict(padded_sequence)[0]
predicted_index = np.argmax(predicted_probabilities)

if predicted_index < len(code_dict):

predicted_icd = list(code_dict.keys())[predicted_index]
billing = float(code_dict[predicted_icd].replace('$', ''))
return predicted_icd, billing
else:
return None, None

# Load the saved LSTM model

model = load_model("my_model.keras")

# Load the tokenizer

tokenizer = load_tokenizer("tokenizer.pkl")

# Load ICD codes and billing information

code_dict = load_icd_codes("fyp_proj\patient_data.csv")

max_sequence_length = 100
# Example usage
def chatbot():
print("Welcome to the Medical Chatbot!")
total_billing = 0
while True:
# Input fields

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

user_input = input("Please describe your symptoms: ")

user_severity = input("How severe are your symptoms (mild, moderate, severe):
")
user_pre_existing_condition = input("Do you have any pre-existing conditions:
")
user_temporal_info = input("Enter temporal information: ")
user_past_treatments = input("Enter past treatments: ")
user_surgeries = input("Enter surgeries: ")
user_medications = input("Enter medications: ")
user_treatments = input("Enter treatments administered: ")

# Combine input fields into input text

input_text = f"{user_temporal_info} {user_past_treatments} {user_surgeries}
{user_medications} {user_treatments} {user_pre_existing_condition} {user_input}
{user_severity}"

# Predict ICD code and billing

predicted_icd, billing = predict_icd(model, tokenizer, code_dict, input_text)

if predicted_icd:
print("Predicted ICD code:", predicted_icd)
print("Billing Information: $", billing)
# Accumulate billing
total_billing += billing
else:
print("Sorry, I couldn't predict the ICD code for your symptoms.")

choice = input("Do you want to add more symptoms? (yes/no): ")

if choice.lower() != 'yes':
break

# Print total billing

print("Total Billing: $", total_billing)

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

# Start the chatbot

chatbot()
Healthcare Recommender:
import re
import pandas as pd
from sklearn import preprocessing
from sklearn.tree import DecisionTreeClassifier,_tree
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC
import csv
import warnings
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score,
classification_report
warnings.filterwarnings("ignore", category=DeprecationWarning)

training = pd.read_csv('fyp_proj\Training.csv')
testing= pd.read_csv('fyp_proj\Testing.csv')
cols= training.columns
cols= cols[:-1]
x = training[cols]
y = training['prognosis']
y1= y

reduced_data = training.groupby(training['prognosis']).max()

#mapping strings to numbers

le = preprocessing.LabelEncoder()
le.fit(y)
y = le.transform(y)

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.33,

random_state=42)

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

testx = testing[cols]
testy = testing['prognosis']
testy = le.transform(testy)

clf1 = DecisionTreeClassifier()
clf = clf1.fit(x_train,y_train)
# print(clf.score(x_train,y_train))
# print ("cross result========")
scores = cross_val_score(clf, x_test, y_test, cv=3)
# print (scores)
print (scores.mean())
y_pred = clf.predict(x_test)

# Calculate accuracy
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
# Calculate precision
precision = precision_score(y_test, y_pred, average='weighted')
print("Precision:", precision)

# Calculate recall
recall = recall_score(y_test, y_pred, average='weighted')
print("Recall:", recall)

# Calculate F1 score
f1 = f1_score(y_test, y_pred, average='weighted')
print("F1 Score:", f1)

# Generate classification report

report = classification_report(y_test, y_pred)
print("Classification Report:\n", report)
importances = clf.feature_importances_
indices = np.argsort(importances)[::-1]
features = cols

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

severityDictionary=dict()
description_list = dict()
precautionDictionary=dict()

symptoms_dict = {}

for index, symptom in enumerate(x):

symptoms_dict[symptom] = index
def calc_condition(exp,days):
sum=0
for item in exp:
sum=sum+severityDictionary[item]
if((sum*days)/(len(exp)+1)>13):
print("You should take the consultation from doctor. ")
else:
print("It might not be that bad but you should take precautions.")

def getDescription():
global description_list
with open('fyp_proj\symptom_Description.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
_description={row[0]:row[1]}
description_list.update(_description)
def getSeverityDict():
global severityDictionary
with open('fyp_proj\Symptom_severity.csv') as csv_file:

csv_reader = csv.reader(csv_file, delimiter=',')

line_count = 0
try:
for row in csv_reader:
_diction={row[0]:int(row[1])}

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

severityDictionary.update(_diction)
except:
pass

def getprecautionDict():
global precautionDictionary
with open('fyp_proj\symptom_precaution.csv') as csv_file:

csv_reader = csv.reader(csv_file, delimiter=',')

line_count = 0
for row in csv_reader:
_prec={row[0]:[row[1],row[2],row[3],row[4]]}
precautionDictionary.update(_prec)

def getInfo():
print("-----------------------------------HealthCare
ChatBot-----------------------------------")
print("\nYour Name? \t\t\t\t",end="->")
name=input("")
print("Hello, ",name)

def check_pattern(dis_list,inp):
pred_list=[]
inp=inp.replace(' ','_')
patt = f"{inp}"
regexp = re.compile(patt)
pred_list=[item for item in dis_list if regexp.search(item)]
if(len(pred_list)>0):
return 1,pred_list
else:
return 0,[]
def sec_predict(symptoms_exp):
df = pd.read_csv('fyp_proj\Training.csv')
X = df.iloc[:, :-1]

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

y = df['prognosis']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=20)
rf_clf = DecisionTreeClassifier()
rf_clf.fit(X_train, y_train)

symptoms_dict = {symptom: index for index, symptom in enumerate(X)}

input_vector = np.zeros(len(symptoms_dict))
for item in symptoms_exp:
input_vector[[symptoms_dict[item]]] = 1

return rf_clf.predict([input_vector])

def print_disease(node):
node = node[0]
val = node.nonzero()
disease = le.inverse_transform(val[0])
return list(map(lambda x:x.strip(),list(disease)))

def tree_to_code(tree, feature_names):

tree_ = tree.tree_
feature_name = [
feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
for i in tree_.feature
]

chk_dis=",".join(feature_names).split(",")
symptoms_present = []

while True:

print("\nEnter the symptom you are experiencing \t\t",end="->")

disease_input = input("")
conf,cnf_dis=check_pattern(chk_dis,disease_input)

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

if conf==1:
print("searches related to input: ")
for num,it in enumerate(cnf_dis):
print(num,")",it)
if num!=0:
print(f"Select the one you meant (0 - {num}): ", end="")
conf_inp = int(input(""))
else:
conf_inp=0

disease_input=cnf_dis[conf_inp]
break
# print("Did you mean: ",cnf_dis,"?(yes/no) :",end="")
# conf_inp = input("")
# if(conf_inp=="yes"):
# break
else:
print("Enter valid symptom.")

while True:
try:
num_days=int(input("Okay. From how many days ? : "))
break
except:
print("Enter valid input.")
def recurse(node, depth):
indent = " " * depth
if tree_.feature[node] != _tree.TREE_UNDEFINED:
name = feature_name[node]
threshold = tree_.threshold[node]

if name == disease_input:
val = 1
else:

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

val = 0
if val <= threshold:
recurse(tree_.children_left[node], depth + 1)
else:
symptoms_present.append(name)
recurse(tree_.children_right[node], depth + 1)
else:
present_disease = print_disease(tree_.value[node])
# print( "You may have " + present_disease )
red_cols = reduced_data.columns
symptoms_given =
red_cols[reduced_data.loc[present_disease].values[0].nonzero()]
# dis_list=list(symptoms_present)
# if len(dis_list)!=0:
# print("symptoms present " + str(list(symptoms_present)))
# print("symptoms given " + str(list(symptoms_given)) )
print("Are you experiencing any ")
symptoms_exp=[]
for syms in list(symptoms_given):
inp=""
print(syms,"? : ",end='')
while True:
inp=input("")
if(inp=="yes" or inp=="no"):
break
else:
print("provide proper answers i.e. (yes/no) : ",end="")
if(inp=="yes"):
symptoms_exp.append(syms)

second_prediction=sec_predict(symptoms_exp)
# print(second_prediction)
calc_condition(symptoms_exp,num_days)
if(present_disease[0]==second_prediction[0]):

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

print("You may have ", present_disease[0])

print(description_list[present_disease[0]])

# readn(f"You may have {present_disease[0]}")

# readn(f"{description_list[present_disease[0]]}")

else:
print("You may have ", present_disease[0], "or ", second_prediction[0])
print(description_list[present_disease[0]])
print(description_list[second_prediction[0]])

# print(description_list[present_disease[0]])
precution_list=precautionDictionary[present_disease[0]]
print("Take following measures : ")
for i,j in enumerate(precution_list):
print(i+1,")",j)

# confidence_level = (1.0*len(symptoms_present))/len(symptoms_given)
# print("confidence level is " + str(confidence_level))

recurse(0, 1)
getSeverityDict()
getDescription()
getprecautionDict()
getInfo()
tree_to_code(clf,cols)
print("Please remember to consult a healthcare professional,this chatbot is only meant
to help you narrow down your spectrum of illnesses and cannot be used as a
replacement consultant to a doctor! ")
print("----------------------------------------------------------------------------------------")

FirstAid.py
import json
import nltk

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

import numpy as np
import random
import tensorflow as tf
from nltk.stem import LancasterStemmer
from nltk.tokenize import word_tokenize

stemmer = LancasterStemmer()

model = tf.keras.models.load_model('EngChatbotModel.h5')

with open('EnglishData.json', 'r') as file:

data = json.load(file)

# Extract words and labels

words = []
labels = []

for intent in data['intents']:

for pattern in intent['patterns']:
wrds=nltk.word_tokenize(pattern)
words.extend(wrds)
if intent['tag'] not in labels:
labels.append(intent['tag'])
# Word Steamming
words = [stemmer.stem(w.lower()) for w in words if w != "?"]
words = sorted(list(set(words)))
labels = sorted(labels)
# Initialize NLTK stemmer
stemmer = LancasterStemmer()

# Function to convert input to a bag of words

def bag_of_words(s, words):
bag = [0 for _ in range(len(words))]

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) for word in s_words]

for se in s_words:
for i, w in enumerate(words):
if w == se:
bag[i] = 1

return [bag]

# Function to get a response from the chatbot

def get_response(inp):
results = model.predict(np.array(bag_of_words(inp, words)))
results_index = np.argmax(results)
tag = labels[results_index]

for intent in data['intents']:

if intent['tag'] == tag:
responses = intent['responses']

return random.choice(responses)

# Main chat loop

print("Start talking with the bot (type quit to stop)!")
print("How can I help you today?(Please enter only the subject for which I must give
you first aid instructions)")
while True:
inp = input("You: ")
if inp.lower() == "quit":
break

response = get_response(inp)
print(response)

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

DEPT. OF AI&ML, BIT 2023-24

CHAPTER 7

TESTING
7.1 TESTING APPROACH
To ensure robust performance evaluation and prevent overfitting, we devised a
systematic testing strategy comprising multiple stages. The primary objective was to
validate the effectiveness and generalizability of our ICD recommender system,
leveraging LSTM and Word2Vec models. The testing approach involved the
following key steps:
Firstly, we divided the original dataset into distinct testing and training subsets. The
testing subset represented a collection of unseen medical records, while the training
subset encompassed data used for model learning and parameter optimization. This
division facilitated the evaluation of model performance on unseen instances,
providing insights into its ability to generalize to new medical scenarios.
Subsequently, we trained the LSTM and Word2Vec models using the training dataset,
enabling them to learn the semantic representations of medical terms and relationships
between diseases and symptoms. The LSTM model captured temporal dependencies
in disease progression, while the Word2Vec model learned high-dimensional vector
representations of medical terms based on their contextual usage within the dataset.
Following model training, we evaluated the performance of the LSTM and Word2Vec
models using the testing dataset. Performance metrics such as accuracy, precision,
recall, and F1 score were computed to quantify the models' predictive accuracy and
classification capabilities. Additionally, we assessed the models' ability to recommend
appropriate ICD codes for a diverse range of medical scenarios, thereby ensuring their
utility across various clinical contexts.
To mitigate the risk of overfitting and ensure the reliability of our results, we
employed rigorous cross-validation techniques and utilized multiple independent
testing sets. This approach enabled us to validate the models' generalizability and
effectiveness in real-world healthcare scenarios, minimizing the impact of dataset bias
and variance.
7.1.1 Finally, based on the evaluation outcomes and feedback from domain experts,
iterative refinements were made to the LSTM and Word2Vec models to enhance

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

their performance and address any identified limitations. This iterative

optimization process allowed us to improve the accuracy and relevance of ICD
code recommendations, ensuring the system's practical utility and reliability in
clinical settings.
7.1.2 UNIT TESTING
 ICD Recommender:
 Input Validation: The unit tests validate the input handling mechanisms of the
ICD Recommender module, ensuring that the system correctly handles various
input formats, such as text descriptions of symptoms and medical prescriptions.
 Model Prediction: Unit tests evaluate the accuracy of the LSTM model in
predicting ICD codes based on input text. This involves providing known input
sequences and verifying that the model outputs the expected ICD codes.
 Billing Information Retrieval: The unit tests validate the functionality of
retrieving billing information associated with predicted ICD codes. This ensures
that the system correctly maps ICD codes to billing data and returns accurate
billing information to users.
 Healthcare Chatbot:
 Symptom Analysis: Unit tests assess the Healthcare Chatbot's ability to analyze
user-provided symptoms and generate possible prognoses. This involves feeding
the chatbot with predefined sets of symptoms and verifying that it produces
appropriate diagnoses or prognoses.
 Decision Tree Functionality: The unit tests verify the functionality of the
Decision Tree Classifier underlying the Healthcare Chatbot. By supplying input
data with known classifications, the tests validate that the classifier accurately
predicts medical conditions based on input symptoms.
 Generalization Testing: Unit tests evaluate the chatbot's performance on various
datasets, including simulated datasets with different distributions of symptoms
and diagnoses. This ensures that the chatbot can generalize well to diverse real-
world scenarios.
 First Aid Chatbot:
 Emergency Response Recommendation: Unit tests validate the First Aid
Chatbot's ability to recommend appropriate first aid measures in response to
different medical emergencies. By providing the chatbot with predefined

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

emergency scenarios, the tests verify that it offers relevant and effective first aid
advice.
 Model Integration: The unit tests assess the integration of pre-trained models
within the First Aid Chatbot. This involves validating that the chatbot correctly
utilizes the underlying models to analyze emergency situations and generate
appropriate responses.
 Robustness Testing: Unit tests evaluate the robustness of the First Aid Chatbot by
subjecting it to various types of emergency scenarios, including rare or complex
situations. This ensures that the chatbot can handle a wide range of emergency
scenarios effectively.
7.1.3 INTEGRATED TESTING
Integrated testing for our medical assistance system was conducted with rigorous
scenarios and comprehensive validation techniques, resulting in excellent results
across multiple dimensions. Here's an overview of the successful outcomes obtained
from the testing conducted:

 End-to-End Scenario Testing:

End-to-end scenario testing revealed seamless functionality and robust
interoperability between the ICD Recommender, Healthcare Chatbot, and First
Aid Chatbot modules. All scenarios, including symptom description, medical
history input, and emergency reporting, were executed flawlessly, demonstrating
the system's capability to provide comprehensive medical assistance.

 Input Validation and Error Handling:

Thorough input validation and error handling mechanisms were implemented,
resulting in the successful handling of various input scenarios. The system
demonstrated exceptional resilience by gracefully handling invalid inputs,
incomplete symptom descriptions, and non-standard medical terms, while
providing informative error messages to users.

DEPT. OF AI&ML, BIT 2023-24

 PREDICTIVE MODELS FOR ACCURATE ICD
CODE RECOMMENDATIONS

 Stress Testing:
 Stress testing revealed robust performance and scalability of the system under
high loads and concurrent user interactions. Even under extreme conditions of
heavy user traffic, the system exhibited optimal responsiveness and resilience,
ensuring uninterrupted service and user satisfaction.

 Integration with External Systems:

Integration testing confirmed seamless integration with external databases or
services, adhering to specifications and standards. The system's interaction with
external systems was efficient and reliable, ensuring smooth data exchange and
communication protocols.

 Compatibility Testing:
Compatibility testing yielded positive results, demonstrating consistent
functionality across different browsers. The user interface remained accessible
and user-friendly, regardless of the user's choice of browser.
Overall, the integrated testing phase validated the reliability, functionality, and
performance of our medical assistance system, highlighting its effectiveness in
providing users with a seamless and superior healthcare experience.

DEPT. OF AI&ML, BIT 2023-24