if (not os.path.isfile(kitchOut2PickleFilename \
and kitchOut3PickleFilename \
and kitchOut4PickleFilename \
and microwavePickleFilename \
and oven01PickleFilename \
and oven02PickleFilename \
and refrigeratorPickleFilename \
and stovePickleFilename)):
# Add observations to the appropriate tesla training objects
for i in range(0, 10000):
# Kitchen Outlets 2
(timestamp, kitchOut2Entry) = kitchOut2Trace.readline().split();
kitchOut2Entry = float(kitchOut2Entry);
(timestamp, kitchOut2Output) = kitchOut2OutputTrace.readline().split();
kitchOut2Output = int(kitchOut2Output);
kitchOut2Trainer.addSingleObservation([kitchOut2Entry], kitchOut2Output);
# Kitchen Outlets 3
(timestamp, kitchOut3Entry) = kitchOut3Trace.readline().split();
kitchOut3Entry = float(kitchOut3Entry);
(timestamp, kitchOut3Output) = kitchOut3OutputTrace.readline().split();
kitchOut3Output = int(kitchOut3Output);
kitchOut3Trainer.addSingleObservation([kitchOut3Entry], kitchOut3Output);
# Kitchen Outlets 4
(timestamp, kitchOut4Entry) = kitchOut4Trace.readline().split();
kitchOut4Entry = float(kitchOut4Entry);
(timestamp, kitchOut4Output) = kitchOut4OutputTrace.readline().split();
kitchOut4Output = int(kitchOut4Output);
kitchOut4Trainer.addSingleObservation([kitchOut4Entry], kitchOut4Output);
## Change the name of the algorithm to test it out.
algorithmTest = Tesla(Complexity.firstOrder, 2, 0, [0, 0], {});
teslaTimestamps = {};
knnTimestamps = {};
for trainingSample in range(numTrainingSamples):
inputRow = next(inputReader);
outputRow = next(outputReader);
if (len(inputRow) > 0):
input1 = float(inputRow[0]);
input2 = float(inputRow[1]);
output = float(outputRow[0]);
firstTS = time.time();
algorithmTest.addSingleObservation([input1, input2], output);
secondTS = time.time();
teslaTimestamps["load" + str(trainingSample)] = secondTS - firstTS;
firstTS = time.time();
algorithmTest.train();
secondTS = time.time();
teslaTimestamps["train"] = secondTS - firstTS;
runningTotal = 0;
for executeSample in range(numExecuteSamples):
inputRow = next(inputReader);
outputRow = next(outputReader);
if (len(inputRow) > 0):
input1 = float(inputRow[0]);
input2 = float(inputRow[1]);
refrigeratorPickleFile2 = 'traces/refrigeratorTrained2.dat';
refrigeratorPickleFile3 = 'traces/refrigeratorTrained3.dat';
refrigeratorPickleFile4 = 'traces/refrigeratorTrained4.dat';
# Open the files needed: input trace and output observations
refrigeratorTrace = open('traces/refrigerator.dat', mode='r');
refrigeratorOutputTrace = open('traces/refrigerator_obs.dat', mode='r');
# First, parse the first 3 elements, needed as additional inputs
# Add observations to the appropriate tesla training objects# First observation
# First observation
(timestamp, refrigeratorEntry1) = refrigeratorTrace.readline().split();
refrigeratorEntry1 = float(refrigeratorEntry1);
(timestamp, refrigeratorOutput) = refrigeratorOutputTrace.readline().split();
refrigeratorOutput = int(refrigeratorOutput);
refrigeratorTrainer1.addSingleObservation([refrigeratorEntry1], refrigeratorOutput);
# Second observation
(timestamp, refrigeratorEntry2) = refrigeratorTrace.readline().split();
refrigeratorEntry2 = float(refrigeratorEntry2);
(timestamp, refrigeratorOutput) = refrigeratorOutputTrace.readline().split();
refrigeratorOutput = int(refrigeratorOutput);
refrigeratorTrainer1.addSingleObservation([refrigeratorEntry2],\
refrigeratorOutput);
refrigeratorTrainer2.addSingleObservation([refrigeratorEntry1,\
refrigeratorEntry2],\
refrigeratorOutput);
# Third observation
(timestamp, refrigeratorEntry3) = refrigeratorTrace.readline().split();
refrigeratorEntry3 = float(refrigeratorEntry3);
(timestamp, refrigeratorOutput) = refrigeratorOutputTrace.readline().split();
refrigeratorOutput = int(refrigeratorOutput);
## Change the name of the algorithm to test it out.
algorithmTest = Tesla(Complexity.firstOrder, 1, 0, [0, 0], {});
teslaTimestamps = {};
knnTimestamps = {};
for trainingSample in range(numTrainingSamples):
inputRow = next(inputReader);
outputRow = next(outputReader);
if (len(inputRow) > 0):
input1 = float(inputRow[0]);
input2 = float(inputRow[1]);
output = float(outputRow[0]);
firstTS = time.time();
algorithmTest.addSingleObservation([input1, input2], output);
secondTS = time.time();
teslaTimestamps["load" + str(trainingSample)] = secondTS - firstTS;
print(str(trainingSample))
firstTS = time.time();
algorithmTest.train();
secondTS = time.time();
teslaTimestamps["train"] = secondTS - firstTS;
runningTotal = 0;
for executeSample in range(numExecuteSamples):
inputRow = next(inputReader);
outputRow = next(outputReader);
if (len(inputRow) > 0):
input1 = float(inputRow[0]);
input2 = float(inputRow[1]);
outputReader = csv.reader(outputFile)
## Change the name of the algorithm to test it out.
algorithmTest = Tesla(complexity, numInputs, 0, [0] * numInputs, {})
teslaTimestamps = {}
knnTimestamps = {}
for trainingSample in range(numTrainingSamples):
inputRow = next(inputReader)
outputRow = next(outputReader)
if (len(inputRow) > 0):
inputs = [float(x) for x in inputRow[0:numInputs]]
output = float(outputRow[0])
firstTS = time.time()
algorithmTest.addSingleObservation(inputs, output)
secondTS = time.time()
teslaTimestamps["load" + str(trainingSample)] = secondTS - firstTS
print(str(trainingSample))
firstTS = time.time()
algorithmTest.train()
secondTS = time.time()
teslaTimestamps["train"] = secondTS - firstTS
runningTotal = 0
for executeSample in range(numExecuteSamples):
inputRow = next(inputReader)
outputRow = next(outputReader)
if (len(inputRow) > 0):
inputs = [float(x) for x in inputRow[0:numInputs]]
output = float(outputRow[0])
# Depending on which trial, offset the starting point for obtaining training samples
try:
inputRow = next(inputReader);
outputRow = next(outputReader);
except:
inputFile.seek(0);
outputFile.seek(0);
inputRow = next(inputReader);
outputRow = next(outputReader);
if (len(inputRow) > 0):
inputVec = [ float(x) for x in inputRow ]
output = float(outputRow[0]);
firstTS = time.time();
algorithmTest.addSingleObservation(inputVec, output);
secondTS = time.time();
teslaTimestamps["load" + str(trainingSample)] = secondTS - firstTS;
else:
print("Error reading training samples");
sys.exit();
firstTS = time.time();
algorithmTest.train();
secondTS = time.time();
teslaTimestamps["train"] = secondTS - firstTS;
## Load samples and TEST
runningTotal = 0;
for executeSample in range(numExecuteSamples):
try:
class PecanStreetCE():
def __init__(self, funcOrder=3, numOfInputs=2, numHistoryStates=0):
self.inputData = []
self.outputData = []
self.flexCE = Tesla(order=funcOrder, numInputs=(numOfInputs+numHistoryStates));
self.aggregatedError = 0.0;
self.aggregatedCount = 0;
self.errorNumerator = 0.0;
self.errorDenominator = 0;
self.predictedList = [];
self.actualList = [];
self.testSetPredictedList = [];
self.testSetActualList = [];
self.numInputs = numOfInputs;
self.numHistoryStates = numHistoryStates;
def runTesla(self, csvFilepath):
with open(csvFilepath) as csvFile:
reader = csv.reader(csvFile);
i = 0;
for row in reader:
inputList = [];
historyList = [];
outputValue = 0.0;
if (i != 0 and i < self.numHistoryStates):
self.predictedList.append(0.0);
self.actualList.append(float(row[self.numInputs]));
elif (i != 0):
# Append the appropriate number of values from the CSV file to the input list.
for j in range(0,self.numInputs):
inputList.append(float(row[j]));
# Generate a list of history states to append to the inputs
for k in range(0, self.numHistoryStates):
historyList.append(-1-k);
# Append the history state as an additional inputs.
inputList += historyList;
outputValue = float(row[self.numInputs]);
self.inputData.append(inputList);
self.outputData.append(outputValue);
if (i >= self.numHistoryStates and i <= 17500):
self.flexCE.addSingleObservation(inputList,
outputValue);
# Append garbage data to predicted, since this is training.
self.predictedList.append(0.0);
self.actualList.append(outputValue);
elif (i > 17500 and i <= 35000):
predicted = self.flexCE.test(inputList);
if (predicted < 0):
predicted = 0.0;
actual = outputValue;
self.aggregatedError += pow(actual-predicted, 2);
self.aggregatedCount += 1;
# print(str(actual), "\t", str(predicted))
self.errorNumerator += abs((actual-predicted));
self.errorDenominator += 1;
self.predictedList.append(predicted);
self.actualList.append(actual);
self.testSetPredictedList.append(predicted);
self.testSetActualList.append(actual);
elif (i > 35000):
print(str(time.clock()));
break;
if (i == 17500):
print("Training data loaded");
startTime = time.clock()
self.flexCE.train();
elapsedTime = time.clock() - startTime;
print("CE trained, elapsed time:",
str(elapsedTime));
print(str(time.clock()));
i+=1;
class CitisenseCE():
def __init__(self):
self.outData = []
self.tuplesCovered = []
self.aqiTrainingLUT = {}
self.aqiTestLUT = {}
self.dateTimeLUT = {}
self.dateTimeCE = Tesla(order=2, numInputs=2);
self.coarseLatCE = Tesla(order=3, numInputs=1);
self.coarseLngCE = Tesla(order=3, numInputs=1);
self.aqiCE = Tesla(order=3, numInputs=3);
def enumerateAQI(self, rawValue):
if (rawValue < 0.0):
return -1;
elif (rawValue <= 50.0):
return 0;
elif (rawValue <= 100.0):
return 1;
elif (rawValue <= 150.0):
return 2;
elif (rawValue <= 200.0):
return 3;
elif (rawValue <= 300.0):
return 4;
else:
return 5;
def truncate(self, f, n):
'''Truncates/pads a float f to n decimal places without rounding'''
s = '%.12f' % f
i, p, d = s.partition('.')
return '.'.join([i, (d+'0'*n)[:n]])
def genLUTs(self):
with open('../traces/aqiOnly.csv', 'r') as csvFile:
reader = csv.reader(csvFile)
index = 0
for row in reader:
if (not index == 0) and (len(row) > 0):
reading = float(row[6])
date = datetime.datetime.strptime(row[7]+"00", "%Y-%m-%d %H:%M:%S%z")
coarseLat = float(self.truncate(float(row[8]), 6))
coarseLng = float(self.truncate(float(row[9]), 6))
dateInt = date.hour*60+date.minute
if (index <= 1400):
self.coarseLatCE.addSingleObservation([float(row[8])], coarseLat);
self.coarseLngCE.addSingleObservation([float(row[9])], coarseLng);
if (date.hour, date.minute) not in self.dateTimeLUT:
self.dateTimeLUT[(date.hour, date.minute)] = dateInt
self.dateTimeCE.addSingleObservation([date.hour, date.minute], dateInt);
if (coarseLat, coarseLng, dateInt) in self.aqiTrainingLUT:
print("Duplicate found! "
+ str(reading)
+ " vs. "
+ str(self.aqiTrainingLUT[(coarseLat, coarseLng, dateInt)]));
continue;
else:
self.aqiTrainingLUT[(coarseLat, coarseLng, dateInt)] = reading;
self.aqiCE.addSingleObservation([coarseLat, coarseLng, dateInt], reading);
elif (index <= 2000):
self.aqiTestLUT[(coarseLat, coarseLng, dateInt)] = reading;
else:
break;
index += 1;
if (not os.path.isfile(kitchOut2PickleFilename \
and kitchOut3PickleFilename \
and kitchOut4PickleFilename \
and microwavePickleFilename \
and oven01PickleFilename \
and oven02PickleFilename \
and refrigeratorPickleFilename \
and stovePickleFilename)):
# Add observations to the appropriate tesla training objects
for i in range(0, 10000):
# Kitchen Outlets 2
(timestamp, kitchOut2Entry) = kitchOut2Trace.readline().split();
kitchOut2Entry = float(kitchOut2Entry);
(timestamp, kitchOut2Output) = kitchOut2OutputTrace.readline().split();
kitchOut2Output = int(kitchOut2Output);
kitchOut2Trainer.addSingleObservation([kitchOut2Entry], kitchOut2Output);
# Kitchen Outlets 3
(timestamp, kitchOut3Entry) = kitchOut3Trace.readline().split();
kitchOut3Entry = float(kitchOut3Entry);
(timestamp, kitchOut3Output) = kitchOut3OutputTrace.readline().split();
kitchOut3Output = int(kitchOut3Output);
kitchOut3Trainer.addSingleObservation([kitchOut3Entry], kitchOut3Output);
# Kitchen Outlets 4
(timestamp, kitchOut4Entry) = kitchOut4Trace.readline().split();
kitchOut4Entry = float(kitchOut4Entry);
(timestamp, kitchOut4Output) = kitchOut4OutputTrace.readline().split();
kitchOut4Output = int(kitchOut4Output);
kitchOut4Trainer.addSingleObservation([kitchOut4Entry], kitchOut4Output);
outputReader = csv.reader(outputFile)
## Change the name of the algorithm to test it out.
algorithmTest = Tesla(Complexity.firstOrder, 1, 0, [0], {})
teslaTimestamps = {}
knnTimestamps = {}
for trainingSample in range(numTrainingSamples):
inputRow = next(inputReader)
outputRow = next(outputReader)
if (len(inputRow) > 0):
input1 = float(inputRow[0])
output = float(outputRow[0])
firstTS = time.time()
algorithmTest.addSingleObservation([input1], output)
secondTS = time.time()
teslaTimestamps["load" + str(trainingSample)] = secondTS - firstTS
print(str(trainingSample))
firstTS = time.time()
algorithmTest.train()
secondTS = time.time()
teslaTimestamps["train"] = secondTS - firstTS
runningTotal = 0
for executeSample in range(numExecuteSamples):
inputRow = next(inputReader)
outputRow = next(outputReader)
if (len(inputRow) > 0):
input1 = float(inputRow[0])
output = float(outputRow[0])
