Foml Project 1
Uploaded by
madhu.amv10Foml Project 1
Uploaded by
madhu.amv10DISEASE PREDICTOR USING
DECISION TREE
A PROJECTREPORT
Submitted by
adhumitha M (221501072)
M
Menakaa V (221501077)
Nithya shree AK (221501090)
AI19442 FUNDAMENTALS OF MACHINE LEARNING
Department of Artificial Intelligence
and Machine Learning
Rajalakshmi Engineering College, Thandalam
BONAFIDE CERTIFICATE
This is to certify that the Mini project work titled “D
ISEASE PREDICTOR
USING DECISION TREE” done by , Madhumitha M-221501077(AIML)
,Menakaa V-221501077(AIML)Nithyashreeak-221501090(AIML)isarecord
ofbonafideworkcarriedoutbyhim/herundermysupervisionasapartofMINI
PROJECT for the subject titled AI19442 -F
UNDAMENTALS OF
MACHINE LEARNING by Department of Artificial Intelligence and
Machine Learning.
SIGNATURE SIGNATURE
Dr.Sekar K M.E., Ph.D, Mr.K.Gopinath M.E.,(Ph.D).,
HEAD OF THE DEPARTMENT FACULTY IN CHARGE
Department of Artificial Intelligence Department of Artificial
Intelligence and Machine Learning, and Machine Learning,
Rajalakshmi Engineering College, Rajalakshmi Engineering College,
Thandalam, Thandalam,
Chennai-602 105. Chennai- 602 105.
Submitted for the project viva-voce examination held on .
INTERNAL EXAMINER EXTERNAL EXAMINER
TABLE OF CONTENTS
S. No Chapter Page Number
1. ABSTRACT iv
2. INTRODUCTION 1
3. RELATED WORK 3
4. MODEL ARCHITECTURE 5
5. IMPLEMENTATION 6
6. RESULT 8
7. CONCLUSION 10
8. APPENDIX 11
9. REFERENCES 15
ABSTRACT
Ourprojectisadiseasepredictionsystemdesignedtodiagnoseillnessesbasedonaperson's
symptoms.Leveragingadvancedmachinelearningtechniques,themodelaccuratelypredicts
diseasesandprovidesuserswithrecommendedprecautions.Astandoutfeatureofoursystem
is itsabilitytovocalizethediagnosisandsuggestedprecautions,enhancinguserexperience
bymakingtheinformationmoreaccessibleandunderstandable.Thisaudiofeedbacksetsour
project apart, ensuring that users receive clear and immediate guidance. Our approach not
only guarantees high accuracy in disease prediction but also offers a user-friendly and
inclusive solution, particularly benefiting those with visual impairments or literacy
challenges. This innovative model represents a significant improvement over traditional
diagnosticmethods,providingbothprecisepredictionsandpracticaladvicetosupportusers
in managing their health.
CHAPTER 1
INTRODUCTION
TheDiseasepredictor projectisapioneeringPythonapplicationdesignedtorevolutionizethe
way users seek medical advice based on reported symptoms. In an era of technological
advancements, this project harnesses the power of machine learning to assist individuals in
identifying potential medical conditions promptly. The primary focus lies in utilizing two
robustmachinelearningmodels:theDecisionTreeClassifierandtheSupportVectorMachine
(SVM).Thesemodelsenablethediseasepredictortomakeaccuratepredictionsaboutpotential
diseases, provide information on those diseases, and suggest precautionary measures.
As part of this project, five datasets were employed, each serving a specific purpose. Two
datasets,namely"Data.csv"and"Dataset.csv,"provideessentialinformationaboutsymptoms,
diseases, and their corresponding features. The remaining three datasets, located in the
"MasterData" folder, include "Symptom_Description.csv," "Symptom_Precaution.csv," and
"Symptom_Severity.csv," which offer detailed insights into symptom descriptions,
precautionary measures, and symptom severity, respectively.
ThisreportdelvesintotheintricaciesoftheTalkBot.AI diseasepredictorproject,coveringits
machine learning models, data analysis, implementation details, and the integration of voice
interactionforanenhanceduserexperience.Thesubsequentsectionswillprovideanin-depth
explorationofthevariouscomponents,methodologies,andoutcomesachievedthroughoutthe
development of this innovative healthcare solution.
The integration of machine learning in healthcare has emerged as a transformative force,
revolutionizing various aspects of medical research, diagnosis, and patient care. The
importance of utilizing machine learning in the healthcare sector lies in its abilitytoharness
the vast amounts of data available, enabling more accurate predictions, personalized
treatments,andefficientdecision-making.Belowarekeyaspectshighlightingthesignificance
of machine learning in healthcare:
Predictive Analytics:
Machine learning algorithms can analyze large datasets to identify patterns and trends,
enabling the prediction of potential health issues and disease outcomes. Early detection of
diseases allows for timely intervention and improved patient outcomes.
Disease Identification and Diagnosis:
Machinelearningmodels,suchasdecisiontreesandsupportvectormachines,canbetrained
on medical data to assist in the identification and diagnosis of diseases based on symptoms.
Improved accuracy in disease identification enhances the efficiency of healthcare
professionals.
Personalized Medicine:
Machinelearningalgorithmsanalyzepatientdata,geneticinformation,andtreatmentoutcomes
to tailor medical treatments to individual patients.
Personalized medicine optimizes treatment plans, minimizing side effects and increasing
treatment efficacy.
The project utilizes twopowerfulmachinelearningmodels,theDecisionTreeClassifierand
Support Vector Machine (SVM), to predict potential diseases based on reported symptoms.
Each model has its strengthsandcharacteristicsthatcontributetotheaccuracyandreliability
of the ChatBot's predictions.
1. Decision Tree Classifier:
A Decision Tree is a tree-like model where each node represents a decision based on a
particular feature, and each branch represents the outcome of that decision. It is a versatile
algorithmusedforclassificationandregressiontasks.TheDecisionTreeClassifieristrainedon
the cleaned dataset(Dataset.csv)withsymptomsasfeaturesanddiseasesaslabels.Themodel
learns decision rules based on the input symptoms, creating a tree structure that facilitates
disease prediction.
Training Process:
Features: Symptoms reported by users.
Labels: Corresponding diseases.
Decision tree nodes are split based on symptom values to maximize information gain.
The model iteratively partitions the data until it forms leaf nodes representing predicted
diseases.Cross-validation is performed to evaluate the model's performance.
The average cross-validation score provides an indication of the model's predictive accuracy.
2. Support Vector Machine (SVM):
Support Vector Machine is a supervised learning algorithm thatclassifiesdatabyfindingthe
hyperplane that best separates different classes. It is effective for both linear and non-linear
classificationtasks.TheSVMmodelistrainedonthesamedataset,usingsymptomsasfeatures
and diseases as labels.SVM aims to find the optimal hyperplane that maximally separates
different diseases in the feature space.
· Training Process:
Features: Symptoms reported by users.
Labels: Corresponding diseases.
SVM identifies the hyperplane with the maximum margin between classes, ensuringoptimal
separation.
The SVM model is evaluated based on its accuracy in predicting diseases on the test set.
A high accuracy score indicates the model's effectiveness in disease classification.
CHAPTER 2
RELATED WORK
1) The author’s idea is tocreateamedicaldiseasepredictorusingArtificialIntelligencethat
candiagnosethediseaseandprovidebasicdetailsaboutthediseasebeforeconsultingadoctor.
This will help to reduce healthcare costs and improve accessibility to medical knowledge
through medical chatbot. The disease predictor are computer programs that use natural
languagetointeractwithusers.Thediseasepredictorstoresthedatainthedatabasetoidentify
the sentence keywords and to make a query decision and answer the question. Ranking and
sentence similarity calculation is performed using n-gram, TFIDF and cosine similarity. The
score will be obtained for each sentence from the given input sentence and more similar
sentences will be obtained for the query given.
2)TheauthorsuseNaturalLanguageProcessing(NLP)algorithm.Thesystemprovidestext-text
assistance to communicate with bot in a user friendly manner.The disease predictorprovides
medical suggestions that can cure the disease based onusersymptoms.Ifitisaseverehealth
problemtheuserwillbeadvisedtoconsultadoctorforabettertreatment.Thediseasepredictor
can also give you medical prescriptions for health problems.Along with the medicines,the
disease predictor also provide you with ayurvedic remedies and homeopathy treatments for
related health problems.
3)The authors proposed a disease predictor which is a software application where there is
interactionbetweenpatientsovertheinternet.Chatbotsareplayinganimportantroleintoday's
world by supporting andhelpingpatientswiththeirappropriateinformation.Proposedideais
to create a Medical disease predictor based on Artificial Intelligence using NLP. Through
chatbots one can communicate with text or voice interface and get reply back to the user.
Thesebotsconnectwithpotentialpatientsvisitingthesite,booksappointments,andalsohelp
getting proper treatment. These chatbots are available 24/7, comfortable, efficient, beneficial
and very friendly to use.
4)The author proposes a medical disease predictorcalled MedBot, which can give proper
advice on leading a healthy lifestyle. The basic idea is to construct a healthcare disease
predictor(MedBot) based on Artificial Intelligence and Natural Language Processing, which
can identify the illness and provide necessary information about it prior to consulting or
visiting a doctor, thereby making the MedBot more reachable and reducing healthcarecosts.
Some of these chatbots act as virtual medical assistants, teaching patients regarding their
sickness and motivating them to have better health. A text-to-text medical disease predictor
involves users in an online conversation about their medical issues and offers a range of
personalized diagnoses depending on the symptoms that have been presented. The MedBot
interacts with potential patients who come to the application
5)Thisdiseasepredictormaybeusedbyregularhumansinanysortofemergencycase,where
it can advise people on primary care before seeing a doctor, or it can sometimes work as a
doctorforsmallandshort-termhealthissuessuchasacold,headache,andsoon.Alongwith
this chatbot, there will be assistance for those in need whoseekimmediatesolutions.Auser
canidentifythetrueconditionbyreportingsymptomsofit.Thetruegoalofthisjobistowork
ontheuser'ssymptomsandmakemedicaladvicebasedontheminordertodecreasethetime
and expense associated with the procedure.
CHAPTER 3
MODEL ARCHITECTURE
· User Input:Users interact with the disease predictor by inputting their symptoms .
· Machine Learning Models: The project employs two machine learning models, the Decision
Tree Classifier and Support Vector Machine, for disease prediction based on symptoms.
· Disease Information:The disease predictoraccesses datasets containing disease descriptions to
provide comprehensive information about the predicted diseases.
· Precautionary Measures:Users receive personalized precautionary measures based on the
predicted disease, promoting preventive healthcare practices.
· Symptom Severity Assessment:Severity levels of reported symptoms are quantified using the
"Symptom_Severity.csv" dataset, educating users about the potential seriousness of their health
concerns.
· Description of the datasets used :The Disease predictor project relies on a set of five datasets
to facilitate accurate disease prediction, provide detailed information about diseases, and offer
personalized precautionary measures. Below is a comprehensive description of each dataset:
CHAPTER 4
IMPLEMENTATION
Disease disease predictor Implementation
The interaction with the user and the symptom input process in the Healthcare disease
predictor is handled by the tree_to_code function. This function prompts the user to input
symptoms,utilizestheDecisionTreeClassifiertomakepredictions,andprovidesinformation
on potential diseases, symptoms, and precautions.
Explanation:
· Symptom Input:
The user is prompted to input symptoms they are experiencing.
The input is processed, and if there is ambiguity or multiple matches, the user is asked to
choose the most relevant symptom.
· Number of Days Input:
The user is asked to input the number of days they have been experiencing the symptoms.
· Decision Tree Traversal:
The Decision Tree is traversed based on the user's input, and the symptoms are evaluated
against the tree's nodes.
· Secondary Prediction:
AsecondarypredictionismadeusingaDecisionTreebasedonthesymptomsprovidedbythe
user.
· Condition Calculation:
The severity of symptoms and the duration are used to calculate the condition and provide
appropriate recommendations.
· Result Presentation:
The predicted diseases, descriptions, and precautions are presented to the user.
The models in the provided code, namely the Decision Tree Classifier and Support Vector
Machine (SVM), predict diseases based on symptoms using a machine learning approach.
Decision Tree Prediction Process:
· Model Training:
During the training phase, the Decision Tree Classifier learns patterns and relationships
between symptoms and diseases from the provided dataset (Data/dataset.csv).
· Feature Importance:
TheDecisionTreeassignsimportancescorestoeachsymptom,indicatinghowinfluentialthey
are in predicting the target variable (diseases).
Features with higher importance scores are considered more critical in making predictions.
· User Interaction:
Whenauserinputssymptoms,thediseasepredictorusesthetrainedDecisionTreetotraverse
its nodes.
At each node, the model evaluates whethertheinputsymptomsmatchtheconditionsdefined
in the tree.
· Decision-Making Nodes:
Decision nodes in the tree compare the input symptoms to specific features (symptoms) and
make decisions based on their values.
For example, if the user reports a symptom like "headache," the DecisionTreemighthavea
node that checks if the input contains this symptom.
· Traversal and Prediction:
Thetraversalcontinuesuntilaleafnodeisreached.Eachleafnodecorrespondstoapredicted
disease or a set of possible diseases.
Themodelpredictsthediseaseassociatedwiththereachedleafnodeasthepotentialcondition
based on the reported symptoms.
· Secondary Prediction (Optional):
ThecodeincludesasecondarypredictionstepusinganotherDecisionTreebasedonsymptoms
provided by the user. This step refines the initial prediction.
· Output Presentation:
The model outputs the predicted disease(s), associated descriptions, and recommended
precautions to the user.
· Explanation of the text-to-speech functionality using pyttsx3 :
· Importing the Library:
This line imports the pyttsx3 library into the script, enabling access to its text-to-speech
capabilities.
· Initializing the Text-to-Speech Engine:
This line initializes the text-to-speech engine. The “init()” function returns a speech engine
instance that can be used to convert text to speech.
· Configuring the Engine Properties:
These lines configure properties ofthetext-to-speechengine.The'voice'propertyissettoan
English voice, and the 'rate' property adjusts the speech rate.
· Speaking Text:
The“say()”functionisusedtospecifythetextthattheengineshouldconverttospeech.Inthis
example, it speaks the prompt asking for the user's name. The “runAndWait()” function
ensures that the speech is delivered synchronously.
· Stopping the Engine:
This line stops the text-to-speech engine. It is useful when you want to interrupt the speech
output or when transitioning to a new speech prompt.
CHAPTER 5
RESULTS AND DISCUSSIONS
Challenges Faced
·Any challenges encountered during the developmentof the disease predictor:
· Domain-Specific Challenges:
Healthcare terminology and domain-specific nuances can be complex. Ensuring that the
disease predictor understands and communicates medical information accurately is crucial for
user trust.
· Generalization to Diverse Symptoms:
Ensuring that the model generalizes well to a diverse range of symptoms and conditions is
important for the chatbot's effectiveness. Overfitting to specific patterns in the training data
should be avoided.
· Solutions or workarounds implemented to overcome challenges :
· Domain-Specific Challenges:
Involve healthcare professionals in the development process to validate model outputs.
Implement continuous learning mechanisms to adapt to evolving medical knowledge.
· Generalization to Diverse Symptoms:
Ensure a diverse and representative dataset during model training.
Regularly update the dataset to include new information and emerging medical conditions.
CHAPTER 6
CONCLUSION AND FUTURE WORKS
Conclusion
In conclusion, the TalkBot.AI disease prediction project is a Python application designed to
assist users in identifying potential medical conditions based on reported symptoms. The
disease predictor utilizes machine learning techniques, specifically a Decision Tree Classifier
and Support Vector Machine (SVM), to make predictions. The project aims to provide users
with information on diseases, their descriptions, and suggested precautions.
Future Enhancements
· Ideas for improving the disease predictor:
Enhancing a healthcare disease prediction involves continuous improvement in various
aspects toprovideabetteruserexperienceandmoreaccurateassistance.Herearesomeideas
for future enhancements to the Healthcare ChatBot:
· Integration with Telemedicine Services:
Enablethediseasepredictortoseamlesslyintegratewithtelemedicineservices,allowingusers
to schedule virtual consultations with healthcare professionals based on the chatbot's
recommendations.
· Personalized Health Profiles:
Implement user profiles to track individual health history, symptoms, and recommendations
over time. This can enhance the chatbot's ability to provide personalized advice.
· Natural Language Understanding (NLU) Improvements:
Enhance the chatbot's NLU capabilities to better understand user queries, including
context-aware responses and the ability to handle more complex medical inquiries.
· Collaboration with Healthcare Professionals:
Establish partnerships with healthcare professionals to ensure the chatbot's recommendations
align with current medical practices and guidelines.
· User Authentication and Data Security:
Implement secure user authentication mechanisms to protect user health data and ensure
compliance with data protection regulations.
CHAPTER 7
APPENDIX
Appendix-1: CODE
import re
import pandas as pd
import pyttsx3
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
warnings.filterwarnings("ignore", category=DeprecationWarning)
d ata= pd.read_csv('Data/dataset.csv')
cols= data.columns
cols= cols[:-1]
x = data[cols]
y = data['prognosis']
y1= y
reduced_data = data.groupby(data['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)
c lf1 = DecisionTreeClassifier()
clf = clf1.fit(x_train,y_train)
# print(clf.score(x_train,y_train))
# print ("cross result========")
s cores = cross_val_score(clf, x_test, y_test, cv=3)
# print (scores)
print (scores.mean())
odel=SVC()
m
model.fit(x_train,y_train)
print("for svm: ")
print(model.score(x_test,y_test))
importances = clf.feature_importances_
indices = np.argsort(importances)[::-1]
features = cols
def readn(nstr):
engine = pyttsx3.init()
e ngine.setProperty('voice', "english+f5")
engine.setProperty('rate', 130)
e ngine.say(nstr)
engine.runAndWait()
engine.stop()
s everityDictionary=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('MasterData/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('MasterData/symptom_severity.csv') as csv_file:
c sv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
try:
for row in csv_reader:
_diction={row[0]:int(row[1])}
severityDictionary.update(_diction)
except:
pass
def getprecautionDict():
global precautionDictionary
with open('MasterData/symptom_precaution.csv') as csv_file:
c sv_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="->")
readn("Enter your name")
name=input("")
print("Hello, ",name)
readn("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('Data/dataset.csv')
X = df.iloc[:, :-1]
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)
s ymptoms_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
]
c hk_dis=",".join(feature_names).split(",")
symptoms_present = []
while True:
p rint("\n","Enter the symptom you are experiencing (if you can't explain just press Enter
and choice)"," \t\t",end="->")
readn("Enter the symptom you are experiencing (if you can't explain just press Enter and
choice)")
disease_input = input("")
conf,cnf_dis=check_pattern(chk_dis,disease_input)
if conf==1:
strn ="searches related to input: "
print(strn)
readn(strn)
for num,it in enumerate(cnf_dis):
print(num,")",it)
if num!=0:
strn = f"Select the one you meant (0 - {num}) if you have more then 1 symptom
choice the The most influential : "
print(strn, end="")
readn(strn)
conf_inp = int(input(""))
else:
conf_inp=0
d isease_input=cnf_dis[conf_inp]
break
# print("Did you mean: ",cnf_dis,"?(yes/no) :",end="")
# conf_inp = input("")
# if(conf_inp=="yes"):
# break
else:
strn = "Enter valid symptom."
print(strn)
readn(strn)
while True:
try:
num_days=int(input("Okay. From how many days ? : "))
readn("Okay. From how many days ? : ")
break
except:
strn = "Enter valid number of days."
print(strn)
readn(strn)
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:
v al = 1
else:
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)) )
strn = "Are you experiencing any "
print(strn)
readn(strn)
symptoms_exp=[]
for syms in list(symptoms_given):
inp=""
strn = syms+"? (yes or no) : "
print(strn,end='')
readn(strn)
while True:
inp=input("")
if(inp=="yes" or inp=="no"):
break
else:
strn = "provide proper answers i.e. (yes/no) : "
print(strn,end="")
readn(strn)
if(inp=="yes"):
symptoms_exp.append(syms)
s econd_prediction=sec_predict(symptoms_exp)
# print(second_prediction)
calc_condition(symptoms_exp,num_days)
if(present_disease[0]==second_prediction[0]):
strn = "You may have "+ present_disease[0]
readn(strn)
print(strn)
strn1 = description_list[present_disease[0]]
p rint(strn1)
readn(strn1)
# readn(f"You may have {present_disease[0]}")
# readn(f"{description_list[present_disease[0]]}")
else:
strn = "You may have "+ present_disease[0]+ "or "+ second_prediction[0]
print(strn)
readn(strn)
print(description_list[present_disease[0]])
readn(description_list[present_disease[0]])
print(description_list[second_prediction[0]])
readn(description_list[second_prediction[0]])
# print(description_list[present_disease[0]])
precution_list=precautionDictionary[present_disease[0]]
print("Take following measures : ")
readn("Take following measures : ")
for i,j in enumerate(precution_list):
print(i+1,")",j)
readn(str(i+1)+j)
# confidence_level = (1.0*len(symptoms_present))/len(symptoms_given)
# print("confidence level is " + str(confidence_level))
r ecurse(0, 1)
getSeverityDict()
getDescription()
getprecautionDict()
getInfo()
tree_to_code(clf,cols)
print("----------------------------------------------------------------------------------------")
CHAPTER 8
OUTPUT
CHAPTER 8
REFERENCES
[1] L.Athota,V.K.Shukla,N.PandeyandA.Rana,"diseasepredictorforHealthcareSystem
Using Artificial Intelligence," 2020 8th International Conference on Reliability, Infocom
TechnologiesandOptimization(TrendsandFutureDirections)(ICRITO),Noida,India,2020,
pp. 619-622, doi: 10.1109/ICRITO48877.2020.9197833. keywords: {Medical
services;Databases;Expert systems;Feature extraction;Medical diagnostic
imaging;Chatbot;Healthcare;Artificial Intelligence;Virtual Assistance;TFID;N-gram},
https://ieeexplore.ieee.org/document/9197833
[2] Ramalingam, Jegadeesan & Srinivas, Dava & Nagappan,Umapathi&Ganesan,Karthick
& Venkateswaran, Natesan. (2023). Section A-Research paper Personal Healthcare disease
predictorforMedicalSuggestionsUsingArtificialIntelligenceandMachineLearningEur.12.
6004-6012. 10.31838/ecb/2023.12.s3.670.
https://www.researchgate.net/publication/372658029_Section_A-Research_paper_Personal_H
ealthcare_Chatbot_for_Medical_Suggestions_Using_Artificial_Intelligence_and_Machine_Le
arning_Eur
[3] Shetty, Riddhi and Bhosale, Ankita and Verma, Pankaj and Phalke, Ashwini, AI Based
Healthcare disease predictor (April 8, 2022).Proceedingsofthe7thInternationalConference
on Innovations and Research in Technology and Engineering (ICIRTE-2022), organized by
VPPCOE & VA, Mumbai-22, INDIA, Available at SSRN:https://ssrn.com/abstract=4109100
orhttp://dx.doi.org/10.2139/ssrn.4109100
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4109100
[4] K. Anjum, M. Sameer and S. Kumar, "AI Enabled NLP based Text to Text Medical
Chatbot," 2023 3rd International Conference on Innovative Practices in Technology and
Management (ICIPTM), Uttar Pradesh, India, 2023, pp. 1-5, doi:
10.1109/ICIPTM57143.2023.10117966.
keywords: {Training;Machine learning algorithms;Hospitals;Machine
learning;Transforms;Oral communication;Chatbots},
https://ieeexplore.ieee.org/document/10117966
[5] DOI : 10.17577/ IJERTCONV10IS12016
https://www.ijert.org/design-implementation-of-healthcare-chatbot-using-artificial-intelligence
You might also like
- Integrated Disease Prediction Platform Using Machine Learning ModelsNo ratings yetIntegrated Disease Prediction Platform Using Machine Learning Models33 pages
- Summative Test in English For Academic and Professional Purposes (EAPP)100% (1)Summative Test in English For Academic and Professional Purposes (EAPP)2 pages
- Machine Learning and Its Applications in Healthcare: Date:5 06,2024No ratings yetMachine Learning and Its Applications in Healthcare: Date:5 06,202419 pages
- Disese Prediction Using Machine Learning by We4No ratings yetDisese Prediction Using Machine Learning by We412 pages
- Multiple Disease Prediction SystemsynopsisNo ratings yetMultiple Disease Prediction Systemsynopsis7 pages
- Symptom-Based_Disease_Prediction_A_Machine_LearninNo ratings yetSymptom-Based_Disease_Prediction_A_Machine_Learnin10 pages
- Predictive_Analytics_and_Personalized_Health_Monitoring_Powered_by_Machine_LearningNo ratings yetPredictive_Analytics_and_Personalized_Health_Monitoring_Powered_by_Machine_Learning6 pages
- Patient Mortality Prediction Using Machine Learning and ArtificialNo ratings yetPatient Mortality Prediction Using Machine Learning and Artificial7 pages
- Words On Trial - Can Linguists Solve Crimes100% (2)Words On Trial - Can Linguists Solve Crimes29 pages
- Image Quality Enhancement Using Pixel-Wise Gamma CorrectionNo ratings yetImage Quality Enhancement Using Pixel-Wise Gamma Correction7 pages
- PREDICTION OF DISEASES USING MACHINE LEARNING SemiNo ratings yetPREDICTION OF DISEASES USING MACHINE LEARNING Semi12 pages
- The Prester John Of The Indies A True Relation Of The Lands Of The Prester John Being The Narrative Of The Portuguese Embassy To Ethiopia In 1520 Volume I G W B Huntingford pdf downloadNo ratings yetThe Prester John Of The Indies A True Relation Of The Lands Of The Prester John Being The Narrative Of The Portuguese Embassy To Ethiopia In 1520 Volume I G W B Huntingford pdf download89 pages
- The Significance of Machine Learning in Clinical Disease Diagnosis: A ReviewNo ratings yetThe Significance of Machine Learning in Clinical Disease Diagnosis: A Review8 pages
- Connectivity Guide For IBM InfoSphere Classic Federation Server For z/OSNo ratings yetConnectivity Guide For IBM InfoSphere Classic Federation Server For z/OS70 pages
- Deepika_Disease Prediction Using Machine LearningNo ratings yetDeepika_Disease Prediction Using Machine Learning3 pages
- Unlocking Healthcare Insights: Disease Prediction With Machine LearningNo ratings yetUnlocking Healthcare Insights: Disease Prediction With Machine Learning6 pages
- Content and Pedagogy Mother Tongue (M-Mtb-Mle 311) : TopicNo ratings yetContent and Pedagogy Mother Tongue (M-Mtb-Mle 311) : Topic5 pages
- Project Synopsis - Machine Learning in Disease PredictionNo ratings yetProject Synopsis - Machine Learning in Disease Prediction5 pages
- Peshitta New Testament: Id: 2:18101 Word: (QƏ Ām) Root: (QDM) Lexeme: (QDM) Conj: ParticleNo ratings yetPeshitta New Testament: Id: 2:18101 Word: (QƏ Ām) Root: (QDM) Lexeme: (QDM) Conj: Particle25 pages
- [IJCST-V13I2P2]:Seema Saroj, Sakshi Sahu, Sanjana Patel, Suraj SahuNo ratings yet[IJCST-V13I2P2]:Seema Saroj, Sakshi Sahu, Sanjana Patel, Suraj Sahu2 pages
- THE 123 - Introduction To Theology: Who Made Me?: Winter 2008No ratings yetTHE 123 - Introduction To Theology: Who Made Me?: Winter 20085 pages
- Introduction to Quantum Computing & Machine Learning Technologies: 1, #1From EverandIntroduction to Quantum Computing & Machine Learning Technologies: 1, #1No ratings yet