AI HEALTH CARE BOT SYSTEM USING

PYTHON
A project report submitted in partial fulfilment of the requirement for the
award of Degree of B. Tech

COMPUTER SCIENCE ENGINEERING

Submitted by,
MEENA LOCHARLA - 20NT5A0555
M. ARAVIND - 20NT1A0557
D.SAGAR SUMANTH - 21NT5A0504
M.MANISH KUMAR - 21NT5A0549

Under the guidance of,

K. Vijay
Assistant Professor

VISAKHA INSTITUTE OF ENGINEERING AND

TECHNOLOGY
(Approved by AICTE NEW DELHI, Affiliated to JNTU-VIZIANAGARAM)
57TH Division, Narava, GVMC, Visakhapatnam-530027 A P

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

 VISAKHA INSTITUTE OF ENGINEERING AND TECHNOLOGY

CERTIFICATE

This is to certify that this project report is a bonafide work of, Meena Locharla
(20NT5A0555),M.Aravind (20NT1A0557), M.Manish Kumar (21NT5A0549),
D.Sagar sumanth (21NT5A0504) who have done the project which entitled
“AI HEALTH CARE BOT SYSTEM USING PYTHON ”

Internal guide Head of the department

K.VIJAY MTech ASN TEJASWINI KONE PhD
Assistant Professor Associate professor
Dept. of CSE Dept. of CSE
VIET VIET

EXTERNAL EXAMINAR
 DECLARATION

We hereby declare that the project report entitled “AI HEALTH

CARE BOT SYSTEM USING PYTHON ” is an original work done in the
Department of Computer Science and Engineering, Visakha Institute of
Engineering and Technology, Visakhapatnam, submitted in partial fulfillment
of the requirements for the award of the degree of BTech in Computer Science
and Engineering.

MEENA LOCHARLA - 20NT5A0555

M. ARAVIND -
20NT1A0557
D.SAGAR SUMANTH -
21NT5A0504
M.MANISH KUMAR -
21NT5A0549
 ACKNOWLEDGEMENT

It gives me immense pleasure to acknowledge all those who helped me

throughout in making project of great success.

With profound gratitude I thank Dr. G. VIDYA PRADEEP VARMA,

MTech, PhD, Principal Sir, Visakha Institute of Engineering and Technology,
for his timely suggestions which helped me to complete this project work
successfully.

Our sincere thanks and deep sense of gratitude to ASN TEJASWINI

KONE, Mam, Head of the Department CSE, for her valuable guidance,
in completion of this project successfully.

I also thank our guide K.VIJAY sir, for her guidance, in completion of
this project successfully.

I am thankful to both Teaching and Non-Teaching staff of CSE department

for their kind cooperation and all sorts of help bringing out this project
work successfully.

With Gratitude,
MEENA LOCHARLA - (20NT5A0555)
 M.ARAVIND - (20NT1A0557)
D.SAGAR SUMANTH - (21NT5A0504)
M.MANISH KUMAR -
(21NT1A0549)

ABSTRACT

Today in the present era, the major challenges that India as a country is facing
are to cater good quality and affordable healthcare services to its growing
population and at the same time, they are not cost-efficient. This inaccessibility
of healthcare facilities especially in rural areas and the difficulty in accessing
means of transport causes patients to postpone their treatment, or option for
medical facilities which is closer but at the same time are not cost-efficient and
well-matched to their medical needs.

To tackle the above-mentioned problem, we have introduced an AI Healthcare

Bot system. Our python-based system connects patients with the chatbot that
will help them give the correct answers and precautions to their questions. It is
developed with the aim to provide helpful information instantly, especially in
times when every second is important. The system will also help the users find
doctors, clinics, and hospitals nearby their location in emergencies.

Our python-based project comprises 2 modules: User and Admin. The user will
need to register first to access the system. They can log in using their
credentials after registering successfully. They can manage their profile and
change the password if they want. The users can chat with the bot and resolve
their health-related queries. They can also view doctors and their clinics near
their location using Google places API. The users can also view hospitals
nearby their location.
The admin can log in directly using their credentials to access the system. They
can manage the question and answers and will require to train the model. They
can also view the details of registered users.

We have created our own dataset to implement this system. Also, the CNN
algorithm is used to develop this system. The accuracy of general disease risk
prediction of CNN is higher as compared to other algorithms.

INDEX
CHAPTER NO TITLE PAGE.NO

1 INTRODUCTION

1.1 OUTLINE OF THE PROJECT 10

1.2 SOFTWARE REQUIREMENTS 10
1.2.1 PROGRAMMING LANGUAGE
1.2.2 PYTHON LIBRARIES& PACKAGES
1.2.3 ALGORITHM ARCHITECTURE
1.3 HARWARE REQUIREMENTS

2 LITERATURE REVIEW

2.1 MACHINE LEARNING

2.1.1 SOME MACHINE LEARNING METHODS

2.1.1.1 SUPERVISED MACHINE LEARNING ALGORITHM

2.1.1.2 UN-SUPERVISED MACHINE LEARNING ALGORITHM

2.1.1.3 SEMI SUPERVISED MACHINE LEARNING ALGORITHM

2.1.1.4REINFORCEMENT MACHINE LEARNING

2.2 DEEP LEARNING

2.2.1 HOW DOES DEEP LEARNING WORKS

 2.3 PYTHON

2.4PACKAGE INSTALLER

2.5TENSORFLOW

2.6KERAS

2.7NLP

2.8NLTK

2.9PICKLE

2.10NUMPY

3 METHODOLOGY

3.1 DATA SETS

3.1.1 JSON

3.1.2INTENTS

3.2 REQUIREMENTS

3.2.1 PROJECT SCOPE

3.2.2 EXISTING SCOPE

3.2.3 PROOPSED SYSTEM

3.2.4 FUNCTIONAL REQUIREMENTS

3.2.5 NON-FUNCTIONAL REQUREMENTS

3.3 DATA PROCESSING

3.4 MODELS

3.4.1 SEQUENTIAL MODEL

3.4.2 TENSOR FLOW

 3.4.3 RNN

3.4.4LSTM

3.5 EXPERINMENTAL SETUP

3.5.1 TRAIN DATASET

3.5.2 VALIDATION DATASET

3.5.3 TEST DATASET

3.6 PARAMETERS GIVEN TO MODEL FOR TRAINING

3.6.1 BATCH SIZE

3.6.2 EPOCHS

3.6.3 VERBOSE

3.6.4 VALIDATION SPLIT

4 TESTING

4.1 TYPES OF TESTING

4.2 TEST STRATEGY AND APPROACH

4.3 TEST CASES

5 RESULTS AND DISCUSSION

5.1 EVALUATION MATRIX AND RESULT

5.2 TRAINING AND TEST DATA

5.3 BUILDING THE MODEL

4.3.1 PREDICT THE RESPONSE

6 CONCLUSION AND FRAMEWORK

 6.1 CONCLUSION

6.2 FUTURE AND ENHANCEMENT

REFERENCE

APPENDIX

A.SOURCE CODE

B.SCREEN SHOTS

C.PUBLISHED WITH PLAGIARISM REPORT

LIST OF FIGURES

FIGURE NO. FIGURE NAME PAGE NO.

1. IMAGE OF CONVERSATIONAL LSTM

2. PROCESS DIAGRAM BETWEEN PATIENTS AND MEDIBOT

3. DESIGN FLOW DIAGRAM

4. SYSTEM ARCHITECTURE

5. PROCESSING STEPS FOR CHATBOT

6. ACCURACY
 7.

CHAPTER 1
INTRODUCTION:
1.1 Outlet of the Project:
This is an automated chat robot design to answer users frequently asked questions,
earlier natural language processing techniques were using to design this robot but
its accuracy of giving correct answer was less and now due to Deep Learning
algorithms accuracy of giving correct answer increase, so here using python deep
learning project we are building CHATBOT application to answer users questions.

To implement this technique first we train deep learning models with the train data
(all possible question’s answers) and whenever users give any question then
application will apply this test question on train model to predict exact answer for
given question.

Earlier companies were hiring humans to answer user’s queries but by using this
application we can answer user’s question without using any manpower.
Chabot can be described as software that can chat with people using artificial
intelligence. Chabot’s are generally used to respond quickly to users. Chabot’s, a
common name for automated conversational interfaces, present a new way for
individuals to interact with computer systems. Traditionally, to get a question
answered by a software program involves using a search engine or filling out a
form. A Chabot allows a user to simply ask questions in the same manner that they
would address a human. There are many well-known voice-based catboats
currently available in the market: Google Assistant, Alexa and Siri. Chabot’s are
currently being adopted at a high rate on computer chat platforms.

To implement this project, we are using python deep learning neural networks and
NLTK (natural Language Processing API) to process train and test text data.

1.2 Software Requirements

● Good Internet speed

● Java script enabled browser

1.2.1 Programming Language

Python

1.2.2 Python Libraries & Packages

● Tensor flow

● Keras

● NLTK

● Pickle

1.2.3 Algorithm – Architecture

RNN - LSTM (Deep Neural Networks)

1.3 Hardware Requirements

 RAM- minimum 4gb/Above

Processor- minimum

intel i5 core/Above

Windows- 7/Above

CHAPTER 2

LITERATURE SURVEY

In today’s world, health is the major key in the development of each sector. Health
also needs modern technology and their implementations in order to boost the
development in this area. As know that it is the most important field in each country,
need to provide sufficient technological development. A lot of researches have been
done in this field in order to modernize the methods of health status. Old methods of
diagnosing are still a major hindrance in the advancement of medical facilities. The
best way to overcome this problem is using a medical chatbot with self-diagnosis
using Artificial Intelligence.
The proposed method can use deep learning algorithms to increase the capabilities
of computers and by enhancing it can understand what humans can do, which
includes speech and text recognition. In this will use text-text in mediots to contact
the patients and teach the chatbots to process natural language text It discusses
about processing natural language using Recurrent Neural Network (RNN). The
sequence to sequence long short-term memory cell neural network (LSTM) is used
to train the model. In addition, it also talks about the challenges of implementing a
Recurrent Neural Network based chatbot. Disease diagnosis system using several
machine learning algorithms is proposed. A detailed comparison of four Machine
Learning algorithms to predict disease based on symptoms provided, is also
presented in this paper.

The purpose was to find the best Machine Learning algorithm to diagnose diseases
early to help doctors and patients, as early prediction of disease can improve
treatment efficiency. The chatbot will start questioning the patients regarding their
symptoms and problems they are suffering and suggest an effective method to
reduce the disease or give the medication according to the disease user suffering.
Deep learning is a subset of machine learning in artificial intelligence that has
networks capable of learning unsupervised from data that is unstructured or
unlabeled. Also known as deep neural learning or deep neural

network. Recurrent Neural Network (RNN) are a type of Neural Network where the
output from the previous step is fed as input to the current step. ... It uses the same
parameters for each input as it performs the same task on all the inputs or hidden
layers to produce the output [8]. In this can build algorithms to make the computer
automatically analyze the given data and also make it understand human language.
In this, mainly use text recognition using deep learning. Deep learning algorithms
are used to enhance the capability of a chatbot. The main focus of the review is to
implement medibot using both deep learning and neural networks.

2.1 Machine Learning

Machine learning is an application of artificial intelligence (AI) that provides systems
the ability to automatically learn and improve from experience without being
explicitly programmed. Machine learning focuses on the development of computer
programs that can access data and use it learn for themselves.

The process of learning begins with observations or data, such as examples, direct
experience, or instruction, in order to look for patterns in data and make better
decisions in the future based on the examples that we provide. The primary aim is
to allow the computers learn automatically without human intervention or assistance
and adjust actions accordingly.

2.1.1 Some machine learning methods

Machine learning algorithms are often categorized as supervised or unsupervised.

2.1.1.1 Supervised machine learning algorithm

Can apply what has been learned in the past to new data using labeled examples to
predict future events. Starting from the analysis of a known training dataset, the
learning algorithm produces an inferred function to make predictions about the
output values. The system can provide targets for any new input after sufficient
training. The learning algorithm can also compare its output with the correct,
intended output and find errors in order to modify the model accordingly.

2.1.1.2 Unsupervised machine learning algorithm

Are used when the information used to train is neither classified nor labeled.
Unsupervised learning studies how systems can infer a function to describe a
hidden structure from unlabeled data. The system does not figure out the right
output, but it explores the data and can draw inferences from datasets to describe
hidden structures from unlabeled data.

2.1.1.3 Semi-supervised machine learning algorithm

Fall somewhere in between supervised and unsupervised learning, since they use
both labeled and unlabeled data for training – typically a small amount of labeled
data and a large amount of unlabeled data. The systems that use this method can
considerably improve learning accuracy. Usually, semi-supervised learning is
chosen when the acquired labeled data requires skilled and relevant resources in
order to train it learn from it. Otherwise, acquiring unlabeled data generally does not
require additional resources.

2.1.1.4 Reinforcement machine learning algorithm

Is a learning method that interacts with its environment by producing actions and
discovers errors or rewards. Trial and error search and delayed reward are the most
relevant characteristics of reinforcement learning. This method allows machines and
software agents to automatically determine the ideal behavior within a specific
context in order to maximize its performance. Simple reward feedback is required
for the agent to learn which action is best; this is known as the reinforcement signal.
Machine learning enables analysis of massive quantities of data. While it generally
delivers faster, more accurate results in order to identify profitable opportunities or
dangerous risks, it may also require additional time and resources to train it
properly. Combining machine learning with AI and cognitive technologies can make
it even more effective in processing large volumes of information.

2.2 Deep Learning

Deep learning is an AI function that imitates the workings of the human brain in
processing data and creating patterns for use in decision making. Deep learning is a
subset of ML in artificial intelligence that has networks capable of learning
unsupervised from data that is unstructured or unlabelled. Also known as deep
neural learning or deep neural network.

● Deep learning is an AI function that mimics the workings of the human brain
in processing data for use in detecting objects, recognizing speech, translating
languages, and making decisions.

● Deep learning AI can learn without human supervision, drawing from data
that is both unstructured and unlabelled.
● Deep learning, a form of machine learning, can be used to help detect fraud
or money laundering, among other functions.

2.2.1 How Does Deep Learning Works

Deep learning has evolved together with the digital era, which has brought about an
explosion of data in all forms and from every region of the world. This data, known
simply as big data, is drawn from sources like social media, internet search engines,
e-commerce platforms, and online cinemas, among others. This enormous amount
of data is readily accessible and can be shared

through applications like cloud computing.

However, the data, which normally is unstructured, is so vast that it could take
decades for humans to comprehend it and extract relevant information.

Companies realize the incredible potential that can result from unravelling this
wealth of information and are increasingly adapting to AI systems for automated
support.

2.3 Python

Python is an easy to learn, powerful programming language. It has efficient high-

level data structures and a simple but effective approach to object-oriented
programming. Python’s elegant syntax and dynamic typing, together with its
interpreted nature, make it an ideal language for scripting and rapid application
development in many areas on most platforms.

The Python interpreter is easily extended with new functions and data types
implemented in C or C++ (or other languages callable from C). Python is also
suitable as an extension language for customizable applications.

2.4 Package Installer

PIP - pip is a command line application written in Python. PIP is a package

management system used to install and manage software packages written in

Python. It stands for “preferred installer program” or “Pip Installs Packages.” PIP for
Python is a utility to manage PyPI package installations from the command line.
Syntax: pip install tensorflow, keras, pickle, nltk

2.5 TensorFlow

It is an open-source artificial intelligence library, using data flow graphs to build

models. It allows developers to create large-scale neural networks with many
layers. TensorFlow is mainly used for: Classification, Perception, Understanding,
Discovering, Prediction and Creation. TensorFlow offers multiple levels of
abstraction so you can choose the right one for your needs. Build and train models
by using the high-level Keras API, which makes getting started with TensorFlow and
machine learning easy.

If you need more flexibility, eager execution allows for immediate iteration and
intuitive debugging. For large ML training tasks, use the Distribution Strategy API for
distributed training on different hardware configurations without changing the model
definition. TensorFlow has always provided a direct path to production. Whether it’s
on servers, edge devices, or the web, TensorFlow lets you train and deploy your
model easily, no matter what language or platform you use.

TensorFlow gives you the flexibility and control with features like the Keras
Functional API and Model Subclassing API for creation of complex topologies. For
easy prototyping and fast debugging, use eager execution.

2.6 Keras

Keras is a deep learning API written in Python, running on top of the machine
learning platform TensorFlow. It was developed with a focus on enabling fast
experimentation. Being able to go from idea to result as fast as possible is key to
doing good research.

Keras is a open-source software library that provides a Python interface for artificial
neural networks. Keras acts as an interface for the TensorFlow library.

Keras is the most used deep learning framework among top-5 winning teams

on Kaggle. Because Keras makes it easier to run new experiments, it empowers

you to try more ideas than your competition, faster.
Keras was created to be user friendly, modular, easy to extend, and to work with
Python. The API was “designed for human beings, not machines,” and “follows best
practices for reducing cognitive load. Keras is used by CERN, NASA, NIH, and
many more scientific organizations around the world (and yes, Keras is used at the
LHC). Keras has the low-level flexibility to implement arbitrary research ideas while
offering optional high-level convenience features to speed up experimentation
cycles.

2.7 Random forest regressor

Natural language processing strives to build machines that understand and respond
to text or voice data—and respond with text or speech of their own—in much the
same way humans do.

NLP drives computer programs that translate text from one language to another,
respond to spoken commands, and summarize large volumes of text rapidly—even
in real time. There is a good chance you have interacted with NLP

in the form of voice-operated GPS systems, digital assistants, speech-to-text

dictation software, customer service chatbots, and other consumer conveniences.
But NLP also plays a growing role in enterprise solutions that help streamline
business operations, increase employee productivity, and simplify mission-critical
business processes.

NLP Use Cases - Natural language processing is the driving force behind machine
intelligence in many modern real-world applications. Here are a few examples:

1. Virtual assistants and chat bots

2. Spam detection

3. Text summarization

4. Social media sentiment analysis

5. Machine translation
2.8 NLTK

NLTK is a leading platform for building Python programs to work with human
language data. NLTK includes libraries for many of the NLP tasks, plus libraries for
subtasks, such as sentence parsing, word segmentation, stemming and
lemmatization (methods of trimming words down to their roots), and tokenization
(for breaking phrases, sentences, paragraphs and passages into tokens that help
the computer better understand the text). It also includes libraries for implementing
capabilities such as semantic reasoning, the ability to reach logical conclusions
based on facts extracted from text.

NLTK has been called “a wonderful tool for teaching, and working in, computational
linguistics using Python,” and “an amazing library to play with natural language.”

The Python programming language provides a wide range of tools and libraries for
attacking specific NLP tasks. Many of these are found in the Natural Language
Toolkit, or NLTK, an open-source collection of libraries, programs, and education
resources for building NLP programs.

2.9 Pickle

The Pickle module implements binary protocols for serializing and de-serializing a
Python object structure. “Pickling” is the process whereby a Python object hierarchy
is converted into a byte stream, and “unpickling” is the inverse operation, whereby a
byte stream (from a binary file or bytes-like object) is converted back into an object
hierarchy. Pickling (and unpickling) is alternatively known as “serialization”.

The data format used by pickle is Python-specific. This has the advantage that there
are no restrictions imposed by external standards such as JSON or XDR (which
can’t represent pointer sharing); however, it means that non-Python programs may
not be able to reconstruct pickled Python objects.

By default, the pickle data format uses a relatively compact binary representation. If
you need optimal size characteristics, you can efficiently compress pickled data.
The module pickle tools contain tools for analysing data stream generated by
Pickle.
2.10 Numpy

NumPy is the fundamental package for scientific computing in Python. It is a Python

library that provides a multidimensional array object, various derived objects (such
as masked arrays and matrices), and an assortment of routines for fast operations
on arrays, including mathematical, logical, shape manipulation, sorting, selecting,
I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations,
random simulation and much more. At the core of the NumPy package, is the
ndarray object. This encapsulates n-dimensional arrays of homogeneous data
types, with many operations being performed in compiled code for performance.

NumPy fully supports an object-oriented approach, starting, once again,with

ndarray. For example, ndarray is a class, possessing numerous methods and
attributes. Many of its methods are mirrored by functions in the outer-most NumPy
namespace, allowing the programmer to code in whichever paradigm they prefer.

CHAPTER -3

METHODOLOGY:
3.1 DataSets:

A data set is a collection of data. In the case of tabular data, a data set corresponds
to one or more database tables, where every column of a table represents a
particular variable, and each row corresponds to a given record of the data set in
question. The data set lists values for each of the variables, such as the height and
weight of an object, for each member of the data set. Each value is known as a
datum. Data sets can also consist of a collection of documents or files.
3.1.1 JSON:

JSON is a text format for storing and transporting data. JSON is self-describing and
easy to understand.

● JSON stands for JavaScript Object Notation

● JSON is a lightweight data-interchange format.

● JSON is plain text written in JavaScript object notation.

● JSON is used to send data between computers.

● JSON is language independent.

Syntax – {“attribute1”:” Value1” , “attribute2” : “Value2” , ……}

Example - {"firstName": "Jason","lastName": "Jones",

"address": {

"city": "San Francisco, CA", "zip": 94121,

"address": "444 Columbus Ave"

},

Why JSON?

The JSON format is syntactically similar to the code for creating JavaScript objects.
Because of this, a JavaScript program can easily convert JSON data into JavaScript
objects.

Since the format is text only, JSON data can easily be sent between computers,
and used by any programming language.
3.1.2 Intents:

Local Data Storage (No External Data Set required) File Format: JSON

The dataset we will be using is ‘intents.json’. This is a JSON file that contains the
patterns we need to find and the responses we want to return to the user.

3.2 Requirements:

This chapter provides the details of the project’s need-based survey, system
requirements, Hardware Requirements, Software Requirements, and System
Requirements.

3.2.1 Project Scope:

• This is an automated chat robot design to answer users frequently asked

questions, earlier natural language processing techniques were using to design this
robot but its accuracy of giving correct answer was less and now due to Deep
Learning algorithms accuracy of giving correct answer increase, so here using
python deep learning project we are building CHATBOT application to answer users
questions.

• To implement this technique first we train deep learning models with the train
data (all possible questions’ answers) and whenever users give any question then
application will apply this test question on train model to predict exact answer for
given question.

3.2.2 Existing System:

Before exploring new technology, one should examine prior work and learn from
past ideas, both succeed and failed attempts. This section presents a selection of
events from the last century, which introduced the ideas that formed the present
definition of a Chabot. It is not an attempt to give an all-encompassing overview
about the history of computing, instead the aim is to explain where the concept of
chat bots and the interest of creating them originated.
Draw backs of Existing System:

• No proper support

• Communication overhead

• High risk

• More Manpower

3.2.3 Propsed System:

Chatbot can be described as software that can chat with people using artificial
intelligence. Chatbots are generally used to respond quickly to users. Chatbots, a
common name for automated conversational interfaces, present a new way for
individuals to interact with computer systems. Traditionally, to get a question
answered by a software program involves using a search engine or filling out a
form. A chatbot allows a user to simply ask questions in the same manner that they
would address a human. There are many well-known voice-based chatbots
currently available in the market: Google Assistant, Alexa and Siri. Chatbots are
currently being adopted at a high rate on computer chat platforms. A chatbot can be
used anywhere a human is interacting with a computer system. These are the areas
where the fastest adoption is occurring.

Advantages: -

• Offers 24/7 Service

• Enhances User Experience

• Cost Efficient

3.2.4 Functional requirements:

In software engineering, a functional requirement defines a system or its

component. It describes the functions a software must perform. A function is nothing
but inputs, its behaviour, and outputs. It can be a calculation, data manipulation,
business process, user interaction, or any other specific functionality which defines
what function a system is likely to perform. Functional software requirements help
you to capture the intended behaviour of the system. This behaviour may be
expressed as functions, services or tasks or which system is required to perform.

3.2.5 non-Functional requirements:

A non-functional requirement defines the quality attribute of a software system.

They represent a set of standards used to judge the specific operation of a system.
Example, how fast does the website load? A non-functional requirement is essential
to ensure the usability and effectiveness of the entire software system. Failing to
meet non-functional requirements can result in systems that fail to satisfy user
needs.

3.3 Data Processing:

When working with text data, we need to perform various pre-processing on the
data before we make a machine learning or a deep learning model. Based on the
requirements we need to apply various operations to pre-process the
data.Tokenizing is the most basic and first thing you can do on text data. Tokenizing
is the process of breaking the whole text into small parts like words.

Here we iterate through the patterns and tokenize the sentence using
nltk.word_tokenize() function and append each word in the words list. We also
create a list of classes for our tags.

for intent in intents['intents']:

for pattern in intent['patterns']:

#tokenize each word

w = nltk.word_tokenize(pattern) words.extend(w)

#add documents in the corpus documents.append((w, intent['tag'])) # add to our

classes list

if intent['tag'] not in classes: classes.append(intent['tag'])

Now we will lemmatize each word and remove duplicate words from the list.
Lemmatizing is the process of converting a word into its lemma form and then
creating a pickle file to store the Python objects which we will use while predicting.

# lemmatize, lower each word and remove duplicates

words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]

words = sorted(list(set(words)))

# sort classes

classes = sorted(list(set(classes)))

# documents = combination between patterns and intents print (len(documents),

"documents")

# classes = intents

print (len(classes), "classes", classes) # words = all words, vocabulary

print (len(words), "unique lemmatized words", words)

pickle.dump(classes,open('classes.pkl','wb'))

3.4 Models:

3.4.1 Sequential Model:

The core idea of Sequential model is simply arranging the Keras layers in a
sequential order and so, it is called Sequential model. Most of the ANN also has
layers in sequential order and the data flows from one layer to another layer in the
given order until the data finally reaches the output layer.

A Sequential model is appropriate for a plain stack of layers where each layer has
exactly one input tensor and one output tensor.

A Sequential model is not appropriate when:

❖ Model has multiple inputs or multiple outputs.

❖ Any of the layers has multiple inputs or multiple outputs.

❖ If need to do layer sharing.

❖ If there is a need of non-linear topology (e.g., a residual connection, a multi-

branch model).

In this project there are 3 layers, first layer 128 neurons, second layer 64 neurons
and 3rd output layer contain number of neurons equal to number of intents to
predict output intent with SoftMax.

We have used the following layers –

3.4.2 dense layer:

Dense layer is the regular deeply connected neural network layer. It is most
common and frequently used layer. Dense layer does the below operation on the
input and return the output.

output = activation (dot(input, kernel) + bias) where,

● input represent the input data.

● kernel represent the weight data.

● dot represent NumPy dot product of all input and its corresponding weights

● bias represent a biased value used in machine learning to optimize the

model.

● activation represent the activation function.

Dropout - Dropout is a technique used to prevent a model from overfitting
(Overfitting occurs when a model tries to predict a trend in data that is too noisy.
This is the caused due to an overly complex model with too many parameters. A
model that is overfitted is inaccurate because the trend does not reflect the reality
present in the data.). Dropout works by randomly setting the outgoing edges of
hidden units (neurons that make up hidden layers) to 0 at each update of the
training phase.

Activation Function - An activation function is a very important feature of an artificial

neural network, they basically decide whether the neuron should be activated or
not. In artificial neural networks, the activation function defines the output of that
node given an input or set of inputs.

In the first layer we have used Relu function (ReLu is a non-linear activation
function that is used in multi-layer neural networks or deep neural networks), and in
the third layer we have used Softmax function (function that converts a vector of
numbers into a vector of probabilities, where the probabilities of each value are
proportional to the relative scale of each value in the vector.).

3.4.3 RNN:

Recurrent neural networks are the state-of-the-art algorithm for

sequential data and are used by Apple's Siri and and Google's voice search. It is
the first algorithm that remembers its input, due to an internal memory, which makes
it perfectly suited for machine learning problems that involve sequential data.
Recurrent Neural Networks (RNN) are a class of Artificial Neural Networks that can
process a sequence of inputs in deep learning and retain its state while processing
the next sequence of inputs. Recurrent Neural Networks (RNN) are a type of Neural
Network where the output from the previous step is fed as input to the current step.
Recurrent Neural Network is a generalization of feedforward neural network that
has an internal memory. RNN is recurrent in nature as it performs the same function
for every input of data while the output of the current input depends on the past one
computation. After producing the output, it is copied and sent back into the recurrent
network. For making a decision, it considers the current input and the output that it
has learned from the previous input.
Recurrent Neural Network (RNN) are a type of Neural Network where the output
from previous step is fed as input to the current step. In traditional neural networks,
all the inputs and outputs are independent of each other, but in cases like when it is
required to predict the next word of a sentence, the previous words are required and
hence there is a need to remember the previous words. Thus, RNN came into
existence, which solved this issue with the help of a Hidden Layer. The main and
most important feature of RNN is Hidden state, which remembers some information
about a sequence.

Advantages:

● Possibility of processing input of any length.

● Model size not increasing with size of input.

● Computation considers historical information.

● Weights are shared across time.

3.4.4 LSTM:

LSTM stands for Long-Short Term Memory. LSTM is an advanced version of

recurrent neural network (RNN) architecture that was designed to model
chronological sequences and their long-range dependencies more precisely than
conventional RNNs.

The major highlights include the interior design of a basic LSTM cell, the variations
brought into the LSTM architecture and few applications of LSTMs that are highly in
demand.

RNN is a network that works on the present input by taking into consideration the
previous output (feedback) and storing in its memory for a short period of time
(short-term memory). Nevertheless, there are drawbacks to RNNs.

First, it fails to store information for a longer period of time. At times, a reference to
certain information stored quite a long time ago is required to predict the current
output. But RNNs are absolutely incapable of handling such “long-term
dependencies”.

Second, there is no finer control over which part of the context needs to be carried
forward and how much of the past needs to be ‘forgotten’.

Other issues with RNNs are exploding and vanishing gradients which occur during
the training process of a network through backtracking. Thus, LSTM was brought
into the picture. It has been designed that the vanishing gradient problem is almost
completely removed, while the training model is left unaltered.

During the training process of a network, the main goal is to minimize loss (in terms
of error or cost). We calculate the gradient i.e., loss with respect to a particular set
of weights. Adjust the weights accordingly and repeat this process until the optimal
set of weights for which the loss is minimum. This is the concept of backtracking.

Sometimes, it so happens that the gradient is almost negligible. It must be noted

that the gradient of a layer depends on certain components in the successive
layers. If some of these components are small (i.e., less than 1), the resultant
gradient will be even smaller. This is known as the scaling effect.

When this gradient is multiplied with the learning rate, which is itself a small value
ranging between 0.1-0.001, it results in a smaller value. As a consequence, the
alteration in weights is quite small, producing almost the same output as before.
Similarly, if the gradients are quite large in value due to the large values of
components, the weights get updated to a value beyond the optimal value. This is
known as the problem of exploding gradients.

To avoid this scaling effect, the neural network unit was re-built in such a way that
the scaling factor was fixed to one. The cell was then enriched by several gating
units and termed as LSTM.

LSTMs comprises of three logistic sigmoid gates and one tanh layer. Gates have
been introduced in order to limit the information that is passed through the cell.
They determine which part of the information will be needed by the next cell and
which part is to be discarded. The output is usually in the range of 0-1 where ‘0’
means ‘reject all’ and ‘1’ means ‘include all’.
 Fig-1

Image of Conventional LSTM

✔ Each LSTM cell has three inputs ht-1, Ct-1 and xt and two outputs ht and Ct. For
a given time t, ht is the hidden state, Ct is the cell state or memory, xt is the current
data point or input.

✔ The first sigmoid layer has two inputs ht-1 and xt where ht-1 is the hidden state of
the previous cell.

✔ First sigmoid layer is also known as the forget gate as its output selects the
amount of information of the previous cell to be included. The output is a number in
[0,1] which is multiplied (pointwise) with the previous cell state Ct-1.

✔ Second sigmoid layer is the input gate that decides what new information is to be
added to the cell. It takes two inputs ht-1 and xt.
✔ The tanh layer creates a vector Ct of the new candidate values. Together, these
two layers determine the information to be stored in the cell state. Their point-wise
multiplication (it ? Ct) tells us the amount of information to be added to the cell state.

✔ The result is then added with the result of the forget gate multiplied with previous
cell state (ft * Ct-1) to produce the current cell state Ct.

✔ Next, the output of the cell is calculated using a sigmoid and a tanh layer. The
sigmoid layer decides which part of the cell state will be present in the output
whereas tanh layer shifts the output in the range of [-1,1].

✔ The results of the two layers undergo point-wise multiplication to produce the
output ht of the cell.
3.5 Experimental Setup:

3.5.1 Train Dataset:

It is the sample of data used to fit the model. This step involves in extraction of
features and train to fit a model and so on. The observations in the training set form
the experience that the algorithm uses to learn. In supervised learning problems,
each observation consists of an observed output variable and one or more
observed input variables.

3.5.2 Validation Dataset:

The sample of data used to provide unbiased evaluation of a model to fit on the
train data set. The evaluation becomes more biased as skill on the validation
dataset is incorporated into the model configuration.

3.5.3 Test dataset:

The sample of data used to provide unbiased evaluation of a final model. It used to
test if the model is making accurate predictions. The test set is a set of observations
used to evaluate the performance of the model using some performance metric. It is
important that no observations from the training set are included in the test set. If
the test set does contain examples from the training set, it will be difficult to assess
whether the algorithm has learned to generalize from the training set or has simply
memorized it.

3.6 Parameters given to model for training:

3.6.1 Batch size:

Integer or None . Number of samples per gradient update. If unspecified, batch_size

will default to 32. Do not specify the batch size if the data is in the form of datasets,
generators, or Keras.utils.Sequence instances.

3.6.2 Epochs:

Integer. Number of epochs to train the model. An epoch is an iteration over the
entire x and y data provided. Note that in conjunction with initial epoch, epochs is to
be understood as "final epoch". The model is not trained for a number of iterations
given by epochs, but merely until the epoch of index epochs is reached.

3.6.3 Verbose:

'auto', 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one line per

epoch. 'auto' defaults to 1 for most cases, but 2 when used with
ParameterServerStrategy. Note that the progress bar is not particularly useful when
logged to a file, so verbose=2 is recommended when not running interactively (e.g.,
in a production environment).

3.6.4 Validation Split:

Float between 0 and 1. Fraction of the training data to be used as validation data.
The model will set apart this fraction of the training data, will not train on it, and will
evaluate the loss and any model metrics on this data at the end of each epoch. 20%
of the train dataset is used as validation dataset for validating the model which is
trained by 80% of the train dataset.
 FIG-2

Process Diagram Between Patient and Medibot

FIG-3
Design Flow Diagram
In this Design Flow Diagram first, it has to start and the user had to send input to
intent classification. From intent files, data will be sent to intent classification. Then
after it goes to search pattern where it searches for the correct pattern in pattern
check if it is yes it goes to return response if not data base. In the next section going
to explain the literature review in which know more about the medibot.

FIG-4
System Architecture
System Architecture is important for the development of a system. This medibot
provides proper guidance to patients who have no awareness of their physical
condition. Many people hesitate to ask doctors about symptoms with chatbots so
they can solve their problems. The below fig 3 gives us working of the system.
 FIG-5

Processing steps for chatbot

According to the above diagram User, messages will be classified into Intent and
Entities by Intent and Entities classification. After it will go to the response generator
where it will send a response to candidates from context and responses. Response
selector will select a response from the above responses shows in fig.4
 5. Testing

The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub-assemblies, assemblies and/or a finished product. It is a process of exercising
software with the intent of ensuring that theSoftware system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of test. Each test
type addresses a specific testing requirement.

5.1 Types of Testing:

Unit Testing:

Unit testing involves the design of test cases that validate, that the internal program logic is
functioning properly, and that program inputs produce valid outputs. All decision branches and
internal code flow should be validated. It is the testing of individual software units of the
application .it is done after the completion of an individual unit before integration. This is a
structural testing, that relies on knowledge of its construction and is invasive. Unit tests perform
basic tests at component level and test a specific business process, application, and/or system
configuration. Unit tests ensure that each unique path of a business process performs accurately to
the documented specifications and contains clearly defined inputs and expected results.

Integration Testing:

Integration tests are designed to test integrated software components to determine if they actually
run as one program. Testing is event driven and is more concerned with the basic outcome of
screens or fields. Integration tests demonstrate that although the components were individually
satisfaction, as shown by successfully unit testing, the combination of components is correct and
consistent. Integration testing is specifically aimed at exposing the problems that arise from the
combination of components.

Functional Tests:

Functional tests provide systematic demonstrations that functions tested are available as specified
by the business and technical requirements, system documentation, and user manuals.

Functional Testing is centered on the following items:

Valid Input : identified classes of valid input must be accepted.

Invalid Input : identified classes of invalid input must be rejected.

Functions : identified functions must be exercised.

Output : identified classes of application outputs must be exercised.

Systems/Procedures : interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key functions, or
special test cases. In addition, systematic coverage pertaining to identify Business process flows;
data fields, predefined processes, and successive processes must be considered for testing. Before
functional testing is complete, additional tests are identified and the effective value of current tests
is determined.

System Test:

System testing ensures that the entire integrated software system meets requirements. It tests a
configuration to ensure known and predictable results. An example of system testing is the
configuration oriented system integration test. System testing is based on process descriptions and
flows, emphasizing pre-driven process links and integration points.

White Box Testing:

White Box Testing is a testing in which in which the software tester has knowledge of the inner
workings, structure and language of the software, or at least its purpose. It is purpose. It is used to
test areas that cannot be reached from a black box level.

Black Box Testing:

Black Box Testing is testing the software without any knowledge of the inner workings, structure or
language of the module being tested. Black box tests, as most other kinds of tests, must be written
from a definitive source document, such as specification or requirements document, such as
specification or requirements document. It is a testing in which the software under test is treated,
as a black box .you cannot “see” into it. The test provides inputs and responds to outputs without
considering how the software works.

Unit Testing:

Unit testing is usually conducted as part of a combined code and unit test phase of the software
lifecycle, although it is not uncommon for coding and unit testing to be conducted as two distinct
phases.

Integration Testing:

Software integration testing is the incremental integration testing of two or more

integrated software components on a single platform to produce failures caused by interface
defects.

The simulation tested with different commands like wish and xgraph and god attributes.

Acceptance Testing:

User Acceptance Testing is a critical phase of any project and requires significant participation by
the end user. It also ensures that the system meets the functional requirements. The input from the
user like source and destination node ids are accepting as per the simulation criteria.

Test Results: All the test cases mentioned above passed successfully. No defects encountered.
5.2 Test Strategy and Approach:

Field testing will be performed manually and functional tests will be written in detail.

Test objectives

 All field entries must work properly.

 Pages must be activated from the identified link.

 The entry screen, messages and responses must not be delayed.

Features to be tested

 Verify that the entries are of the correct format

 No duplicate entries should be allowed

 All links should take the user to the correct page

5.3 Test cases:

Figure 5.3.1 TEST CASE -1

Figure 5.3.2 TEST

CASE-1

Figure 5.3.2 Test case 2

CHAPTER 4
 RESULT AND DISCUSSION

Model Evaluation is an integral part of the model development process. It helps to

find best model that represents the data and how well the chosen model will work in
the future. Evaluating model performance with the data used for training is not
acceptable in data science because it can easily generate overoptimistic and
overfitted models.

4.1 Evaluation Metrics and Result

Model evaluation metrics are required to quantify model performance. The choice of
model evaluation metrics depends on a given machine learning task.

In this project evaluation metrics are:

1) Accuracy

2) Loss

Sample Code for Evaluating Model

model.evaluate(np.array(train_x), np.array(train_y))

As a result of evaluation using model.evaluate() method,

1- Accuracy of the model is depicted as 1.0000
2- Loss of the model is depicted as 0.00073455

Fig-6

4.2. Training and Testing Data

We will create the training data in which we will provide the input and the output.
Our input will be the pattern and output will be the class our input pattern belongs
to. we will convert text into numbers.

# create our training data training = []

# create an empty array for our output output_empty = [0] * len(classes)

# training set, bag of words for each sentence
for doc in documents:
# initialize our bag of words bag = []
# list of tokenized words for the pattern pattern_words = doc[0]
# lemmatize each word - create base word, in attempt to represent related words
pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words] #
create our bag of words array with 1, if word match found in current pattern
for w in words:
bag.append(1) if w in pattern_words else bag.append(0)
# output is a '0' for each tag and '1' for current tag (for each pattern)
output_row = list(output_empty)
output_row[classes.index(doc[1])] = 1 training.append([bag,
output_row])
# shuffle our features and turn into np.array random.shuffle(training)
training = np.array(training)
# create train and test lists. X - patterns, Y - intents train_x =
list(training[:,0])
train_y = list(training[:,1])
print ("Training data created")

4.3. Building the Model

We have our training data ready, now we will build a deep neural
network that has 3 layers. We use the Keras sequential API for this.
After training the model for 200 epochs, we achieved 100% accuracy
on our model. Let us save the model as ‘chatbot_model.h5’.

# Create model - 3 layers. First layer 128 neurons, second layer 64

neurons and 3rd output layer contains number of neurons
# equal to number of intents to predict output intent with softmax model
= Sequential()
model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu')) model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]), activation='softmax'))
# Compile model. Stochastic gradient descent with Nesterov
accelerated gradient gives good results for this model
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=sgd, metrics=['accuracy'])
#fitting and saving the model

hist = model.fit(np.array(train_x), np.array(train_y), epochs=200,

batch_size=5, verbose=1)
model.save('chatbot_model.h5', hist) print("model created")

4.3.1 Predict the response (Graphical User Interface)

To predict the sentences and get a response from the user to let us
create a new file ‘chatapp.py’.

We will load the trained model and then use a graphical user interface
that will predict the response from the bot. The model will only tell us
the class it belongs to, so we will implement some functions which will
identify the class and then retrieve us a random response from the list
of responses.

Again we import the necessary packages and load the ‘words.pkl’ and
‘classes.pkl’ pickle files which we have created when we trained our
model:

import nltk
from nltk.stem import WordNetLemmatizer lemmatizer =
WordNetLemmatizer()

import pickle
import numpy as np
from keras.models import load_model model =
load_model('chatbot_model.h5') import json
import random
intents = json.loads(open('intents.json').read()) words =
pickle.load(open('words.pkl','rb')) classes =
pickle.load(open('classes.pkl','rb'))

To predict the class, we will need to provide input in the same way as
we did while training. So we will create some functions that will perform
text pre-processing and then predict the class.

def clean_up_sentence(sentence):
# tokenize the pattern - split words into array
sentence_words = nltk.word_tokenize(sentence) # stem each word -
create short form for word
sentence_words = [lemmatizer.lemmatize(word.lower()) for
sentence_words]
return sentence_words
# return bag of words array: 0 or 1 for each word in the bag that
exists in the sentence
def bow(sentence, words, show_details=True):
# tokenize the pattern
sentence_words = clean_up_sentence(sentence)
# bag of words - matrix of N words, vocabulary matrix bag =
[0]*len(words)
for s in sentence_words:
for i,w in enumerate(words):
if w == s:
# assign 1 if current word is in the vocabulary position bag[i] = 1
if show_details:
print ("found in bag: %s" % w)
return(np.array(bag))
def predict_class(sentence, model):
# filter out predictions below a threshold
p = bow(sentence, words,show_details=False) res =
model.predict(np.array([p]))[0]
ERROR_THRESHOLD = 0.25
results = [[i,r] for i,r in enumerate(res) if r>ERROR_THRESHOLD] #
sort by strength of probability
results.sort(key=lambda x: x[1], reverse=True) return_list = []
for r in results:
return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
return return_list

After predicting the class, we will get a random response from the list of
intents.
def getResponse(ints, intents_json):
tag = ints[0]['intent']
list_of_intents = intents_json['intents']
for i in list_of_intents:
if(i['tag']== tag):
result = random.choice(i['responses']) break
return result
def chatbot_response(text):
ints = predict_class(text, model) res = getResponse(ints, intents) return
res

Now we will develop a graphical user interface. Let’s use Tkinter library
which is shipped with tons of useful libraries for GUI. We will take the
input message from the user and then use the helper functions we have
created to get the response from the bot and display it on the GUI. Here
is the full source code for the GUI.

#Creating GUI with tkinter import tkinter

from tkinter import *
def send():
msg = EntryBox.get("1.0",'end-1c').strip() EntryBox.delete("0.0",END)
if msg != '': ChatLog.config(state=NORMAL) ChatLog.insert(END, "You:
" + msg + '\n\n')
ChatLog.config(foreground="#442265", font=("Verdana", 12 )) res =
chatbot_response(msg)
ChatLog.insert(END, "Bot: " + res + '\n\n')
ChatLog.config(state=DISABLED) ChatLog.yview(END)
base = Tk() base.title("Hello") base.geometry("400x500")

base.resizable(width=FALSE, height=FALSE) #Create Chat window

ChatLog = Text(base, bd=0, bg="white", height="8", width="50",
font="Arial",) ChatLog.config(state=DISABLED)
#Bind scrollbar to Chat window
scrollbar = Scrollbar(base, command=ChatLog.yview, cursor="heart")
ChatLog['yscrollcommand'] = scrollbar.set #Create Button to send
message
SendButton = Button(base, font=("Verdana",12,'bold'), text="Send",
width="12", height=5,
bd=0, bg="#32de97", activebackground="#3c9d9b",fg='#ffffff',
command= send )
#Create the box to enter message
EntryBox = Text(base, bd=0, bg="white",width="29", height="5",
font="Arial") #EntryBox.bind("<Return>", send)
#Place all components on the screen scrollbar.place(x=376,y=6,
height=386) ChatLog.place(x=6,y=6, height=386, width=370)
EntryBox.place(x=128, y=401, height=90, width=265)
SendButton.place(x=6, y=401, height=90)
base.mainloop()
 CHAPTER 5
CONCLUSION AND FUTURE WORK

5.1 CONCLUSION:

The Intent of this paper is to increase the awareness of health among the people. In
current days, many people show their lazy behavior and don’t consult a doctor during
a time of illness so the implementation of a chatbot will help the people to diagnose
the disease without consulting a doctor. The chatbot will act as a virtual doctor. The
user will prescribe their symptoms of their illness and the chatbot will analyze the
disease and suggest the necessary healthcare steps that need to be taken. In the
datasets it includes information regarding diseases and health care steps.

5.2 FUTURE WORK:

Based on the system development and extensibility in future can also implement
audio and face recognition to user’s benefits and also interact will doctors in case of
a patient’s emergency for treatment.
REFERENCES:
[1] Srivastava, P., & Singh, N (2020, February). Automatized medical chatbot
(medibot). In 2020 International Conference on Power Electronics & IoT Applications
in Renewable Energy and its Control (PARC) (pp. 351-354). IEEE.
[2] Kandpal, P., Jasnani, K., Raut, R., & Bhorge, S. (2020, July). Contextual
Chatbot for healthcare purposes (using deep learning). In 2020 Fourth World
Conference on Smart Trends in Systems, Security and Sustainability (WorldS4) (pp.
625-634). IEEE.
[3] Athota, L., Shukla, V. K., Pandey, N., & Rana, A. (2020, June). Chatbot for
Healthcare System Using Artificial Intelligence. In 2020 8th International Conference
on Reliability, Infocom Technologies and Optimization (Trends and Future Directions)
(ICRITO) (pp. 619-622). IEEE.
[4] Karri, S. P. R., & Kumar, B. S. (2020, January). Deep learning techniques for
implementation of chatbots. In 2020 International Conference on Computer
Communication and Informatics (ICCCI) (pp. 1-5). IEEE.
[5] Bharti, U., Bajaj, D., Batra, H., Lalit, S., Lalit, S., & Gangwani, A. (2020, June).
Medbot: Conversational artificial intelligence powered chatbot for delivering tele-
health after covid-19. In 2020 5th International Conference on Communication and
Electronics Systems (ICCES) (pp. 870-875). IEEE.
[6] Milla T Mutiwokuziva, Melody W Chanda, Prudence Kadebu, Addlight
Mukwazvure, Tatenda T Gotora, “A Neural-network based Chat Bot” in ICCES,2017
[7] Gentner, T., Neitzel, T., Schulze, J., & Buettner, R. (2020, July). A Systematic
literature review of medical chatbot research from a behavior change perspective. In
2020 IEEE 44th Annual Computers, Software, and Applications Conference
(COMPSAC) (pp. 735-740). IEEE.
[8] https://www.investopedia.com/terms/d/deeplearning.asp#:~:text=Deep%20l
earning%20is%20a%20subset,le arning%20or%20deep%20neural%20network.
 APPENDIX

A. SOURCE CODE(app.py file)

import random
from flask import jsonify
import secrets
from flask import Flask, render_template, flash, redirect, url_for,
session, logging, request, session
from flask_sqlalchemy import SQLAlchemy
from collections.abc import Mapping

ALLOWED_EXTENSIONS = ['png', 'jpg', 'jpeg']

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db'
db = SQLAlchemy(app)
app.secret_key = "m4xpl0it"

def make_token():
"""
Creates a cryptographically-secure, URL-safe string
"""
return secrets.token_urlsafe(16)

class user(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
email = db.Column(db.String(120))
password = db.Column(db.String(80))

@app.route("/")
def index():
 return render_template("index.html")
userSession = {}

@app.route("/user")
def index_auth():
my_id = make_token()
userSession[my_id] = -1
return render_template("index_auth.html",sessionId=my_id)

@app.route("/instruct")
def instruct():
return render_template("instructions.html")

@app.route("/upload")
def bmi():
return render_template("bmi.html")

@app.route("/diseases")
def diseases():
return render_template("diseases.html")

@app.route('/pred_page')
def pred_page():
pred = session.get('pred_label', None)
f_name = session.get('filename', None)
return render_template('pred.html', pred=pred, f_name=f_name)
@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
uname = request.form["uname"]
passw = request.form["passw"]

login = user.query.filter_by(username=uname,
password=passw).first()
 if login is not None:
return redirect(url_for("index_auth"))
return render_template("login.html")

@app.route("/register", methods=["GET", "POST"])

def register():
if request.method == "POST":
uname = request.form['uname']
mail = request.form['mail']
passw = request.form['passw']

register = user(username=uname, email=mail, password=passw)

db.session.add(register)
db.session.commit()

return redirect(url_for("login"))
return render_template("register.html")

import msgConstant as msgCons

import re

all_result = {
'name':'',
'age':0,
'gender':'',
'symptoms':[]
}

# Import Dependencies
# import gradio as gr
import pandas as pd
import numpy as np
from joblib import load
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def predict_symptom(user_input, symptom_list):

# Convert user input to lowercase and split into tokens
user_input_tokens = user_input.lower().replace("_"," ").split()

# Calculate cosine similarity between user input and each symptom

similarity_scores = []
for symptom in symptom_list:
# Convert symptom to lowercase and split into tokens
symptom_tokens = symptom.lower().replace("_"," ").split()

# Create count vectors for user input and symptom

count_vector = np.zeros((2, len(set(user_input_tokens +
symptom_tokens))))
for i, token in enumerate(set(user_input_tokens +
symptom_tokens)):
count_vector[0][i] = user_input_tokens.count(token)
count_vector[1][i] = symptom_tokens.count(token)

# Calculate cosine similarity between count vectors

similarity = cosine_similarity(count_vector)[0][1]
similarity_scores.append(similarity)

# Return symptom with highest similarity score

max_score_index = np.argmax(similarity_scores)
print(symptom_list[max_score_index])
return symptom_list[max_score_index]

import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Load the dataset into a pandas dataframe

df = pd.read_excel('C:/Users/User/Desktop/project k/Updated
Code/flask/dataset.xlsx')

# Get all unique symptoms

symptoms = set()
for s in df['Symptoms']:
for symptom in s.split(','):
symptoms.add(symptom.strip())

def predict_disease_from_symptom(symptom_list):

symptoms = {'itching': 0, 'skin_rash': 0, 'nodal_skin_eruptions': 0,

'continuous_sneezing': 0,
'shivering': 0, 'chills': 0, 'joint_pain': 0,
'stomach_pain': 0, 'acidity': 0, 'ulcers_on_tongue': 0,
'muscle_wasting': 0, 'vomiting': 0, 'burning_micturition':
0, 'spotting_urination': 0, 'fatigue': 0,
'weight_gain': 0, 'anxiety': 0, 'cold_hands_and_feets': 0,
'mood_swings': 0, 'weight_loss': 0,
'restlessness': 0, 'lethargy': 0, 'patches_in_throat': 0,
'irregular_sugar_level': 0, 'cough': 0,
'high_fever': 0, 'sunken_eyes': 0, 'breathlessness': 0,
'sweating': 0, 'dehydration': 0,
'indigestion': 0, 'headache': 0, 'yellowish_skin': 0,
'dark_urine': 0, 'nausea': 0, 'loss_of_appetite': 0,
'pain_behind_the_eyes': 0, 'back_pain': 0, 'constipation':
0, 'abdominal_pain': 0, 'diarrhoea': 0, 'mild_fever': 0,
'yellow_urine': 0, 'yellowing_of_eyes': 0,
'acute_liver_failure': 0, 'fluid_overload': 0, 'swelling_of_stomach': 0,
'swelled_lymph_nodes': 0, 'malaise': 0,
'blurred_and_distorted_vision': 0, 'phlegm': 0, 'throat_irritation': 0,
'redness_of_eyes': 0, 'sinus_pressure': 0, 'runny_nose':
0, 'congestion': 0, 'chest_pain': 0, 'weakness_in_limbs': 0,
 'fast_heart_rate': 0, 'pain_during_bowel_movements': 0,
'pain_in_anal_region': 0, 'bloody_stool': 0,
'irritation_in_anus': 0, 'neck_pain': 0, 'dizziness': 0,
'cramps': 0, 'bruising': 0, 'obesity': 0, 'swollen_legs': 0,
'swollen_blood_vessels': 0, 'puffy_face_and_eyes': 0,
'enlarged_thyroid': 0, 'brittle_nails': 0, 'swollen_extremeties': 0,
'excessive_hunger': 0, 'extra_marital_contacts': 0,
'drying_and_tingling_lips': 0, 'slurred_speech': 0,
'knee_pain': 0, 'hip_joint_pain': 0, 'muscle_weakness': 0,
'stiff_neck': 0, 'swelling_joints': 0, 'movement_stiffness': 0,
'spinning_movements': 0, 'loss_of_balance': 0,
'unsteadiness': 0, 'weakness_of_one_body_side': 0, 'loss_of_smell': 0,
'bladder_discomfort': 0, 'foul_smell_of urine': 0,
'continuous_feel_of_urine': 0, 'passage_of_gases': 0, 'internal_itching':
0,
'toxic_look_(typhos)': 0, 'depression': 0, 'irritability':
0, 'muscle_pain': 0, 'altered_sensorium': 0,
'red_spots_over_body': 0, 'belly_pain': 0,
'abnormal_menstruation': 0, 'dischromic_patches': 0, 'watering_from_eyes':
0,
'increased_appetite': 0, 'polyuria': 0, 'family_history':
0, 'mucoid_sputum': 0, 'rusty_sputum': 0, 'lack_of_concentration': 0,
'visual_disturbances': 0, 'receiving_blood_transfusion':
0, 'receiving_unsterile_injections': 0, 'coma': 0,
'stomach_bleeding': 0, 'distention_of_abdomen': 0,
'history_of_alcohol_consumption': 0, 'fluid_overload.1': 0,
'blood_in_sputum': 0, 'prominent_veins_on_calf': 0,
'palpitations': 0, 'painful_walking': 0, 'pus_filled_pimples': 0,
'blackheads': 0, 'scurring': 0, 'skin_peeling': 0,
'silver_like_dusting': 0, 'small_dents_in_nails': 0, 'inflammatory_nails':
0,
'blister': 0, 'red_sore_around_nose': 0,
'yellow_crust_ooze': 0}

# Set value to 1 for corresponding symptoms

 #symptom_list = ['acidity']
for s in symptom_list:
index = predict_symptom(s, list(symptoms.keys()))
print('User Input: ',s," Index: ",index)
symptoms[index] = 1

# Put all data in a test dataset

df_test = pd.DataFrame(columns=list(symptoms.keys()))
df_test.loc[0] = np.array(list(symptoms.values()))
print(df_test.head())
# Load pre-trained model
clf = load(str("C:/Users/User/Desktop/project k/Updated
Code/flask/model/random_forest.joblib"))
result = clf.predict(df_test)

disease_details = getDiseaseInfo(result[0])
print(df_test)
# Cleanup
del df_test
#return f"<b>{result[0]}</b><br>{disease_details}",result[0]
#print(df_test)

return f"<b>{result[0]}</b><br>{disease_details}",result[0]

user_symptoms = symptom_list
# Vectorize symptoms using CountVectorizer
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(df['Symptoms'])
user_X = vectorizer.transform([', '.join(user_symptoms)])

# Compute cosine similarity between user symptoms and dataset symptoms

similarity_scores = cosine_similarity(X, user_X)

# Find the most similar disease(s)

max_score = similarity_scores.max()
B. SCREENSHOTS