import csv
from KalmanFilter import KalmanFilter
with open('SmallHouse.csv', 'r') as csvfile:
so = csv.reader(csvfile, delimiter=';', quotechar='"')
so = list(so)
import matplotlib.pyplot as plt
sensor1 = []
for i in range(1, len(so)):
sensor1.append(float(so[i][2]))
#for i in range(1, len(so)):
#if (so[i][2] == 0.0 or so[i][3] == 0.0 or so[i][4] == 0.0):
# so.pop(i)
q = 0.001
errorArray = []
qvalues = []
while (q <= 1.001):
kFilter1 = KalmanFilter(1, 1, q)
error = 0.0
for j in range(0, len(sensor1)):
error = error + abs((kFilter1.updateEstimate(sensor1[j]) - sensor1[j]))
errorArray.append(error / (float(len(sensor1))))
qvalues.append(q)
q = q + 0.001
print(q)
plt.plot(qvalues, errorArray)
plt.plot(sensor2)
plt.subplot(2, 2, 3)
plt.plot(sensor3)
#addseconds = []
#k = 0
#for i in range(0, len(time)):
# addseconds.append(k)
# k = k+30
#d = datetime.datetime(2018,9,3, 00,00)
#print (d)
#x = [d + datetime.timedelta(seconds=i) for i in addseconds]
#print (x)
#plt.plot(x,sensor3, label="Raw sensor data")
for i in range(0, len(sensor1)):
sensor1[i] = kFilter1.updateEstimate(sensor1[i])
sensor2[i] = kFilter2.updateEstimate(sensor2[i])
sensor3[i] = kFilter3.updateEstimate(sensor3[i])
plt.subplot(2, 2, 1)
plt.plot(sensor1)
plt.subplot(2, 2, 2)
plt.plot(sensor2)
plt.subplot(2, 2, 3)
plt.plot(sensor3)
#plt.plot(x,sensor3, label="Kalman filtered data")
#plt.legend(loc='upper left')
#plt.ylim([-1.0,40])
#plt.title("Raw sensor data and kalman filtered data with Q = 1")
#plt.xlabel("Sensor reading number")
print("Sensor " + str(sensorID) + " ADC reading: ",
adcValue)
if (adcValue != 0):
R_th = 1000.0 / ((1023.0 / (1023 - adcValue)) - 1.0)
T = round(
1.0 / ((1.0 / 298.15) + (1.0 / 3800.0) *
(np.log(R_th / 1000.0))) - 273.15, 2)
print("Sensor " + str(sensorID) + " Temperature: " +
str(T))
if sensorID == 0:
receivedValues[2] = T
adcSensorValues[0] = readMessage[2]
adcSensorValues[1] = readMessage[3]
neuralNetworkReadings[0] = neuralNetReading
T = round(kFilter1.updateEstimate(T), 2)
if (canImpute == True):
error1 = round(
abs(impute0(receivedValues, 1) - T) / (T) *
100.0, 2)
print("Sensor 0 error: " + str(error1))
e1r.set(str(error1))
print("Sensor 0 filtered temperature: " + str(T))
s1r.set(str(T))
sensor1Online.set("Yes")
root.update()
if sensorID == 1:
receivedValues[3] = T
adcSensorValues[2] = readMessage[2]
adcSensorValues[3] = readMessage[3]
T = round(kFilter2.updateEstimate(T), 2)
def train(nodes, layers, n_neuralnets, epochs, sensorNumber):
#nodes = number of hidden nodes in hidden layer
#layers = number of hidden layers
#n_neuralnets = number neuralnets in the initial population
#epochs = number of training runs
#sensorNumber = which sensor to train
starttime = timer.time()
time = []
sensor1 = []
sensor2 = []
sensor3 = []
kFilter1 = KalmanFilter(1, 1, 0.01)
kFilter2 = KalmanFilter(1, 1, 0.01)
kFilter3 = KalmanFilter(1, 1, 0.01)
with open('ProjectDemonstration.csv', 'r') as csvfile:
data = csv.reader(csvfile, delimiter=';', quotechar='"')
data = list(data)
for i in range(7000, len(data)):
for j in range(0, len(data[i])):
data[i][j] = float(data[i][j])
time.append(data[i][1])
sensor1.append(kFilter1.updateEstimate(data[i][2]))
sensor2.append(kFilter2.updateEstimate(data[i][3]))
sensor3.append(kFilter3.updateEstimate(data[i][4]))
normalise(time, sensor1, sensor2, sensor3)
trainingErrors = []
testErrors = []
neuralnets = []
for i in range(0, n_neuralnets):
neuralnets.append(NeuralNetwork(nodes, layers))
trainingErrors.append(0)
testErrors.append(0)
populationSize = len(neuralnets)
trainingSet = []
testSet = []
trainingTargets = []
testTargets = []
if sensorNumber == 0: #train a sensor for node 1
for i in range(0, len(sensor1)):
if random.randint(1, 100) <= 60:
trainingSet.append([sensor2[i], sensor3[i], time[i]])
trainingTargets.append(sensor1[i])
else:
testSet.append([sensor2[i], sensor3[i], time[i]])
testTargets.append(sensor1[i])
elif sensorNumber == 1: #train a sensor for node 2
for i in range(0, len(sensor1)):
if random.randint(1, 100) <= 60:
trainingSet.append([sensor1[i], sensor3[i], time[i]])
trainingTargets.append(sensor2[i])
else: #train a sensor for node 3
testSet.append([sensor1[i], sensor3[i], time[i]])
testTargets.append(sensor2[i])
elif sensorNumber == 2:
for i in range(0, len(sensor1)):
if random.randint(1, 100) <= 60:
trainingSet.append([sensor1[i], sensor2[i], time[i]])
trainingTargets.append(sensor3[i])
else:
testSet.append([sensor1[i], sensor2[i], time[i]])
testTargets.append(sensor3[i])
TrainingLoss = []
TestLoss = []
for i in range(0, epochs): # for every epoch
fitPopulation = []
for j in range(
0, len(neuralnets)): #for every neural net in the population
for k in range(0, len(
trainingSet)): #for every data point in the training set
output = neuralnets[j].predict(trainingSet[k])
trainingErrors[j] = trainingErrors[j] + abs(
trainingTargets[k] - output)
trainingErrors[j] = trainingErrors[j] / len(trainingTargets)
for j in range(0, len(neuralnets)):
for k in range(0, len(testSet)):
output = neuralnets[j].predict(testSet[k])
testErrors[j] = testErrors[j] + abs(testTargets[k] - output)
testErrors[j] = testErrors[j] / len(testTargets)
for j in range(0, int(len(neuralnets) /
10)): #Get top 10% of the population
smallest = 1.01
position = 0
for k in range(0, len(neuralnets)):
if smallest > trainingErrors[k]:
position = k
smallest = trainingErrors[k]
fitPopulation.append([
neuralnets.pop(position),
trainingErrors.pop(position),
testErrors.pop(position)
])
neuralnets = []
trainingErrors = []
testErrors = []
for j in range(0, populationSize):
trainingErrors.append(0)
testErrors.append(0)
for j in range(0, len(fitPopulation)):
neuralnets.append(fitPopulation[j][0])
for j in range(0, int(populationSize / 10.0 *
9.0)): #repopulate the population
p1NeuralNet = fitPopulation[random.randint(0,
len(fitPopulation) - 1)]
p2NeuralNet = fitPopulation[random.randint(0,
len(fitPopulation) - 1)]
while (p1NeuralNet == p2NeuralNet
): #ensure always two unique parents
p2NeuralNet = fitPopulation[random.randint(
0,
len(fitPopulation) - 1)]
p1Probability = 1.0 - (p1NeuralNet[1] /
(p1NeuralNet[1] + p2NeuralNet[1]))
cNeuralNet = NeuralNetwork(nodes, layers)
newWeight = []
for k in range(0, len(cNeuralNet.weights)):
if (p1Probability >= random.uniform(0.0, 1.0)):
newWeight.append(p1NeuralNet[0].weights[k])
else:
newWeight.append(p2NeuralNet[0].weights[k])
cNeuralNet.setWeights(newWeight)
if random.uniform(0.0, 1.0) <= 0.02: #2% chance to mutate a gene
cNeuralNet.weights[random.randint(
0,
len(cNeuralNet.weights) - 1)] = round(
random.uniform(-1.0, 1.0) * 1000000.0) / 1000000.0
#Randomly generate a new weight for a gene
neuralnets.append(cNeuralNet)
sys.stdout.write('\rEpoch: ' + str(i + 1) + ", Hidden Nodes: " +
str(nodes) + ", Training Loss: " +
str(fitPopulation[0][1]) + ", Test Loss: " +
str(fitPopulation[0][2]) + ", Elapsed Time: " +
str(round(timer.time() - starttime)))
TrainingLoss.append(fitPopulation[0][1])
TestLoss.append(fitPopulation[0][2])
if (i == epochs - 1):
return (fitPopulation[0], TrainingLoss, TestLoss)
