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,
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 __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 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 __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 _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
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 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)
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
