def testCapnpWriteRead(self):
m1 = previous_value_model.PreviousValueModel(
opf_utils.InferenceType.TemporalMultiStep, predictedField ='a',
predictionSteps = [1, 3, 5])
m1.run(dict_utils.DictObj({'a' : 0}))
# Serialize
builderProto = PreviousValueModelProto.new_message()
m1.write(builderProto)
# Construct reader from populated builder
readerProto = PreviousValueModelProto.from_bytes(builderProto.to_bytes())
# Deserialize
m2 = previous_value_model.PreviousValueModel.read(readerProto)
self.assertIs(m1.getSchema(), PreviousValueModelProto)
self.assertIs(m2.getSchema(), PreviousValueModelProto)
self.assertEqual(m2._numPredictions, m1._numPredictions)
self.assertEqual(m2.getInferenceType(), m1.getInferenceType())
self.assertEqual(m2.isLearningEnabled(), m1.isLearningEnabled())
self.assertEqual(m2.isInferenceEnabled(), m1.isInferenceEnabled())
self.assertEqual(m2.getInferenceArgs(), m1.getInferenceArgs())
self.assertEqual(m2._predictedField, m1._predictedField)
self.assertEqual(m2._fieldNames, m1._fieldNames)
self.assertEqual(m2._fieldTypes, m1._fieldTypes)
self.assertEqual(m2._predictionSteps, m1._predictionSteps)
# Run computes on m1 & m2 and compare results
r1 = m1.run(dict_utils.DictObj({'a' : 1}))
r2 = m2.run(dict_utils.DictObj({'a' : 1}))
self.assertEqual(r2.predictionNumber, r1.predictionNumber)
self.assertEqual(r2.rawInput, r1.rawInput)
self.assertEqual(r2.predictionNumber, r1.predictionNumber)
self.assertEqual(r2.inferences[opf_utils.InferenceElement.prediction],
r1.inferences[opf_utils.InferenceElement.prediction])
self.assertEqual(
r2.inferences[opf_utils.InferenceElement.multiStepBestPredictions][1],
r1.inferences[opf_utils.InferenceElement.multiStepBestPredictions][1])
self.assertEqual(
r2.inferences[opf_utils.InferenceElement.multiStepBestPredictions][3],
r1.inferences[opf_utils.InferenceElement.multiStepBestPredictions][3])
self.assertEqual(
r2.inferences[opf_utils.InferenceElement.multiStepBestPredictions][5],
r1.inferences[opf_utils.InferenceElement.multiStepBestPredictions][5])
def testSequenceReset(self):
encoders = {
"a": {
"fieldname": u"a",
"maxval": 9,
"minval": 0,
"n": 10,
"w": 1,
"clipInput": True,
"forced": True,
"type": "ScalarEncoder"
}
}
inferenceType = opf_utils.InferenceType.TemporalNextStep
twoGramModel = two_gram_model.TwoGramModel(inferenceType, encoders)
inputRecords = (dict_utils.DictObj(d) for d in ({
"a": 5
}, {
"a": 6
}, {
"a": 5
}, {
"a": 6
}))
inferences = ((0, ), (0, ), (6, ), (0, ))
resets = (False, False, True, False)
for i, (inputRecord, expectedInference,
reset) in enumerate(zip(inputRecords, inferences, resets)):
if reset:
twoGramModel.resetSequenceStates()
results = twoGramModel.run(inputRecord)
self.assertEqual(results.predictionNumber, i)
self.assertSequenceEqual(
results.inferences[opf_utils.InferenceElement.prediction],
expectedInference)
def testCategoryPredictions(self):
encoders = {
"a": {
"fieldname": u"a",
"n": 10,
"w": 3,
"forced": True,
"type": "SDRCategoryEncoder"
}
}
inferenceType = opf_utils.InferenceType.TemporalNextStep
twoGramModel = two_gram_model.TwoGramModel(inferenceType, encoders)
inputRecords = (dict_utils.DictObj(d) for d in ({
"a": "A"
}, {
"a": "B"
}, {
"a": "A"
}, {
"a": "B"
}))
inferences = (("", ), ("", ), ("B", ), ("A", ))
for i, (inputRecord,
expectedInference) in enumerate(zip(inputRecords, inferences)):
results = twoGramModel.run(inputRecord)
self.assertEqual(results.predictionNumber, i)
self.assertSequenceEqual(
results.inferences[opf_utils.InferenceElement.prediction],
expectedInference)
def _runNextStep(self, data):
model = previous_value_model.PreviousValueModel(
opf_utils.InferenceType.TemporalNextStep, predictedField ='a')
inputRecords = (dict_utils.DictObj({'a' : d}) for d in data)
for i, (inputRecord, expectedInference) in enumerate(zip(inputRecords,
data)):
results = model.run(inputRecord)
self.assertEqual(results.predictionNumber, i)
self.assertEqual(results.inferences[
opf_utils.InferenceElement.prediction], expectedInference)
self.assertEqual(results.inferences[
opf_utils.InferenceElement.multiStepBestPredictions][1],
expectedInference)
def testMultipleFields(self):
encoders = {
"a": {
"fieldname": u"a",
"maxval": 9,
"minval": 0,
"n": 10,
"w": 1,
"clipInput": True,
"forced": True,
"type": "ScalarEncoder"
},
"b": {
"fieldname": u"b",
"maxval": 9,
"minval": 0,
"n": 10,
"w": 1,
"clipInput": True,
"forced": True,
"type": "ScalarEncoder"
}
}
inferenceType = opf_utils.InferenceType.TemporalNextStep
twoGramModel = two_gram_model.TwoGramModel(inferenceType, encoders)
inputRecords = (dict_utils.DictObj(d) for d in ({
"a": 5,
"b": 1
}, {
"a": 6,
"b": 2
}, {
"a": 5,
"b": 3
}, {
"a": 6,
"b": 2
}))
inferences = ((0, 0), (0, 0), (6, 0), (5, 3))
for i, (inputRecord,
expectedInference) in enumerate(zip(inputRecords, inferences)):
results = twoGramModel.run(inputRecord)
self.assertEqual(results.predictionNumber, i)
self.assertSequenceEqual(
results.inferences[opf_utils.InferenceElement.prediction],
expectedInference)
def testWriteRead(self):
encoders = {
"a": {
"fieldname": "a",
"maxval": 9,
"minval": 0,
"n": 10,
"w": 1,
"clipInput": True,
"forced": True,
"type": "ScalarEncoder"
},
"b": {
"fieldname": "b",
"maxval": 9,
"minval": 0,
"n": 10,
"w": 1,
"clipInput": True,
"forced": True,
"type": "ScalarEncoder"
}
}
inferenceType = opf_utils.InferenceType.TemporalNextStep
model = two_gram_model.TwoGramModel(inferenceType, encoders)
inputRecords = (dict_utils.DictObj(d) for d in ({
"a": 5,
"b": 1
}, {
"a": 6,
"b": 3
}, {
"a": 5,
"b": 2
}, {
"a": 6,
"b": 1
}))
inferences = ((0, 0), (0, 0), (6, 0), (5, 3))
for i, (inputRecord,
expectedInference) in enumerate(zip(inputRecords, inferences)):
results = model.run(inputRecord)
self.assertEqual(results.predictionNumber, i)
self.assertSequenceEqual(
results.inferences[opf_utils.InferenceElement.prediction],
expectedInference)
proto = TwoGramModelProto.new_message()
model.write(proto)
with tempfile.TemporaryFile() as f:
proto.write(f)
f.seek(0)
protoDeserialized = TwoGramModelProto.read(f)
modelDeserialized = two_gram_model.TwoGramModel.read(protoDeserialized)
self.assertEqual(model.getInferenceType(), inferenceType)
self.assertEqual(modelDeserialized.getInferenceType(),
model.getInferenceType())
self.assertSequenceEqual(modelDeserialized._prevValues,
model._prevValues)
self.assertSequenceEqual(modelDeserialized._hashToValueDict,
model._hashToValueDict)
self.assertSequenceEqual(modelDeserialized._fieldNames,
model._fieldNames)
self.assertSequenceEqual(modelDeserialized._twoGramDicts,
model._twoGramDicts)
for i, (inputRecord,
expectedInference) in enumerate(zip(inputRecords, inferences)):
expected = model.run(inputRecord)
actual = modelDeserialized.run(inputRecord)
self.assertEqual(expected.predictionNumber,
actual.predictionNumber)
self.assertSequenceEqual(
expected.inferences[opf_utils.InferenceElement.prediction],
actual.inferences[opf_utils.InferenceElement.prediction])
