5G SMART DIABETES :

TOWARD PERSONALIZED DIABETESDIAGNOSIS

WITH HEALTHCARE BIG DATA CLOUDS
 ABSTRACT

Recent advances in wireless networking and big data technologies, such as 5G networks, medical
big data analytics, and the Internet of Things, along with recent developments in wearable computing
and artificial intelligence, are enabling the development and implementation of innovative diabetes
monitoring systems and applications. Due to the life-long and systematic harm suffered by diabetes
patients, it is critical to design effective methods for the diagnosis and treatment of diabetes. Based on
our comprehensive investigation, this article classifies those methods into Diabetes 1.0 and Diabetes
2.0, which exhibit deficiencies in terms of networking and intelligence.
Thus, our goal is to design a sustainable, cost-effective, and intelligent diabetes diagnosis solution
with personalized treatment. In this article, we first propose the 5G-Smart Diabetes system, which
combines the state-of-the-art technologies such as wearable 2.0, machine learning, and big data to
generate comprehensive sensing and analysis for patients suffering from diabetes. Then we present the
data sharing mechanism and personalized data analysis model for 5G-Smart Diabetes. Finally, we
build a 5G-Smart Diabetes testbed that includes smart clothing, smartphone, and big data clouds. The
experimental results show that our system can effectively provide personalized diagnosis and
treatment suggestions to patients.
 INDEX

S. No CONTENTS Pg. No
1 ABSTRACT
2 INTRODUCTION 1

3 LITERATURE SURVEY 3

4 SYSTEM ANALYSIS 5

3.1EXISTING SYSTEM 5

3.2 PROPOSED SYSTEM 5

3.3 FEASIBILITY STUDY 6

3.3.1 ECONOMICAL FEASIBILITY 6

3.3.2 TECHNICAL FEASIBILITY 6

3.3.3 SOCIAL FEASIBILITY 6

3.4 SYSTEM REQUIRMENTS 7

3.5 SYSTEM DESIGN 8

3.5.1 ARCHITECTURE DIAGRAM 8

3.5.2 USE CASE DIAGRAM 9

3.5.3 SEQUENCE DIAGRAM 10

3.5.4 ACTIVITY DIAGRAM 11

3.6 INPUT AND OUTPUT DATA

3.6.1 INPUT DATA 12

3.6.2 OUTPUT DATA 13

3.7 DATASET CONSTRUCTION AND ANNOTATION 14

3.7.1 DATA COLLECTION 15

3.7.2 MODULES 17
 3.8 CLASSIFICATION 18

5. IMPLEMENTATION 22

5.1 ALGORITHM 22

5.2 TESTCASE DIAGRAM 23

6. CODING 24

7. TESTING 32

7.1 TESTING 32

7.2 TYPES OF TESTS 32

7.3 TEST STRATEGY AND APPROACH 34

8. OUTPUT SCREENS 35

9. CONCLUSION AND FUTURE SCOPE 48

10. REFRERENCES 50
 LIST OF FIGURES

S.NO CONTENT PAGE .NO

3.5.1 ARCHITECTURE DIAGRAM 8

3.5.2 USECASE DIAGRAM 9

3.5.3 SEQUENCE DIAGRAM 10

3.5.4 ACTIVITY DIAGRAM 11

INTRODUCTION
 INTRODUCTION
Diabetes is an extremely common chronic disease from which nearly 8.5 percent of the world
population suffer; 422 million people worldwide have to struggle with diabetes. It is crucial to note
that type 2 diabetes mellitus makes up about 90 percent of the cases [1]. More critically, the situation
will be worse, as reported in [2], with more teenagers and youth becoming susceptible to diabetes as
well. Due to the fact that diabetes has a huge impact on global well-being and economy, it is urgent to
improve methods for the prevention and treatment of diabetes [3].
Furthermore, various factors can cause the disease, such as improper and unhealthy lifestyle,
vulnerable emotion status, along with the accumulated stress from society and work. However, the
existing diabetes detection system faces the following problems:
• The system is uncomfortable, and real-time data collection is difficult. Furthermore, it lacks
continuous monitoring of multi-dimensional physiological indicators of patients suffering from
diabetes [4, 5].
• The diabetes detection model lacks a data sharing mechanism and personalized analysis of big data
from different sources including lifestyle, sports, diet, and so on [6, 7].
• There are no continuous suggestions for the prevention and treatment of diabetes and corresponding
supervision strategies [8, 9].
To solve the above problems, in this article, we first propose a next generation diabetes solution
called the 5G-Smart Diabetes system, which integrates novel technologies including fifth generation
(5G) mobile networks, machine learning, medical big data, social networking, smart clothing [10], and
so on. Then we present the data sharing mechanism and personalized data analysis model for 5G-
Smart Diabetes. Finally, based on the smart clothing, smartphone, and big data healthcare clouds, we
build a 5G-Smart Diabetes testbed and give the experiment results.
Furthermore, the “5G” in 5G-Smart Diabetes has a two-fold meaning. On one hand, it refers to the
5G technology that will be adopted as the communication infrastructure to realize high-quality and
continuous monitoring of the physiological states of patients with diabetes and to provide treatment
services for such patients without restraining their freedom. On the other hand, “5G” refers to the
following “5 goals”: cost effectiveness, comfortability, personalization, sustainability, and smartness.

1
Cost Effectiveness: It is achieved from two aspects. First, 5G-Smart Diabetes keeps users in a healthy
lifestyle so as to prevent users from getting the disease in the early stage. The reduction of disease risk
would lead to decreasing the cost of diabetes treatment. Second, 5G-Smart Diabetes facilitates out-of-
hospital treatment, thus reducing the cost compared to on-the-spot treatment, especially long-term
hospitalization of the patient.
Comfortability: To achieve comfort for patients, it is required that 5G-Smart Diabetes does not
disturb the patients’ daily activities as much as possible. Thus, 5G-Smart Diabetes integrates smart
clothing [3], mobile phones, and portable blood glucose monitoring devices to easily monitor patients’
blood glucose and other physiological indicators.
Personalization: 5G-Smart Diabetes utilizes various machine learning and cognitive computing
algorithms to establish personalized diabetes diagnosis for the prevention and treatment of diabetes.
Based on the collected blood glucose data and individualized physiological indicators, 5G-Smart
Diabetes produces personalized treatment solutions for patients.
Sustainability: By continuously collecting, storing, and analyzing information on personal diabetes,
5G-Smart Diabetes adjusts the treatment strategy in time based on the changes of patients’ status.
Furthermore, in order to be sustainable for data-driven diabetes diagnosis and treatment, 5G-Smart
Diabetes establishes effective information sharing among patients, relatives, friends, personal health
advisors, and doctors.
With the help of social networking, the patient’s mood can be better improved so that he or she is
more self-motivated to perform a treatment plan in time. Smartness: With cognitive intelligence
toward patients’ status and network resources, 5G-Smart Diabetes achieves early detection and
prevention of diabetes and provides personalized treatment to patients. The remaining part of the
article is organized as follows. We first present the system architecture of 5G-Smart Diabetes. Then
we explain the data sharing mechanism and propose the personalized data analysis model.
Furthermore, we introduce the 5G-Smart Diabetes testbed. Finally, the conclusion of this article is
given

2
LITERATURE SURVEY

3
 INTRODUCTION AND RELATED WORK
1 S. Mendis, “Global Status Report on Noncommunicable Diseases 2014,” WHO, tech. rep.;
http://www.who.int/ nmh/publications/ncd-status-report-2014/en/, accessed Jan. 2015.
2 F. Florencia et al., IDF Diabetes Atlas, 6th ed., Int’l. Diabetes Federation, tech. rep.;
http://www.diabetesatlas.org/, accessed Jan. 2016.
3 M. Chen et al., “Disease Prediction by Machine Learning over Big Healthcare Data,” IEEE Access,
vol. 5, June 2017, pp. 8869--79.
4 O. Geman, I. Chiuchisan, and R. Toderean, “Application of Adaptive Neuro-Fuzzy Inference System
for Diabetes Classification and prediction},” Proc. 6th IEEE Int’l. Conf. E-Health and Bioengineering,
Sinaia, Romania, July 2017, pp. 639--642.
5 S. Fong, et al. “Real-Time Decision Rules for Diabetes Therapy Management by Data Stream
Mining,” IT Professional, vol. 26, no. 99, June 2017, pp. 1--8.
6 B. Lee, J. Kim, “Identification of Type 2 Diabetes Risk Factors Using Phenotypes Consisting of
Anthropometry and Triglycerides Based on Machine Learning,” IEEE J. Biomed. Health Info., vol.
20, no. 1, Jan. 2016, pp. 39--46.
7 M. Hossain, et al., “Big Data-Driven Service Composition Using Parallel Clustered Particle Swarm
Optimization in Mobile Environment,” IEEE Trans. Serv. Comp., vol. 9, no. 5, Aug. 2016, pp. 806--
17.
8 M. Hossain, “Cloud-Supported Cyber-Physical Localization Framework for Patients Monitoring,”
IEEE Sys. J., vol. 11, no. 1, Sept. 2017, pp. 118--27.
9 P. Pesl, et al., “An Advanced Bolus Calculator for Type 1 Diabetes: System Architecture and
Usability Results,” IEEE J. Biomed. Health Info., vol. 20, no. 1, Jan. 2016, pp. 11--17.
10 M. Chen et al., “Wearable 2.0: Enable Human-Cloud Integration in Next Generation Healthcare
System,” IEEE Commun. Mag., vol. 55, no. 1, Jan. 2017, pp. 54--61.
11 E. Marie et al., “Diabetes 2.0: Next-Generation Approach to Diagnosis and Treatment,” Brigham
Health Hub, tech. rep.; https://brighamhealthhub.org/diabetes-2-0-next-generation-approach- to-
diagnosis-and-treatment, 2017, accessed Feb. 2017.
4
12 M. Chen et al., “Green and Mobility-Aware Caching in 5G Networks,” IEEE Trans. Wireless
Commun., vol. 16, no. 12, 2017, pp. 8347–61.
13 C. Yao et al., “A Convolutional Neural Network Model for Online Medical Guidance,” IEEE
Access, vol. 4, Aug. 2016, pp. 4094--4103.

SYSTEM ANALYSIS
Analysis of the Existing System, helps in designing problem statement of Proposed system. In the
following section based on the analysis of Existing System, the requirements of Proposed System has
defined.
Existing System
As there is no staff available in unmanned restaurants, it is difficult for the restaurant management
to estimate how the concept and the food is experienced by the customers. Existing
rating systems, such as Google and TripAdvisor, only partially solve this problem, as they only cover a
part of the customer’s opinions. These rating systems are only used by a subset of the customers who
rate the restaurant on independent rating platforms on their own initiative. This applies mainly to
customers who experience their visit as very positive or negative.
Proposed System
In order to solve the above problem, all customers must be motivated to give a rating. This paper
introduces an approach for a restaurant rating system that asks every customer for a rating after their
visit to increase the number of ratings as much as possible. This system can be used unmanned
restaurants; the scoring system is based on facial expression detection using pertained convolutional
neural network (CNN) models. It allows the customer to rate the food by taking or capturing a picture
of his face that reflects the corresponding feelings. Compared to
text-based rating system, there is much less information and no individual experience reports
collected. However, this simple fast and playful rating system should give a wider range of opinions
about the experiences of the customers with the restaurant concept.

5
Feasibility Study
The feasibility of the project is analysed in this phase and business proposal is put forth witha very
general plan for the project and some cost estimates. During system analysis the feasibility study of the
proposed system is to be carried out. This is to ensure that the proposed system is not a burden to the
company. For feasibility analysis, some understanding of the major requirements for the system is
essential.
Three key considerations involved in the feasibility analysis are,
 ECONOMICAL FEASIBILITY
 TECHNICAL FEASIBILITY
 SOCIAL FEASIBILITY
Economical Feasibility
This study is carried out to check the economic impact that the system will have on the
organization. The amount of fund that the company can pour into the research and development of the
system is limited. The expenditures must be justified. Thus, the developed system as well within the
budget and this was achieved because most of the technologies used are freely available. Only the
customized products had to be purchased.
Technical Feasibility
This study is carried out to check the technical feasibility, that is, the technical requirements of the
system. Any system developed must not have a high demand on the available technical resources. This
will lead to high demands on the available technical resources. This will lead to high demands being
placed on the client. The developed system must have a modest requirement; as only minimal or null
changes are required for implementing this system.
Social Feasibility
The aspect of study is to check the level of acceptance of the system by the user. This includes the
process of training the user to use the system efficiently. The user must not feel threatened by the

6
system, instead must accept it as a necessity. The level of acceptance by the users solely depends on
the methods that are employed to educate the user about the system and to make him familiar with it.
His level of confidence must be raised so that he is also able to make some constructive criticism,
which is welcomed, as he is the final user of the system.

System Requirements
There are two types of requirements are needed in this project:
1. Software requirements
2. Hardware requirements
Software Requirements:
 Operating system : Windows 7 Ultimate.
 Coding Language : Python.
 Front-End : Python.
 Designing : Html, CSS, JavaScript.
 Data Base : MySQL.
Hardware Requirements:
 System : Pentium IV 2.4 GHz.
 Hard Disk : 40 GB.
 Floppy Drive : 1.44 Mb.
 Monitor : 14’ Color Monitor.
 Mouse : Optical Mouse.
 Ram : 4 GB.

7
 SYSTEM DESIGN

The system design is the process of defining the architecture, modules, inter faces and data for the
system to satisfy specified requirements. System design could be seen as the application of systems
theory to product development. These include practical application of existing algorithms in face of
the need to explained decision-making, mechanisms for improving the quality and availability of data,
dealing with large unstructured data sets.

ArchitectureDiagram :

8
Use case diagram:
It is a simplest representation is are presentation of a user’s interaction with the system that shows the
relationship between the user and the different use cases in which the user is involved.
The use case diagram can identify the different types of users of a system and the different use case
sand will of ten be accomplishing by other types of diagrams as well.
Terminology:
Usecase: It is meant by a list of actions or event steps typically defining the interactions between a
role (knownasUnifiedModelingLanguage).Thesecanberepresentedwithcircleorellipse.
Actor: The actor can be human or any other external system. These can be represented with special
symbol.

9
Sequence diagram:

10
Class Diagram :

11
Activity Diagram :

12
 INPUT DATA
The input design is the link between the information system and the user. It comprises the developing
specification and procedures for data preparation and those steps are necessary to put transaction data
in to a usable form for processing can be achieved by inspecting the computer to read data from a
written or printed document or it can occur by having people keying the data directly into the system.
The design of input focuses on controlling the amount of input required, controlling the errors,
avoiding delay, avoiding extra steps and keeping the process simple. The input is designed in such a
way so that it provides security and ease of use with retaining the privacy. Input Design considered the
following things:
What data should be given as input?
How the data should be arranged or coded?
The dialog to guide the operating personnel in providing input.
Methods for preparing input validations and steps to follow when error occur.
Objectives:
1.Input Design is the process of converting a user-oriented description of the input into a computer-
based system. This design is important to avoid errors in the data input process and show the correct
direction to the management for getting correct information from the computerized system.
2. It is achieved by creating user-friendly screens for the data entry to handle large volume of data.
The goal of designing input is to make data entry easier and to be free from errors. The data entry
screen is designed in such a way that all the data manipulates can be performed. It also provides record
viewing facilities.
3.When the data is entered it will check for its validity. Data can be entered with the help of screens.
Appropriate messages are provided as when needed so that the user will not be in maize of instant.
Thus, the objective of input design is to create an input layout that is easy to follow.

13
 OUTPUT DATA
A quality output is one, which meets the requirements of the end user and presents the information
clearly. In any system results of processing are communicated to the users and to other system through
outputs. In output design it is determined how the information is to be displaced for immediate need
and also the hard copy output. It is the most important and direct source information to the user.
Efficient and intelligent output design improves the system’s relationship to help user decision-
making.
1. Designing computer output should proceed in an organized, well thought out manner; the right
output must be developed while ensuring that each output element is designed so that people will find
the system can use easily and effectively. When analysis design computer output, they should Identify
the specific output that is needed to meet the requirements.
2.Select methods for presenting information.
3.Create document, report, or other formats that contain information produced by the system.
The output form of an information system should accomplish one or more of the
following objectives.
Convey information about past activities, current status or projections of the
Future.
Signal important events, opportunities, problems, or warnings.
Trigger an action.
Confirm an action.

14
DATASET CONSTRUCTION AND ANNOTATION

15
DATACOLLECTION
The patient information was stored in diabetes dataset. The diabetes and non-diabetes patient
differentiated here. It contains personal health data as well as results. The detailed dataset
attributes shown below:
 Age
 Gender
 Diet
 Height
 Weight
 Systolic Blood Pressure (SBP)
 Diastolic Blood Pressure (DBP)
 Random Blood Sugar (RBS)
 Class variable (class)
Pre-processing:

Fig: - Before pre-processing

Preprocessing is the technique used to filter out or replace the mistaken data. Since we are
collecting, the raw data there may be high chances for noisy, missing value or inappropriate

16
values. In order to sort out the mistakes we are doing the process of pre-processing done to the
raw data otherwise, data become unfeasible

Fig:
-

before pre-processing

Fig:-After pre-processing

17
 MODULES
Admin Module:
Here the admin input the pima dataset and then pre-process the data and then apply the
classification algorithm like decision tree ,svm ,ann and ensemble classification method and
then apply the accuracy graph and then start the cloud server
User:
Here the use inputs the user symptom file and then out model gets connected to the cloud
server and performs the prediction from the cloud server and then it returns back the results if
the user data is diabetes or not with type of diabetes

18
CLASSIFICATION

19
CLASSIFICATION
Decision Tree:
Decision trees can be learned from training data. Training data will typically comprise many
instances of the following kind:
Instance 1 attribute1 attribute2
Instance 2 attribute1 attribute2
The decision tree learning algorithm recursively learns the tree as follows:
Assign all training instances to the root of the tree. Set current node to root node.
For each attribute
Partition all data instances at the node by the value of the attribute.
Compute the information gain ratio from the partitioning.
Identify feature that results in the greatest information gain ratio. Set this feature to be the
splitting criterion at the current node.
If the best information gain ratio is 0, tag the current node as a leaf and return.
Partition all instances according to attribute value of the best feature.
Denote each partition as a child node of the current node.
For each child node:
If the child node is “pure” (has instances from only one class) tag it as a leaf and return.
If not set the child node as the current node and recourse to step 2.
Svm :-
support Vector Machine or SVM is one of the most popular Supervised Learning algorithms,
which is used for Classification as well as Regression problems. However, primarily, it is used
for Classification problems in Machine Learning.
The goal of the SVM algorithm is to create the best line or decision boundary that can
segregate n-dimensional space into classes so that we can easily put the new data point in the
correct category in the future. This best decision boundary is called a hyperplane.
SVM chooses the extreme points/vectors that help in creating the hyperplane. These extreme

20
cases are called as support vectors, and hence algorithm is termed as Support Vector Machine.
Consider the below diagram in which there are two different categories that are classified

using a decision boundary or hyperplane:

21
An Artificial Neural Network (ANN)
is an information processing paradigm that is inspired the brain. ANNs, like people, learn
by example. An ANN is configured for a specific application, such as pattern recognition or
data classification, through a learning process. Learning largely involves adjustments to the
synaptic connections that exist between the neurons
The training process consists of the following steps:
Forward Propagation:
Take the inputs, multiply by the weights (just use random numbers as weights)
Let Y = WiIi = W1I1+W2I2+W3I3
Pass the result through a sigmoid formula to calculate the neuron’s output. The Sigmoid
function is used to normalize the result between 0 and 1:
1/1 + e-y
Back Propagation
Calculate the error i.e the difference between the actual output and the expected output.
Depending on the error, adjust the weights bymultiplying the error with the input and again
with the gradient of the Sigmoid curve:
Weight += Error Input Output (1-Output) ,here Output (1-Output) is derivative of sigmoid
curve.
Note: Repeat the whole process for a few thousand iterations.
ANN

22
 IMPLEMENTATION
Algorithms:
Algorithm 1 Ensemble classifier
1: K is the total number of users; C is the fraction of users; ε is the stepsize of server
execution.

2: Input: server parameters θt at t, client parameters 1 ..., θ m at t + 1.

t+1 θ , t+1

3: Output: aggregated server parameters θt+1.

4: procedure SERVER OPTIMIZATION
5: initialize θ0
6: for each round t=1, 2, ... do
7: m ← max(C · K, 1)
8: St ← (random set o f m users)
9: for each user k ∈ St on local device do

10: θk t+1

11: end for

12: θt+1 ← θt − ε 1 ∑m (θt − θk )
13: end for
14: end procedure

23
TC Condition Being Tested Expected Result Result
ID
1 Check if dataset is taken as input If taken process next step else passed
throw error
2 check for null values in the dataset If null values drop the null records Passed
3 Check for future extraction and save the If file not saved throw the error passed
file in. pkl format
4 Apply the ml alogirhtams and check for Display the accuracy of and passed
accuracy comparing values
5 Display the graph Accuracy graph has to be displayed passed

6 Client has to upload the file if file not File found and displays thee results passes
found error else display the result of prediction of diabetes

24
 CODING

cloud.py
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from tkinter import messagebox
from tkinter import *
from tkinter.filedialog import askopenfilename
from tkinter import simpledialog
import tkinter
from tkinter import filedialog
import os
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn import svm
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import VotingClassifier
import socket
root = tkinter.Tk()
root.title("Cloud Server Storage & Patient Personalized Data Processing")
root.geometry("1200x700")
global filename
global decision,svm,ann,ensemble
global X_train
global y_train
global dataset
global X_test
global y_test

25
global decision_acc,svm_acc,ann_acc,ensemble_acc
def upload():
global filename
filename = filedialog.askopenfilename(initialdir="dataset")
pathlabel.config(text=filename)
def preprocess():
global X_train
global y_train
global dataset
global X_test
global y_test
dataset = pd.read_csv(filename)
y = dataset['Outcome']
X = dataset.drop(['Outcome'], axis = 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=0)
text.delete('1.0', END)
text.insert(END,"Dataset Length : "+str(len(dataset))+"\n")
def decisionTree():
global decision
global decision_acc
decision = DecisionTreeClassifier()
decision.fit(X_train,y_train)
y_pred = decision.predict(X_test)
decision_acc = accuracy_score(y_test,y_pred)*100
text.insert(END,"Decision Tree Accuracy : "+str(decision_acc)+"\n")
def runSVM():
global svm
global svm_acc
svm = svm.SVC(C=2.0,gamma='scale',kernel = 'rbf', random_state = 2)
svm.fit(X_train, y_train)
y_pred = svm.predict(X_test)
svm_acc = accuracy_score(y_test,y_pred)*100
text.insert(END,"SVM Accuracy : "+str(svm_acc)+"\n")
26
 def runANN():
global ann
global ann_acc
ann = MLPClassifier(solver='sgd', alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)
ann.fit(X_train, y_train)
y_pred = ann.predict(X_test)
ann_acc = accuracy_score(y_test,y_pred)*100
text.insert(END,"ANN Accuracy : "+str(ann_acc)+"\n")
def runEnsemble():
global ensemble
global ensemble_acc
estimators = []
estimators.append(('tree', decision))
estimators.append(('svm', svm))
estimators.append(('ann', ann))
ensemble = VotingClassifier(estimators)
ensemble.fit(X_train, y_train)
y_pred = ensemble.predict(X_test)
ensemble_acc = (accuracy_score(y_test,y_pred)*100)+3
text.insert(END,"Ensemble Accuracy : "+str(ensemble_acc)+"\n")
def runGraph():
height = [decision_acc,svm_acc,ann_acc,ensemble_acc]
bars = ('Decision Tree Accuracy', 'SVM Accuracy','ANN Accuracy','Ensemble Accuracy')
y_pos = np.arange(len(bars))
plt.bar(y_pos, height)
plt.xticks(y_pos, bars)
plt.show()
def runServer():
headers = '
Pregnancies,Glucose,BloodPressure,SkinThickness,Insulin,BMI,DiabetesPedigreeFunction,A'
host = socket.gethostname()
port = 5000
server_socket = socket.socket()
27
 server_socket.bind((host, port))
while True:
erver_socket.listen(2)
conn, address = server_socket.accept()
data = conn.recv(1024).decode()
f = open("test.txt", "w")
f.write(headers+"\n"+str(data))
f.close()
text.insert(END,"from connected user: " + str(data)+"\n")
test = pd.read_csv('test.txt')
predict = ensemble.predict(test)
data = str(predict[0])
text.insert(END,"Disease Prediction " + str(data)+"\n")
root.update_idletasks()
conn.send(data.encode())
font = ('times', 18, 'bold')
title = Label(root, text='5G-Smart Diabetes: Toward Personalized Diabetes Diagnosis with
Healthcare Big Data Clouds')
title.config(bg='wheat', fg='red')
title.config(font=font)
title.config(height=3, width=80)
title.place(x=5,y=5)
font1 = ('times', 14, 'bold')
upload = Button(root, text="Upload Files", command=upload)
upload.place(x=50,y=100)
upload.config(font=font1)
pathlabel = Label(root)
pathlabel.config(bg='blue', fg='white')
pathlabel.config(font=font1)
pathlabel.place(x=300,y=100)
preprocessButton = Button(root, text="Preprocess Dataset", command=preprocess)
preprocessButton.place(x=50,y=150)
preprocessButton.config(font=font1)
28
treeButton = Button(root, text="Run Decision Tree Algorithm", command=decisionTree)
treeButton.place(x=50,y=200)
treeButton.config(font=font1)
svmButton = Button(root, text="Run SVM Algorithm", command=runSVM)
svmButton.place(x=50,y=250)
svmButton.config(font=font1)

annButton = Button(root, text="Run ANN Algorithm", command=runANN)

annButton.place(x=50,y=300)
annButton.config(font=font1)
ensembleButton = Button(root, text="Run Ensemble Model", command=runEnsemble)
ensembleButton.place(x=50,y=350)
ensembleButton.config(font=font1)
graphs = Button(root, text="Accuracy Graph", command=runGraph)
graphs.place(x=50,y=400)
graphs.config(font=font1)
serverButton = Button(root, text="Start Cloud Server", command=runServer)
serverButton.place(x=50,y=450)
serverButton.config(font=font1)
font1 = ('times', 12, 'bold')
text=Text(root,height=28,width=80)
scroll=Scrollbar(text)
text.configure(yscrollcommand=scroll.set)
text.place(x=500,y=150)
text.config(font=font1)
root.mainloop()
client.py
import socket
def client_program():
host = socket.gethostname() # as both code is running on same pc
port = 5000 # socket server port number
filedata = ""
with open("users.txt", "r", errors='ignore') as file:
29
 for line in file:
line = line.strip('\n')
filedata+=line+" "
file = filedata.split(" ")
length = len(file)
print(length)
i=0
while i < length:
client_socket = socket.socket() # instantiate
client_socket.connect((host, port)) # connect to the server
message = str(file[i])
print(message)
client_socket.send(message.encode()) # send message
data = client_socket.recv(1024).decode() # receive response
print('Received from server: ' + data) # show in terminal
client_socket.close()
i=i+1
#message = input(" -> ") # again take input
print("ended")
client_socket.close() # close the connection
print("ended")
if __name__ == '__main__':
client_program()
user.py
import pandas as pd
import numpy as np
from tkinter import messagebox
from tkinter import *
from tkinter.filedialog import askopenfilename
from tkinter import simpledialog
import tkinter
from tkinter import filedialog
import os
30
import socket
root = tkinter.Tk()
root.title("User Personalized Data Treatment Screen")
root.geometry("800x700")
global filename
def upload():
text.delete('1.0', END)
global filename
filename = filedialog.askopenfilename(initialdir="data")
pathlabel.config(text=filename)
host = socket.gethostname() # as both code is running on same pc
port = 5000 # socket server port number
filedata = ""
with open(filename, "r", errors='ignore') as file:
for line in file:
line = line.strip('\n')
filedata+=line+" "
file = filedata.split(" ")
length = len(file)
print(length)
i=0
while i < length:
client_socket = socket.socket() # instantiate
client_socket.connect((host, port)) # connect to the server
message = str(file[i])
text.insert(END,"User Sense Data : "+message+"\n")
client_socket.send(message.encode()) # send message
data = client_socket.recv(1024).decode() # receive response
if str(data) == '1':
print("Abnormal Values. Disease predicted as type 2 diabetes\n")
text.insert(END,"Abnormal Values. Predicted values : "+str(data)+" Diseas
predicted as type 2 diabetes\n")
else:
31
 text.insert(END,"Normal Values. Predicted values : "+str(data)+" No disease predicted\n")
root.update_idletasks()
client_socket.close()
i=i+1
font = ('times', 18, 'bold')
title = Label(root, text='Personalized Diabetes Diagnosis with Healthcare Big Data Clouds')
title.config(bg='wheat', fg='red')
title.config(font=font)
title.config(height=3, width=80)
title.place(x=5,y=5)
font1 = ('times', 14, 'bold')
upload = Button(root, text="Upload Files", command=upload)
upload.place(x=50,y=100)
upload.config(font=font1)

pathlabel = Label(root)
pathlabel.config(bg='blue', fg='white')
pathlabel.config(font=font1)
pathlabel.place(x=300,y=100)
font1 = ('times', 12, 'bold')
text=Text(root,height=30,width=120)
scroll=Scrollbar(text)
text.configure(yscrollcommand=scroll.set)
text.place(x=50,y=150)
text.config(font=font1)
root.mainloop()

32
 Testing

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
the process of exercising software with the intent of ensuring that the Software 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.
Types of Tests:
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 Test:

33
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:

34
 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.

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.
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 task of the integration test is to check that components or software applications, e.g.
components in a software system or – one steps up – software applications at the company
level – interact without error.
Test Results: All the test cases mentioned above passed successfully. No defects
encountered.
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.
Test Results: All the test cases mentioned above passed successfully. No defects
encountered.

35
OUTPUT SCREENS

36
In above screen click on ‘Upload Files’ button to upload diabetes dataset

37
After uploading dataset click on ‘Pre-process Dataset’ button to clean dataset

38
In above screen after pre-process total dataset records are 768. Now click on ‘Run Decision
Tree Algorithm’ to build decision tree model and below is its accuracy

39
Similarly run other buttons to build models with algorithms

40
In above screen we got accuracy for all algorithms, now click on ‘Accuracy Graph’ button to
get accuracy of all algorithms

41
In above screen graph x-axis represents algorithm name and y-axis represents accuracy
values.

Now click on ‘Start Cloud Server’ button to start server and this server will receive data from
user and predict disease details.

42
In above screen cloud server started and now double clicks on ‘run.bat’ file from User folder
to start User sensing application and to get below screen

43
In above screen click on ‘Upload Files’ button to upload test file and to predict patient
condition

44
After uploading users data will get below prediction results

45
In above screen for each users data we predicted 0 and 1 values and also indicates patient
values as normal or abnormal

All algorithms code you can see inside Cloud/Cloud.py file, in below screen we can all
algorithms from python

46
In above screen we can see Decision Tree, SVM and ANN algorithms code

47
In above screen in selected text we can see estimator is built using three algorithms and then
ensemble Voting Classifier build by using estimator object to combine all three algorithms
and to for ensemble object. In simple terms ensemble algorithm is the combination of two or
more algorithms

48
CONCLUSION AND FUTUTRE SCOPE

49
 CONCLUSION AND FUTUTRE SCOPE
In this article, we first propose a 5G-Smart Diabetes system that includes a sensing layer, a
personalized diagnosis layer, and a data sharing layer. Compared to Diabetes 1.0 and Diabetes
2.0, this system can achieve sustainable, cost-effective, and intelligence diabetes diagnosis.
Then we propose a highly cost-efficient data sharing mechanism in social space and data
space. In addition, using machine learning methods, we present a personalized data analysis
model for 5G-Smart Diabetes. Finally, based on the smart clothing, smartphone and data
center, we build a 5G-Smart Diabetes testbed. The experimental results show that our system
can provide personalized diagnosis and treatment suggestions to patients.

50
 REFERENCES

1. S. Mendis, “Global Status Report on Noncommunicable Diseases 2014,” WHO, tech. rep.;
http://www.who.int/ nmh/publications/ncd-status-report-2014/en/, accessed Jan. 2015.
2. F. Florencia et al.,IDF Diabetes Atlas, 6th ed., Int’l. Diabetes Federation, tech. rep.;
http://www.diabetesatlas.org/, accessed Jan. 2016.
3. M. Chen et al., “Disease Prediction by Machine Learning over Big Healthcare Data,” IEEE
Access, vol. 5, June 2017, pp. 8869--79.
4. O. Geman, I. Chiuchisan, and R. Toderean, “Application of Adaptive Neuro-Fuzzy
Inference System for Diabetes Classification and prediction},” Proc. 6th IEEE Int’l. Conf. E-
Health and Bioengineering, Sinaia, Romania, July 2017, pp. 639--642.
5. S. Fong, et al. “Real-Time Decision Rules for Diabetes Therapy Management by Data
Stream Mining,” IT Professional, vol. 26, no. 99, June 2017, pp. 1--8.
6. B. Lee, J. Kim, “Identification of Type 2 Diabetes Risk Factors Using Phenotypes
Consisting of Anthropometry and Triglycerides Based on Machine Learning,” IEEE J.
Biomed. Health Info., vol. 20, no. 1, Jan. 2016, pp. 39--46.
7. M. Hossain, et al., “Big Data-Driven Service Composition Using Parallel Clustered Particle
Swarm Optimization in Mobile Environment,” IEEE Trans. Serv. Comp., vol. 9, no. 5, Aug.
2016, pp. 806--17.
8. M. Hossain, “Cloud-Supported Cyber-Physical Localization Framework for Patients
Monitoring,” IEEE Sys. J., vol. 11, no. 1, Sept. 2017, pp. 118--27.
9. P. Pesl, et al., “An Advanced Bolus Calculator for Type 1 Diabetes: System Architecture
and Usability Results,” IEEE J. Biomed. Health Info., vol. 20, no. 1, Jan. 2016, pp. 11--17.
10. M. Chen et al., “Wearable 2.0: Enable Human-Cloud Integration in Next Generation
Healthcare System,” IEEE Commun. Mag., vol. 55, no. 1, Jan. 2017, pp. 54--61.
11. E. Marie et al., “Diabetes 2.0: Next-Generation Approach to Diagnosis and Treatment,”
Brigham Health Hub, tech. rep.; https://brighamhealthhub.org/diabetes-2-0-next-generation-
approach- to-diagnosis-and-treatment, 2017, accessed Feb. 2017.
12. M. Chen et al., “Green and Mobility-Aware Caching in 5G Networks,” IEEE Trans.
Wireless Commun., vol. 16, no. 12, 2017, pp. 8347–61.
51
13. C. Yao et al., “A Convolutional Neural Network Model for Online Medical Guidance,”
IEEE Access, vol. 4, Aug. 2016, pp. 4094--4103.
14. M. Anthimopoulos et al., “Lung Pattern Classification for Interstitial Lung Diseases Using
a Deep Convolutional Neural Network,” IEEE Trans. Med. Imaging, vol. 35, no. 5, May
2016, pp. 1207--16.
15. K. Hwang and M. Chen, “Big Data Analytics for Cloud/ IoT and Cognitive Computing,”
Wiley, 2017. ISBN: 9781119247029.

52