def __init__(self,
modelConfig,
inferenceArgs,
metricSpecs,
sourceSpec,
sinkSpec=None):
"""Initialization.
Args:
modelConfig: The model config dict.
metricSpecs: A sequence of MetricSpec instances.
sourceSpec: Path to the source CSV file.
sinkSpec: Path to the sink CSV file.
"""
self.model = ModelFactory.create(modelConfig)
self.model.enableInference(inferenceArgs)
self.metricsManager = MetricsManager(metricSpecs,
self.model.getFieldInfo(),
self.model.getInferenceType())
self.sink = None
if sinkSpec is not None:
# TODO: make this work - sinkSpec not yet supported.
raise NotImplementedError('The sinkSpec is not yet implemented.')
#self.sink = BasicPredictionLogger(
# self.model.getFieldInfo(), sinkSpec, 'myOutput',
# self.model.getInferenceType())
#self.sink.setLoggedMetrics(
# self.metricsManager.getMetricLabels())
self.datasetReader = BasicDatasetReader(sourceSpec)
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'consumption'})
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
with open(_INPUT_FILE_PATH) as fin:
reader = csv.reader(fin)
headers = reader.next()
reader.next()
reader.next()
for i, record in enumerate(reader, start=1):
modelInput = dict(zip(headers, record))
modelInput["consumption"] = float(modelInput["consumption"])
modelInput["timestamp"] = datetime.datetime.strptime(
modelInput["timestamp"], "%m/%d/%y %H:%M")
result = model.run(modelInput)
result.metrics = metricsManager.update(result)
isLast = i == _NUM_RECORDS
if i % 100 == 0 or isLast:
_LOGGER.info(
"After %i records, 1-step altMAPE=%f", i,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=consumption"])
if isLast:
break
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'consumption'})
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
with open (_INPUT_FILE_PATH) as fin:
reader = csv.reader(fin)
headers = reader.next()
reader.next()
reader.next()
for i, record in enumerate(reader, start=1):
modelInput = dict(zip(headers, record))
modelInput["consumption"] = float(modelInput["consumption"])
modelInput["timestamp"] = datetime.datetime.strptime(
modelInput["timestamp"], "%m/%d/%y %H:%M")
result = model.run(modelInput)
result.metrics = metricsManager.update(result)
isLast = i == _NUM_RECORDS
if i % 100 == 0 or isLast:
_LOGGER.info("After %i records, 1-step altMAPE=%f", i,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=consumption"])
if isLast:
break
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS,
model.getFieldInfo(),
model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
self.shifter = InferenceShifter()
self.dates = deque(maxlen=WINDOW)
self.convertedDates = deque(maxlen=WINDOW)
self.actualValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.predictedValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.linesInitialized = False
self.actualLines = None
self.predictedLines = None
self.shouldScheduleDraw = True
fig = plt.figure(figsize=(6.1, 11))
plotCount = 1
gs = gridspec.GridSpec(plotCount, 1)
self.graph = fig.add_subplot(gs[0, 0])
plt.xlabel('Date')
plt.ylabel('Consumption (kW)')
plt.tight_layout()
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS,
model.getFieldInfo(),
model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
def runIoThroughNupic(inputData, model, name, plot):
inputFile = open(inputData, "rb")
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if len(plot) == 0:
for field in SWARM_DESCRIPTION["includedFields"]:
plot.append(field["fieldName"])
output = nupic_output.NuPICFileOutput(name, plot)
else:
output = nupic_output.NuPICPlotOutput(name, plot)
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
data = {}
fldCounter = 0
for field in SWARM_DESCRIPTION["includedFields"]:
data[field["fieldName"]] = translate_data(field["fieldType"], row[fldCounter])
fldCounter += 1
result = model.run(data)
result.metrics = metricsManager.update(result)
if options.verbose is not None and counter % 100 == 0:
print "Read %i lines..." % counter
print ("After %i records, 1-step altMAPE=%f" % (counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field="+PREDICTED_FIELD]))
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
vals = []
for field in plot:
vals.append(data[field])
output.write(vals, prediction)
inputFile.close()
output.close()
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
self.shifter = InferenceShifter()
self.dates = deque(maxlen=WINDOW)
self.convertedDates = deque(maxlen=WINDOW)
self.actualValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.predictedValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.linesInitialized = False
self.actualLines = None
self.predictedLines = None
self.shouldScheduleDraw = True
fig = plt.figure(figsize=(6.1, 11))
plotCount = 1
gs = gridspec.GridSpec(plotCount, 1)
self.graph = fig.add_subplot(gs[0, 0])
plt.xlabel('Date')
plt.ylabel('Consumption (kW)')
plt.tight_layout()
class HotGym(CLASanityModel):
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(), model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
def step(self):
self.counter += 1
self.timestampStr, self.consumptionStr = self.inputs.next()
timestamp = datetime.datetime.strptime(self.timestampStr, "%m/%d/%y %H:%M")
consumption = float(self.consumptionStr)
result = self.model.run({"timestamp": timestamp, "kw_energy_consumption": consumption})
result.metrics = self.metricsManager.update(result)
if self.counter % 100 == 0:
print "Read %i lines..." % self.counter
print (
"After %i records, 1-step altMAPE=%f"
% (
self.counter,
result.metrics[
"multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=kw_energy_consumption"
],
)
)
def getInputDisplayText(self):
return (["time", self.timestampStr], ["power consumption (kW)", self.consumptionStr])
class HotGym(CLASanityModel):
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS,
model.getFieldInfo(),
model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
def step(self):
self.counter += 1
self.timestampStr, self.consumptionStr = self.inputs.next()
timestamp = datetime.datetime.strptime(self.timestampStr,
"%m/%d/%y %H:%M")
consumption = float(self.consumptionStr)
result = self.model.run({
"timestamp": timestamp,
"kw_energy_consumption": consumption,
})
result.metrics = self.metricsManager.update(result)
if self.counter % 100 == 0:
print "Read %i lines..." % self.counter
print("After %i records, 1-step altMAPE=%f" %
(self.counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=kw_energy_consumption"]))
def getInputDisplayText(self):
return (["time", self.timestampStr],
["power consumption (kW)", self.consumptionStr])
def runIoThroughNupic(inputData, model, gymName, plot):
inputFile = open(inputData, "rb")
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_output.NuPICPlotOutput([gymName])
else:
output = nupic_output.NuPICFileOutput([gymName])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
timestamp = datetime.datetime.strptime(row[0], DATE_FORMAT)
consumption = float(row[1])
result = model.run({
"timestamp": timestamp,
"kw_energy_consumption": consumption
})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print("After %i records, 1-step altMAPE=%f" %
(counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=kw_energy_consumption"]))
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
output.write([timestamp], [consumption], [prediction])
if plot and counter % 20 == 0:
output.refreshGUI()
inputFile.close()
output.close()
def runCPU():
"""Poll CPU usage, make predictions, and plot the results. Runs forever."""
# Create the model for predicting CPU usage.
model = ModelFactory.create(model_params.MODEL_PARAMS)
model.enableInference({'predictedField': 'cpu'})
# Create a metrics manager for computing an error metric.
metricsManager = MetricsManager(METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
# The shifter will align prediction and actual values.
shifter = InferenceShifter()
# Keep the last WINDOW predicted and actual values for plotting.
actHistory = deque([0.0] * WINDOW, maxlen=60)
predHistory = deque([0.0] * WINDOW, maxlen=60)
# Initialize the plot lines that we will update with each new record.
actline, = plot(range(WINDOW), actHistory)
predline, = plot(range(WINDOW), predHistory)
# Set the y-axis range.
actline.axes.set_ylim(0, 100)
predline.axes.set_ylim(0, 100)
while True:
s = time.time()
# Get the CPU usage.
cpu = psutil.cpu_percent()
# Run the input through the model and shift the resulting prediction.
modelInput = {'cpu': cpu}
result = shifter.shift(model.run(modelInput))
# Compute an error metric (not currently used).
result.metrics = metricsManager.update(result)
# Update the trailing predicted and actual value deques.
inference = result.inferences['multiStepBestPredictions'][5]
if inference is not None:
actHistory.append(result.rawInput['cpu'])
predHistory.append(inference)
# Redraw the chart with the new data.
actline.set_ydata(actHistory) # update the data
predline.set_ydata(predHistory) # update the data
draw()
# Make sure we wait a total of 2 seconds per iteration.
time.sleep(SECONDS_PER_STEP - (time.time() - s))
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(), model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
def runIoThroughNupic(inputData, model, gymName, plot):
inputFile = open(inputData, "rb")
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_output.NuPICPlotOutput([gymName])
else:
output = nupic_output.NuPICFileOutput([gymName])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
timestamp = datetime.datetime.strptime(row[0], DATE_FORMAT)
consumption = float(row[1])
result = model.run({
"timestamp": timestamp,
"kw_energy_consumption": consumption
})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print ("After %i records, 1-step altMAPE=%f" % (counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=kw_energy_consumption"]))
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
output.write([timestamp], [consumption], [prediction])
if plot and counter % 20 == 0:
output.refreshGUI()
inputFile.close()
output.close()
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'Volume'})
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
with open (findDataset(_DATA_PATH)) as fin:
reader = csv.reader(fin)
headers = reader.next()
for i, record in enumerate(reader, start=1):
modelInput = dict(zip(headers, record))
modelInput["Volume"] = float(modelInput["Volume"])
result = model.run(modelInput)
result.metrics = metricsManager.update(result)
isLast = i == _NUM_RECORDS
if i % 100 == 0 or isLast:
print result.metrics
if isLast:
break
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'consumption'})
metricsManager = MetricsManager(METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
with open(findDataset(DATA_PATH)) as fin:
reader = csv.reader(fin)
headers = reader.next()
reader.next()
reader.next()
for record in reader:
modelInput = dict(zip(headers, record))
modelInput["consumption"] = float(modelInput["consumption"])
modelInput["timestamp"] = datetime.datetime.strptime(
modelInput["timestamp"], "%Y-%m-%d %H:%M:%S.%f")
result = model.run(modelInput)
result.metrics = metricsManager.update(result)
print result
def runIoThroughNupic( inputData, model, textName, word_list ):
inputFile = open(inputData, "rb")
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
output = nupic_output.NuPICFileOutput([textName])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
model.enableLearning()
counter = 0
for row in csvReader:
counter += 1
reset_flag = bool( row[0] )
word_num = int( row[1] )
if reset_flag:
print( 'resetting model' )
model.resetSequenceStates()
result = model.run({
"word_num": word_num
})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print ("After %i records, 1-step altMAPE=%f", counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=word_num"])
model.finishLearning()
model.save( MODEL_DIR )
inputFile.close()
output.close()
def runIoThroughNupic(inputData, model, modelName, plot):
inputFile = open(inputData, "rb")
csvReader = csv.reader(inputFile)
# skip header rows
headers = csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_anomaly_output.NuPICPlotOutput(modelName)
else:
output = nupic_anomaly_output.NuPICFileOutput(modelName)
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
timestamp = datetime.datetime.strptime(row[0], DATE_FORMAT)
consumption = float(row[1])
result = model.run({
"Time": timestamp,
PREDICTED_FIELD: consumption
})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print ("After %i records, 1-step altMAPE=%f", counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=%s" % PREDICTED_FIELD])
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
anomalyScore = result.inferences["anomalyScore"]
output.write(timestamp, consumption, prediction, anomalyScore)
inputFile.close()
output.close()
def __init__(self, modelParamsPath, savedModelsPath, steps):
"""
Initialise the class with setup variables and metric manager
:param modelParamsPath: The model params pather to use if no saved models path is found
:param savedModelsPath: The models path where the model is persisted to file
:param steps: The number of steps to predict into the future
:return:
"""
self.modelParamsPath = modelParamsPath
self.savedModelsPath = savedModelsPath
self.fieldToPredict = "numberOfDeliveries"
self.steps = steps
self.metricSpecs = self.defineMetricSpecs()
self.model = self.getModel()
self.metricsManager = MetricsManager(self.metricSpecs,
self.model.getFieldInfo(),
self.model.getInferenceType())
def runIoThroughNupic(inputData, model, modelName, plot):
inputFile = open(inputData, "rb")
csvReader = csv.reader(inputFile)
# skip header rows
headers = csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_anomaly_output.NuPICPlotOutput(modelName)
else:
output = nupic_anomaly_output.NuPICFileOutput(modelName)
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
timestamp = datetime.datetime.strptime(row[0], DATE_FORMAT)
consumption = float(row[1])
result = model.run({"Time": timestamp, PREDICTED_FIELD: consumption})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print(
"After %i records, 1-step altMAPE=%f", counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=%s" % PREDICTED_FIELD])
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
anomalyScore = result.inferences["anomalyScore"]
output.write(timestamp, consumption, prediction, anomalyScore)
inputFile.close()
output.close()
def runIoThroughNupic(inputData, model, dataName, plot):
inputFile = open(inputData, "rU")
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_output.NuPICPlotOutput([dataName])
else:
output = nupic_output.NuPICFileOutput([dataName])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
y = float(row[0])
result = model.run({
"y": y
})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print ("After %i records, 1-step nrmse=%f", counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='nrmse':steps=1:window=1000000:"
"field=y"])
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
output.write([0], [y], [prediction])
inputFile.close()
output.close()
def runIoThroughNupic(inputData, model, dataName, plot):
inputFile = open(inputData, "rU")
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_output.NuPICPlotOutput([dataName])
else:
output = nupic_output.NuPICFileOutput([dataName])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
for row in csvReader:
counter += 1
y = float(row[0])
result = model.run({"y": y})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print(
"After %i records, 1-step nrmse=%f", counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='nrmse':steps=1:window=1000000:"
"field=y"])
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
output.write([0], [y], [prediction])
inputFile.close()
output.close()
def _init_model(self, model):
model.enableInference({"predictedField": self.PredictedField})
metrics = ['aae', 'altMAPE', 'rmse']
windows = [
self.PredictedSteps * 100, self.PredictedSteps * 10,
self.PredictedSteps
]
metric_specs = list()
for w in windows:
for m in metrics:
metric_specs.append(
MetricSpec(field=self.PredictedField,
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={
'errorMetric': m,
'window': w,
'steps': self.PredictedSteps
}))
self.Metrics = MetricsManager(metric_specs, model.getFieldInfo(),
model.getInferenceType())
self.Model = model
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'consumption'})
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
with open (findDataset(_DATA_PATH)) as fin:
reader = csv.reader(fin)
headers = reader.next()
print headers[0], headers[1]
record = reader.next()
print record
record = reader.next()
print record
record1 = reader.next()
timestamp1 = time.mktime(datetime.datetime.strptime(record1[0], "%m/%d/%y %H:%M").timetuple())
print timestamp1
record2 = reader.next()
timestamp2 = time.mktime(datetime.datetime.strptime(record2[0], "%m/%d/%y %H:%M").timetuple())
print record2[0], record2[1]
print timestamp2-timestamp1
for i, record in enumerate(reader, start=1):
modelInput = dict(zip(headers, record))
modelInput["consumption"] = float(modelInput["consumption"])
modelInput["timestamp"] = datetime.datetime.strptime(
modelInput["timestamp"], "%m/%d/%y %H:%M")
result = model.run(modelInput)
#print result
#import sys; sys.exit()
result.metrics = metricsManager.update(result)
isLast = i == _NUM_RECORDS
if i % 10 == 0 or isLast:
_LOGGER.info("After %i records, 1-step altMAPE=%f", i,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=consumption"])
if isLast:
break
def init_metrics(self):
metric_list = []
# create a MetricSpec for each level of inference
for i in self.steps:
metric_list.append(
MetricSpec(field='value',
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={'errorMetric': 'altMAPE',
'window': 384,
'steps': i
}
)
)
# convert specs to tuple and initialize metrics manager
metric_specs = tuple(metric_list)
self.metrics_manager = MetricsManager(metric_specs,
self.model.getFieldInfo(),
self.model.getInferenceType())
def __init__(self, modelConfig, inferenceArgs, metricSpecs, sourceSpec,
sinkSpec=None):
"""Initialization.
Args:
modelConfig: The model config dict.
metricSpecs: A sequence of MetricSpec instances.
sourceSpec: Path to the source CSV file.
sinkSpec: Path to the sink CSV file.
"""
self.model = ModelFactory.create(modelConfig)
self.model.enableInference(inferenceArgs)
self.metricsManager = MetricsManager(metricSpecs, self.model.getFieldInfo(),
self.model.getInferenceType())
self.sink = None
if sinkSpec is not None:
# TODO: make this work - sinkSpec not yet supported.
raise NotImplementedError('The sinkSpec is not yet implemented.')
#self.sink = BasicPredictionLogger(
# self.model.getFieldInfo(), sinkSpec, 'myOutput',
# self.model.getInferenceType())
#self.sink.setLoggedMetrics(
# self.metricsManager.getMetricLabels())
self.datasetReader = BasicDatasetReader(sourceSpec)
class Run(object):
def __init__(self, modelParamsPath, savedModelsPath, steps):
"""
Initialise the class with setup variables and metric manager
:param modelParamsPath: The model params pather to use if no saved models path is found
:param savedModelsPath: The models path where the model is persisted to file
:param steps: The number of steps to predict into the future
:return:
"""
self.modelParamsPath = modelParamsPath
self.savedModelsPath = savedModelsPath
self.fieldToPredict = "numberOfDeliveries"
self.steps = steps
self.metricSpecs = self.defineMetricSpecs()
self.model = self.getModel()
self.metricsManager = MetricsManager(self.metricSpecs,
self.model.getFieldInfo(),
self.model.getInferenceType())
def createModelFromParams(self, modelParams):
"""
Creates a model fromt the provided model parameters file
:param modelParams:
:return:
"""
model = ModelFactory.create(modelParams)
model.enableInference({"predictedField": self.fieldToPredict})
return model
def defineMetricSpecs(self):
"""
Define the metric properties for nupic model
:return:
"""
metricSpecs = (MetricSpec(field=self.fieldToPredict,
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={
'errorMetric': 'aae',
'window': 1000,
'steps': self.steps
}),
MetricSpec(field=self.fieldToPredict,
metric='trivial',
inferenceElement='prediction',
params={
'errorMetric': 'aae',
'window': 1000,
'steps': self.steps
}),
MetricSpec(field=self.fieldToPredict,
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={
'errorMetric': 'altMAPE',
'window': 1000,
'steps': self.steps
}),
MetricSpec(field=self.fieldToPredict,
metric='trivial',
inferenceElement='prediction',
params={
'errorMetric': 'altMAPE',
'window': 1000,
'steps': self.steps
}))
return metricSpecs
def getModelParams(self):
"""
Get the model parameters object
:return:
"""
log.info("Importing model params from %s" % self.modelParamsPath)
moduleName = os.path.basename(self.modelParamsPath)
importedModelParams = imp.load_source(moduleName, self.modelParamsPath)
return importedModelParams.MODEL_PARAMS
def getModel(self):
"""
Get the existing model from file or create
from model params if not already existing
:return:
"""
# Check if the dir is empty
if os.path.exists(self.savedModelsPath) and os.listdir(
self.savedModelsPath):
log.info("Loading model from checkpoint %s" % self.savedModelsPath)
model = ModelFactory.loadFromCheckpoint(self.savedModelsPath)
else:
log.info("Creating model from %s..." % self.modelParamsPath)
model = self.createModelFromParams(self.getModelParams())
return model
def predict(self, timestamp, amountOfJobs):
"""
Run a single timestamp and amount value through nupic
and return the prediction for the next hour of jobs
:param timestamp:
:param amountOfJobs:
:return:
"""
result = self.model.run({
"timestamp": timestamp,
self.fieldToPredict: float(amountOfJobs)
})
result.metrics = self.metricsManager.update(result)
prediction = float(
result.inferences["multiStepBestPredictions"][self.steps])
return prediction
def saveModel(self):
"""
Save the model to file
:return:
"""
log.info("Saving model to %s..." % self.savedModelsPath)
self.model.save(self.savedModelsPath)
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'consumption'})
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
# The shifter will align prediction and actual values.
shifter = InferenceShifter()
# Keep the last WINDOW predicted and actual values for plotting.
actHistory = deque([0.0] * WINDOW, maxlen=60)
predHistory = deque([0.0] * WINDOW, maxlen=60)
# Initialize the plot lines that we will update with each new record.
actline, = plt.plot(range(WINDOW), actHistory)
predline, = plt.plot(range(WINDOW), predHistory)
# Set the y-axis range.
actline.axes.set_ylim(0, 100)
predline.axes.set_ylim(0, 100)
with open (findDataset(_DATA_PATH)) as fin:
reader = csv.reader(fin)
headers = reader.next()
reader.next()
reader.next()
for i, record in enumerate(reader, start=1):
modelInput = dict(zip(headers, record))
modelInput["consumption"] = float(modelInput["consumption"])
modelInput["timestamp"] = datetime.datetime.strptime(
modelInput["timestamp"], "%m/%d/%y %H:%M")
result = model.run(modelInput)
shifted_result = shifter.shift(result);
# Update the trailing predicted and actual value deques.
inference = shifted_result.inferences['multiStepBestPredictions'][1]
if inference is not None:
actHistory.append(shifted_result.rawInput['consumption'])
predHistory.append(inference)
# Redraw the chart with the new data.
actline.set_ydata(actHistory) # update the data
predline.set_ydata(predHistory) # update the data
plt.draw()
plt.legend( ('actual','predicted') )
# Make sure we wait a total of SECONDS_PER_STEP seconds per iteration.
try:
plt.pause(SECONDS_PER_STEP)
except:
pass
result.metrics = metricsManager.update(result)
isLast = i == _NUM_RECORDS
if i % 100 == 0 or isLast:
_LOGGER.info("After %i records, 1-step altMAPE=%f", i,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=consumption"])
if isLast:
break
class ModelController(Process):
def __init__(self, market, conn):
super(ModelController, self).__init__()
# runtime vars
self.market = market
self.conn = conn
self.data_queue = deque()
# set opf vars and instantiate model
self.steps = [1, 3, 6, 12, 24, 48, 96]
# TODO check if a model exists, if not create one
params = self.get_params('alg.model_params.temporal-multistep_params')
self.create_model(params)
# Multiprocessing entry point
def run(self):
# spawn a worker thread to queue incoming data
worker = threading.Thread(target=self.queuer)
worker.daemon = True
worker.start()
# Compute items in queue
# spinner spinner hey we have a spinner
while True:
while not self.data_queue:
time.sleep(0.1)
# get oldest queue item and compute
datapoint = self.data_queue.popleft()
result = self.iterate(datapoint)
# send result to Pipe
self.conn.send(result)
# just in case
worker.join()
# Data queuer thread
def queuer(self):
while True:
# send all incoming data to the deque
# should block when there are no incoming messages
self.data_queue.append(self.conn.recv())
# initialize metrics manager
def init_metrics(self):
metric_list = []
# create a MetricSpec for each level of inference
for i in self.steps:
metric_list.append(
MetricSpec(field='value',
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={'errorMetric': 'altMAPE',
'window': 384,
'steps': i
}
)
)
# convert specs to tuple and initialize metrics manager
metric_specs = tuple(metric_list)
self.metrics_manager = MetricsManager(metric_specs,
self.model.getFieldInfo(),
self.model.getInferenceType())
# for save/load, use alg/models dir always
# load model from file
def load_model(self, name):
name = os.path.abspath(name)
self.model = ModelFactory.loadFromCheckpoint(name)
# save model to file
def save_model(self, name):
name = os.path.abspath(name)
self.model.save(name)
# create model from params
def create_model(self, params):
# create model
self.model = ModelFactory.create(params)
# set init params
self.model.enableLearning()
self.model.enableInference({'predictedField': 'value'})
# init metrics
self.init_metrics()
# import model params from file
def get_params(self, name):
try:
params = importlib.import_module(name).MODEL_PARAMS
except ImportError:
raise Exception("No model exists called %s, need to run swarming algorithm" % name)
return params
# iterate through a single datapoint
def iterate(self, datapoint):
# compute
result = self.model.run(datapoint)
# run metrics
metrics = self.metrics_manager.update(result)
# scrape metrics and construct clean version
result.metrics = {}
for key in metrics:
for i in self.steps:
string = ':steps=' + str(i) + ':'
if string in key:
result.metrics[i] = metrics[key]
return (self.market, result)
def model_create(request):
guid = str(uuid4())
metrics = None
inferenceArgs = None
try:
params = request.json_body
if 'params' in request.json_body:
params = request.json_body['params']
if 'metrics' in request.json_body:
metrics = request.json_body['metrics']
if 'inferenceArgs' in request.json_body:
inferenceArgs = request.json_body['inferenceArgs']
except ValueError:
params = None
if params:
if 'guid' in params:
guid = params['guid']
if guid in models.keys():
request.response.status = 409
return {'error': 'The guid "' + guid + '" is not unique.'}
if 'modelParams' not in params:
request.response.status = 400
return {
'error':
'POST body must include JSON with a modelParams value.'
}
msg = 'Used provided model parameters'
else:
params = importlib.import_module(
'model_params.model_params').MODEL_PARAMS['modelConfig']
print 'Using default model, timestamp is field c0'
model = ModelFactory.create(params)
if inferenceArgs is None:
inferenceArgs = dict(predictedField='c1')
print 'Using default predictedField c1'
if inferenceArgs["predictedField"] is None:
print 'No prediciton field'
inferenceShifter = None
else:
model.enableInference(inferenceArgs)
print model_create, guid, 'inferenceType', model.getInferenceType()
print model_create, guid, 'inferenceArgs', model.getInferenceArgs()
inferenceShifter = InferenceShifter()
#if metrics:
#_METRIC_SPECS = (MetricSpec(field=metric['field'],
#metric=metric['metric'],
# inferenceElement=metric['inferenceElement'],
# params=metric['params'])
# for metric in metrics)
if inferenceArgs["predictedField"] is not None and params[
'predictAheadTime'] is not None:
_METRIC_SPECS = (
MetricSpec(field=inferenceArgs["predictedField"],
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={
'errorMetric': 'aae',
'window': 1000,
'steps': params['predictAheadTime']
}),
MetricSpec(field=inferenceArgs["predictedField"],
metric='trivial',
inferenceElement='prediction',
params={
'errorMetric': 'aae',
'window': 1000,
'steps': params['predictAheadTime']
}),
MetricSpec(field=inferenceArgs["predictedField"],
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={
'errorMetric': 'altMAPE',
'window': 1000,
'steps': params['predictAheadTime']
}),
MetricSpec(field=inferenceArgs["predictedField"],
metric='trivial',
inferenceElement='prediction',
params={
'errorMetric': 'altMAPE',
'window': 1000,
'steps': params['predictAheadTime']
}),
)
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
else:
metricsManager = None
models[guid] = {
'model': model,
'inferenceArgs': inferenceArgs,
'inferenceShifter': inferenceShifter,
'params': params,
'seen': 0,
'last': None,
'alh': anomaly_likelihood.AnomalyLikelihood(),
'tfield': find_temporal_field(params),
'metrics': metrics,
'metricsManager': metricsManager
}
print "Made model", guid
return serialize_model(guid)
print model._spLearningEnabled
printTPRegionParams(model._getTPRegion())
inputData = "%s/%s.csv" % (DATA_DIR, dataSet.replace(" ", "_"))
sensor = model._getSensorRegion()
encoderList = sensor.getSelf().encoder.getEncoderList()
if sensor.getSelf().disabledEncoder is not None:
classifier_encoder = sensor.getSelf().disabledEncoder.getEncoderList()
classifier_encoder = classifier_encoder[0]
else:
classifier_encoder = None
_METRIC_SPECS = getMetricSpecs(predictedField, stepsAhead=_options.stepsAhead)
metric = metrics.getModule(_METRIC_SPECS[0])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
if plot:
plotCount = 1
plotHeight = max(plotCount * 3, 6)
fig = plt.figure(figsize=(14, plotHeight))
gs = gridspec.GridSpec(plotCount, 1)
plt.title(predictedField)
plt.ylabel('Data')
plt.xlabel('Timed')
plt.tight_layout()
plt.ion()
print "Load dataset: ", dataSet
df = pd.read_csv(inputData, header=0, skiprows=[1, 2])
def runIoThroughNupic(inputData, model, gymName, plot):
inputFile = open(inputData, "rb")
#csvReader = csv.reader(inputFile)
csvReader = csv.reader(inputFile)
# skip header rows
csvReader.next()
csvReader.next()
csvReader.next()
shifter = InferenceShifter()
if plot:
output = nupic_output.NuPICPlotOutput([gymName])
else:
output = nupic_output.NuPICFileOutput([gymName])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
counter = 0
#not quite sure best way to handle missing data, but for now use
#last good value
for row in csvReader:
counter += 1
timestamp = datetime.datetime.strptime(row[0], DATE_FORMAT)
try:
temp = float(row[1])
except:
temp = temp
try:
dewpt = float(row[2])
except:
dewpt=dewpt
try:
wind = float(row[3])
except:
wind=wind
is_daylight = int(row[4])
elapsed = int(row[5])
kwh = float(row[6])
result = model.run({
"timestamp": timestamp,
"temp":temp,
"dewpt":dewpt,
"wind": wind,
"is_daylight":is_daylight,
"elapsed":elapsed,
"kwh":kwh,
})
result.metrics = metricsManager.update(result)
if counter % 100 == 0:
print "Read %i lines..." % counter
print ("After %i records, 1-step altMAPE=%f", counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=10:"
"field=kwh"])
if plot:
result = shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
output.write([timestamp], [kwh], [prediction])
inputFile.close()
output.close()
class Client(object):
""" Simple OPF client. """
def __init__(self, modelConfig, inferenceArgs, metricSpecs, sourceSpec,
sinkSpec=None):
"""Initialization.
Args:
modelConfig: The model config dict.
metricSpecs: A sequence of MetricSpec instances.
sourceSpec: Path to the source CSV file.
sinkSpec: Path to the sink CSV file.
"""
self.model = ModelFactory.create(modelConfig)
self.model.enableInference(inferenceArgs)
self.metricsManager = MetricsManager(metricSpecs, self.model.getFieldInfo(),
self.model.getInferenceType())
self.sink = None
if sinkSpec is not None:
# TODO: make this work - sinkSpec not yet supported.
raise NotImplementedError('The sinkSpec is not yet implemented.')
#self.sink = BasicPredictionLogger(
# self.model.getFieldInfo(), sinkSpec, 'myOutput',
# self.model.getInferenceType())
#self.sink.setLoggedMetrics(
# self.metricsManager.getMetricLabels())
self.datasetReader = BasicDatasetReader(sourceSpec)
def __iter__(self):
return self
def _processRecord(self, inputRecord):
modelResult = self.model.run(inputRecord)
modelResult.metrics = self.metricsManager.update(modelResult)
if self.sink:
self.sink.writeRecord(modelResult)
return modelResult
def next(self):
record = self.datasetReader.next()
return self._processRecord(record)
def skipNRecords(self, n):
for i in range(n):
self.datasetReader.next()
def nextTruthPrediction(self, field):
record = self.datasetReader.next()
prediction=self._processRecord(record).inferences['prediction'][0]
truth=record[field]
return truth, prediction
def run(self):
result = None
while True:
try:
result = self.next()
#print result
except StopIteration:
break
return result
class Client(object):
""" Simple OPF client. """
def __init__(self,
modelConfig,
inferenceArgs,
metricSpecs,
sourceSpec,
sinkSpec=None):
"""Initialization.
Args:
modelConfig: The model config dict.
metricSpecs: A sequence of MetricSpec instances.
sourceSpec: Path to the source CSV file.
sinkSpec: Path to the sink CSV file.
"""
self.model = ModelFactory.create(modelConfig)
self.model.enableInference(inferenceArgs)
self.metricsManager = MetricsManager(metricSpecs,
self.model.getFieldInfo(),
self.model.getInferenceType())
self.sink = None
if sinkSpec is not None:
# TODO: make this work - sinkSpec not yet supported.
raise NotImplementedError('The sinkSpec is not yet implemented.')
#self.sink = BasicPredictionLogger(
# self.model.getFieldInfo(), sinkSpec, 'myOutput',
# self.model.getInferenceType())
#self.sink.setLoggedMetrics(
# self.metricsManager.getMetricLabels())
self.datasetReader = BasicDatasetReader(sourceSpec)
def __iter__(self):
return self
def _processRecord(self, inputRecord):
modelResult = self.model.run(inputRecord)
modelResult.metrics = self.metricsManager.update(modelResult)
if self.sink:
self.sink.writeRecord(modelResult)
return modelResult
def next(self):
record = self.datasetReader.next()
return self._processRecord(record)
def skipNRecords(self, n):
for i in range(n):
self.datasetReader.next()
def nextTruthPrediction(self, field):
record = self.datasetReader.next()
prediction = self._processRecord(record).inferences['prediction'][0]
truth = record[field]
return truth, prediction
def run(self):
result = None
while True:
try:
result = self.next()
#print result
except StopIteration:
break
return result
def runHotgym():
model = createModel()
model.enableInference({'predictedField': 'consumption'})
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
# The shifter will align prediction and actual values.
shifter = InferenceShifter()
# Keep the last WINDOW predicted and actual values for plotting.
actHistory = deque([0.0] * WINDOW, maxlen=60)
predHistory = deque([0.0] * WINDOW, maxlen=60)
# Initialize the plot lines that we will update with each new record.
actline, = plt.plot(range(WINDOW), actHistory)
predline, = plt.plot(range(WINDOW), predHistory)
# Set the y-axis range.
actline.axes.set_ylim(0, 100)
predline.axes.set_ylim(0, 100)
with open(findDataset(_DATA_PATH)) as fin:
reader = csv.reader(fin)
headers = reader.next()
reader.next()
reader.next()
for i, record in enumerate(reader, start=1):
modelInput = dict(zip(headers, record))
modelInput["consumption"] = float(modelInput["consumption"])
modelInput["timestamp"] = datetime.datetime.strptime(
modelInput["timestamp"], "%m/%d/%y %H:%M")
result = model.run(modelInput)
shifted_result = shifter.shift(result)
# Update the trailing predicted and actual value deques.
inference = shifted_result.inferences['multiStepBestPredictions'][
1]
if inference is not None:
actHistory.append(shifted_result.rawInput['consumption'])
predHistory.append(inference)
# Redraw the chart with the new data.
actline.set_ydata(actHistory) # update the data
predline.set_ydata(predHistory) # update the data
plt.draw()
plt.legend(('actual', 'predicted'))
# Make sure we wait a total of SECONDS_PER_STEP seconds per iteration.
try:
plt.pause(SECONDS_PER_STEP)
except:
pass
result.metrics = metricsManager.update(result)
isLast = i == _NUM_RECORDS
if i % 100 == 0 or isLast:
_LOGGER.info(
"After %i records, 1-step altMAPE=%f", i,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=consumption"])
if isLast:
break
class HotGym(CLASanityModel):
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS,
model.getFieldInfo(),
model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
self.shifter = InferenceShifter()
self.dates = deque(maxlen=WINDOW)
self.convertedDates = deque(maxlen=WINDOW)
self.actualValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.predictedValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.linesInitialized = False
self.actualLines = None
self.predictedLines = None
self.shouldScheduleDraw = True
fig = plt.figure(figsize=(6.1, 11))
plotCount = 1
gs = gridspec.GridSpec(plotCount, 1)
self.graph = fig.add_subplot(gs[0, 0])
plt.xlabel('Date')
plt.ylabel('Consumption (kW)')
plt.tight_layout()
def draw(self):
self.shouldScheduleDraw = True
self.graph.relim()
self.graph.autoscale_view(True, True, True)
plt.draw()
plt.legend(('actual', 'predicted'), loc=3)
def step(self):
self.counter += 1
self.timestampStr, self.consumptionStr = self.inputs.next()
timestamp = datetime.datetime.strptime(self.timestampStr,
"%m/%d/%y %H:%M")
consumption = float(self.consumptionStr)
result = self.model.run({
"timestamp": timestamp,
"kw_energy_consumption": consumption,
})
result.metrics = self.metricsManager.update(result)
if self.counter % 100 == 0:
print "Read %i lines..." % self.counter
print("After %i records, 1-step altMAPE=%f" %
(self.counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=kw_energy_consumption"]))
result = self.shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
if not self.linesInitialized:
self.dates += deque([timestamp] * WINDOW)
self.convertedDates += [date2num(date) for date in self.dates]
addedLinesActual, = self.graph.plot(self.dates, self.actualValues,
'r')
self.actualLines = addedLinesActual
predictedLinesActual, = self.graph.plot(self.dates,
self.predictedValues, 'b')
self.predictedLines = predictedLinesActual
self.graph.xaxis.set_major_formatter(DateFormatter("%H:%M"))
self.linesInitialized = True
self.dates.append(timestamp)
self.convertedDates.append(date2num(timestamp))
self.actualValues.append(consumption)
self.predictedValues.append(prediction)
self.actualLines.set_xdata(self.convertedDates)
self.actualLines.set_ydata(self.actualValues)
self.predictedLines.set_xdata(self.convertedDates)
self.predictedLines.set_ydata(self.predictedValues)
if self.shouldScheduleDraw:
# If we're stepping the model really quickly, coalesce the redraws.
self.shouldScheduleDraw = False
t = threading.Timer(0.2, self.draw)
t.start()
def getInputDisplayText(self):
return (["time", self.timestampStr],
["power consumption (kW)", self.consumptionStr])
class nupic_bridge:
MODEL_PARAMS_IMPORT_NAME = "model_params"
PredictedField = None
PredictedSteps = 0
Metrics = None
Model = None
def _init_model(self, model):
model.enableInference({"predictedField": self.PredictedField})
metrics = ['aae', 'altMAPE', 'rmse']
windows = [
self.PredictedSteps * 100, self.PredictedSteps * 10,
self.PredictedSteps
]
metric_specs = list()
for w in windows:
for m in metrics:
metric_specs.append(
MetricSpec(field=self.PredictedField,
metric='multiStep',
inferenceElement='multiStepBestPredictions',
params={
'errorMetric': m,
'window': w,
'steps': self.PredictedSteps
}))
self.Metrics = MetricsManager(metric_specs, model.getFieldInfo(),
model.getInferenceType())
self.Model = model
def create_model(self, modelParamsDir):
modelParams = self._getModelParamsFromName(modelParamsDir)
print "Creating model..."
model = ModelFactory.create(modelParams)
self._init_model(model)
def load_model(self, modelSaveDir):
try:
print "Loading model from %s..." % modelSaveDir
model = ModelFactory.loadFromCheckpoint(modelSaveDir)
self._init_model(model)
except:
print "ERR", "load_model", sys.exc_info()
traceback.print_exc()
raise
def _getModelParamsFromName(self, modelParamsDir):
print "Importing model params from %s" % modelParamsDir
try:
importedModelParams = imp.load_source(
self.MODEL_PARAMS_IMPORT_NAME,
os.path.join(modelParamsDir, self.MODEL_PARAMS_IMPORT_NAME +
'.py')).MODEL_PARAMS
except ImportError:
raise Exception("No model params exist")
return importedModelParams
def step(self, timestampStr, names, values):
try:
row = dict()
if timestampStr is not None:
row['Timestamp'] = parse_date(timestampStr)
for i in range(0, len(names)):
row[names[i]] = values[i]
result = self.Model.run(row)
result.metrics = self.Metrics.update(result)
prediction = result.inferences["multiStepBestPredictions"][
self.PredictedSteps]
#print result.metrics
#print result.inferences
#print prediction
m = flatten_dict(result.metrics)
#print m
i = flatten_dict(result.inferences)
#print i
ret = merge_two_dicts(m, i)
ret["prediction"] = prediction
for n in ret.keys():
print n, ret[n]
return ret.keys(), ret.values()
except:
print "ERR", "step", sys.exc_info()
traceback.print_exc()
raise
def save_model(self, modelSaveDir):
print "Saving model to %s" % modelSaveDir
try:
saveDirWithTimestamp = "%s_%s" % (modelSaveDir, time.time())
self.Model.save(saveDirWithTimestamp)
if os.path.exists(modelSaveDir):
shutil.rmtree(modelSaveDir)
shutil.copytree(saveDirWithTimestamp, modelSaveDir)
shutil.rmtree(saveDirWithTimestamp)
except:
print "ERR", "save_model", sys.exc_info()
traceback.print_exc()
pass
def init(self, predictedField, predictedSteps):
self.PredictedField = predictedField
self.PredictedSteps = predictedSteps
def test(self, this=None):
if (this is not None):
print "Running as COM server"
else:
print "Running as native"
PredictionSteps = 16
ModelParamsDir = os.path.abspath("..\data\model_0")
ModelSaveDir = os.path.abspath("..\data\model_save")
PredictedField = "kw_energy_consumption"
print "init"
self.init(PredictedField, PredictionSteps)
print "create"
self.create_model(ModelParamsDir)
print "save"
self.save_model(ModelSaveDir)
print "load"
self.load_model(ModelSaveDir)
print "step"
self.step(["timestamp", PredictedField],
[datetime.datetime.now(), 0.1])
print "save"
self.save_model(ModelSaveDir)
print "load"
self.load_model(ModelSaveDir)
print "done."
printTPRegionParams(model._getTPRegion())
inputData = "%s/%s.csv" % (DATA_DIR, dataSet.replace(" ", "_"))
sensor = model._getSensorRegion()
encoderList = sensor.getSelf().encoder.getEncoderList()
if sensor.getSelf().disabledEncoder is not None:
classifier_encoder = sensor.getSelf().disabledEncoder.getEncoderList()
classifier_encoder = classifier_encoder[0]
else:
classifier_encoder = None
_METRIC_SPECS = getMetricSpecs(predictedField,
stepsAhead=_options.stepsAhead)
metric = metrics.getModule(_METRIC_SPECS[0])
metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
if plot:
plotCount = 1
plotHeight = max(plotCount * 3, 6)
fig = plt.figure(figsize=(14, plotHeight))
gs = gridspec.GridSpec(plotCount, 1)
plt.title(predictedField)
plt.ylabel('Data')
plt.xlabel('Timed')
plt.tight_layout()
plt.ion()
print "Load dataset: ", dataSet
df = pd.read_csv(inputData, header=0, skiprows=[1, 2])
class HotGym(CLASanityModel):
def __init__(self, model, inputs):
super(HotGym, self).__init__(model)
self.model = model
self.inputs = inputs
self.metricsManager = MetricsManager(_METRIC_SPECS, model.getFieldInfo(),
model.getInferenceType())
self.counter = 0
self.timestampStr = ""
self.consumptionStr = ""
self.shifter = InferenceShifter()
self.dates = deque(maxlen=WINDOW)
self.convertedDates = deque(maxlen=WINDOW)
self.actualValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.predictedValues = deque([0.0] * WINDOW, maxlen=WINDOW)
self.linesInitialized = False
self.actualLines = None
self.predictedLines = None
self.shouldScheduleDraw = True
fig = plt.figure(figsize=(6.1, 11))
plotCount = 1
gs = gridspec.GridSpec(plotCount, 1)
self.graph = fig.add_subplot(gs[0, 0])
plt.xlabel('Date')
plt.ylabel('Consumption (kW)')
plt.tight_layout()
def draw(self):
self.shouldScheduleDraw = True
self.graph.relim()
self.graph.autoscale_view(True, True, True)
plt.draw()
plt.legend(('actual', 'predicted'), loc=3)
def step(self):
self.counter += 1
self.timestampStr, self.consumptionStr = self.inputs.next()
timestamp = datetime.datetime.strptime(self.timestampStr, "%m/%d/%y %H:%M")
consumption = float(self.consumptionStr)
result = self.model.run({
"timestamp": timestamp,
"kw_energy_consumption": consumption,
})
result.metrics = self.metricsManager.update(result)
if self.counter % 100 == 0:
print "Read %i lines..." % self.counter
print ("After %i records, 1-step altMAPE=%f" % (
self.counter,
result.metrics["multiStepBestPredictions:multiStep:"
"errorMetric='altMAPE':steps=1:window=1000:"
"field=kw_energy_consumption"]))
result = self.shifter.shift(result)
prediction = result.inferences["multiStepBestPredictions"][1]
if not self.linesInitialized:
self.dates += deque([timestamp]*WINDOW)
self.convertedDates += [date2num(date) for date in self.dates]
addedLinesActual, = self.graph.plot(
self.dates, self.actualValues, 'r'
)
self.actualLines = addedLinesActual
predictedLinesActual, = self.graph.plot(
self.dates, self.predictedValues, 'b'
)
self.predictedLines = predictedLinesActual
self.graph.xaxis.set_major_formatter(DateFormatter("%H:%M"))
self.linesInitialized = True
self.dates.append(timestamp)
self.convertedDates.append(date2num(timestamp))
self.actualValues.append(consumption)
self.predictedValues.append(prediction)
self.actualLines.set_xdata(self.convertedDates)
self.actualLines.set_ydata(self.actualValues)
self.predictedLines.set_xdata(self.convertedDates)
self.predictedLines.set_ydata(self.predictedValues)
if self.shouldScheduleDraw:
# If we're stepping the model really quickly, coalesce the redraws.
self.shouldScheduleDraw = False
t = threading.Timer(0.2, self.draw)
t.start()
def getInputDisplayText(self):
return (["time", self.timestampStr],
["power consumption (kW)", self.consumptionStr])
