-
Notifications
You must be signed in to change notification settings - Fork 1
/
UDPServer.py
136 lines (121 loc) · 4.06 KB
/
UDPServer.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
'''
GUI to make real time predictions
and calculate calory consumption
'''
from kivy.support import install_twisted_reactor
install_twisted_reactor()
from twisted.internet import reactor
from twisted.internet import protocol
from kivy.app import App
from kivy.uix.label import Label
from kivy.properties import ObjectProperty
from kivy.uix.widget import Widget
from kivy.clock import Clock
import pandas as pd
import os, pickle, socket
import numpy as np
import scipy.stats as stats
from statsmodels.robust.scale import mad as mediad
from sklearn.naive_bayes import GaussianNB
from collections import deque
activities = {
0: 'Stationary',
1: 'Walking',
2: 'Running',
}
def get_parameters(data):
'''
perform aggregates on
rolling windows of 410
after scaling and normalizing
This function seems to be faster,
no unnecessary calculations
'''
func_dict = {
'min': np.min,
'max': np.max,
'diff': lambda x: np.max(x) - np.min(x),
#'mean': np.mean,
'std': np.std,
'iqr': stats.iqr,
'rms': lambda x: np.sqrt(np.mean(np.square(x))),
#'integral': np.trapz,
'mad': lambda x: x.mad(),
'mediad': mediad
}
aggregations = {
'X': func_dict,
'Y': func_dict,
'Z': func_dict
}
#data[['X', 'Y', 'Z']] = preprocessing.scale(preprocessing.MinMaxScaler().fit_transform(data[['X', 'Y', 'Z']]))
#data[['X', 'Y', 'Z']] = preprocessing.scale(data[['X', 'Y', 'Z']])
data['temp'] = 10
data = data.groupby('temp', as_index=False)
stats_data = data.agg(aggregations)
# correlations = data[['X', 'Y', 'Z']].corr().unstack()
# correlations.columns = correlations.columns.droplevel()
# correlations.columns = ['XX', 'XY', 'XZ', 'YX', 'YY', 'YZ', 'ZX', 'ZY', 'ZZ']
# correlations = correlations.drop(['XX', 'YY', 'ZZ', 'YX', 'XZ', 'ZY'], axis=1)
stats_data.columns = [''.join(col).strip() for col in stats_data.columns.values]
#tats_data = pd.concat([stats_data], axis=1)
del stats_data['temp']
return stats_data
class EchoProtocol(protocol.DatagramProtocol):
def __init__(self, app):
self.app = app
def datagramReceived(self, data, addr):
self.app.handle_message(data)
class TestWidget(Widget):
x_reading = ObjectProperty(None)
y_reading = ObjectProperty(None)
z_reading = ObjectProperty(None)
sample_rate = ObjectProperty(None)
activity_label = ObjectProperty(None)
calorie_label = ObjectProperty(None)
calories = 0
calorie_rate = 0
X = deque(maxlen=300)
Y = deque(maxlen=300)
Z = deque(maxlen=300)
NBModel = pickle.load(open('NBModel2.pkl', 'rb'))
count = 0
def show_sample_rate(self, dt):
self.sample_rate.text = "{0:.2f}".format((self.count + float(self.sample_rate.text))/2)
if self.count != 0:
data_frame = pd.DataFrame({
'X': self.X,
'Y': self.Y,
'Z': self.Z,
}
)
activity = self.NBModel.predict(
get_parameters(data_frame)
)[0]
if activity == 1:
self.calories += 0.064
if activity == 2:
self.calories += 0.176
self.activity_label.text = activities[activity]
self.count = 0
self.calorie_rate += 1
if self.calorie_rate == 5:
self.calorie_label.text = "{0:.2f}".format((self.calories))
self.calorie_rate = 0
def handle_message(self, msg):
x, y, z = str(msg, 'utf-8').strip().split(',')
self.x_reading.text = x
self.y_reading.text = y
self.z_reading.text = z
self.X.append(float(x))
self.Y.append(float(y))
self.Z.append(float(z))
self.count += 1
class TwistedServerApp(App):
def build(self):
ui = TestWidget()
reactor.listenUDP(5000, EchoProtocol(ui))
Clock.schedule_interval(ui.show_sample_rate, 1.0)
return ui
if __name__ == '__main__':
TwistedServerApp().run()