## refrigeratorOutput);
## refrigeratorTrainer4.addSingleObservation([refrigeratorEntry1,\
## refrigeratorEntry2,\
## refrigeratorEntry3,\
## refrigeratorEntry4],\
## refrigeratorOutput);
# Update old observations to set up for the next iteration
refrigeratorEntry1 = refrigeratorEntry2;
refrigeratorEntry2 = refrigeratorEntry3;
refrigeratorEntry3 = refrigeratorEntry4;
if (refrigeratorOutput > 0):
print("High Value found!\n");
refrigeratorTrainer1.train();
##refrigeratorTrainer2.train();
##refrigeratorTrainer3.train();
##refrigeratorTrainer4.train();
##pickleFileRef = open(refrigeratorPickleFile, 'wb');
##pickle.dump(refrigeratorTrainer, pickleFileRef);
##else:
## pickleFileRef = open(fridgePickleFile, 'rb');
## fridgeTrainer = pickle.load(pickleFileRef);
print(refrigeratorTrainer1.numObservations);
print(refrigeratorTrainer1.coefficientVector[0]);
# Refrigerator
(timestamp, refrigeratorEntry) = refrigeratorTrace.readline().split();
refrigeratorEntry = float(refrigeratorEntry);
(timestamp, refrigeratorOutput) = refrigeratorOutputTrace.readline().split();
refrigeratorOutput = int(refrigeratorOutput);
refrigeratorTrainer.addSingleObservation([refrigeratorEntry], refrigeratorOutput);
# Stove
(timestamp, stoveEntry) = stoveTrace.readline().split();
stoveEntry = float(stoveEntry);
(timestamp, stoveOutput) = stoveOutputTrace.readline().split();
stoveOutput = int(stoveOutput);
stoveTrainer.addSingleObservation([stoveEntry], stoveOutput);
# Train the individual appliances.
kitchOut2Trainer.train();
kitchOut3Trainer.train();
kitchOut4Trainer.train();
microwaveTrainer.train();
oven01Trainer.train();
oven02Trainer.train();
refrigeratorTrainer.train();
stoveTrainer.train();
# Pickle the Tesla objects, to prevent them from needing to be trained again.
kitchOut2PickleFileRef = open(kitchOut2PickleFilename, 'wb');
pickle.dump(kitchOut2Trainer, kitchOut2PickleFileRef);
kitchOut3PickleFileRef = open(kitchOut3PickleFilename, 'wb');
pickle.dump(kitchOut3Trainer, kitchOut3PickleFileRef);
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]);
output = float(outputRow[0]);
firstTS = time.time();
theor = algorithmTest.execute([input1, input2]);
secondTS = time.time();
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])
firstTS = time.time()
theor = algorithmTest.execute(inputs)
secondTS = time.time()
teslaTimestamps["test" + str(executeSample)] = secondTS - firstTS
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]);
output = float(outputRow[0]);
firstTS = time.time();
theor = algorithmTest.execute([input1, input2]);
secondTS = time.time();
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;
# Refrigerator
(timestamp, refrigeratorEntry) = refrigeratorTrace.readline().split();
refrigeratorEntry = float(refrigeratorEntry);
(timestamp, refrigeratorOutput) = refrigeratorOutputTrace.readline().split();
refrigeratorOutput = int(refrigeratorOutput);
refrigeratorTrainer.addSingleObservation([refrigeratorEntry], refrigeratorOutput);
# Stove
(timestamp, stoveEntry) = stoveTrace.readline().split();
stoveEntry = float(stoveEntry);
(timestamp, stoveOutput) = stoveOutputTrace.readline().split();
stoveOutput = int(stoveOutput);
stoveTrainer.addSingleObservation([stoveEntry], stoveOutput);
# Train the individual appliances.
kitchOut2Trainer.train();
kitchOut3Trainer.train();
kitchOut4Trainer.train();
microwaveTrainer.train();
oven01Trainer.train();
oven02Trainer.train();
refrigeratorTrainer.train();
stoveTrainer.train();
# Pickle the Tesla objects, to prevent them from needing to be trained again.
kitchOut2PickleFileRef = open(kitchOut2PickleFilename, 'wb');
pickle.dump(kitchOut2Trainer, kitchOut2PickleFileRef);
kitchOut3PickleFileRef = open(kitchOut3PickleFilename, 'wb');
pickle.dump(kitchOut3Trainer, kitchOut3PickleFileRef);
