async def update(self, record: Record):
db = self.parent.db
# Store feature data
feature_cols = self.parent.FEATURE_COLS
feature_data = OrderedDict.fromkeys(feature_cols)
feature_data.update(record.features(feature_cols))
await db.execute(
"INSERT OR REPLACE INTO features (key, " +
", ".join(feature_cols) + ") "
"VALUES(?, " + ", ".join("?" * len(feature_cols)) + ")",
[record.key] + list(feature_data.values()),
)
# Store prediction
try:
prediction = record.prediction("target_name")
prediction_cols = self.parent.PREDICTION_COLS
prediction_data = OrderedDict.fromkeys(prediction_cols)
prediction_data.update(prediction.dict())
await db.execute(
"INSERT OR REPLACE INTO prediction (key, " +
", ".join(prediction_cols) + ") "
"VALUES(?, " + ", ".join("?" * len(prediction_cols)) + ")",
[record.key] + list(prediction_data.values()),
)
except KeyError:
pass
async def test_predict(self):
records: Dict[str, Record] = {
record.key: record.export()
async for record in self.sctx.records()
}
async with self.post(f"/model/{self.mlabel}/predict/0",
json=records) as r:
i: int = 0
response = await r.json()
for key, record_data in response["records"].items():
record = Record(key, data=record_data)
self.assertEqual(int(record.key), i)
self.assertEqual(
record.feature("by_ten"),
record.prediction("Salary").value / 10,
)
self.assertEqual(float(record.key),
record.prediction("Salary").confidence)
i += 1
self.assertEqual(i, self.num_records)
class TestRecord(unittest.TestCase):
def setUp(self):
self.null = Record("null")
self.full = Record(
"full",
data=dict(
features=dict(dead="beef"),
extra=dict(extra="read all about it"),
),
extra=dict(half=True),
)
def test_dict(self):
data = self.full.dict()
self.assertIn("extra", data)
def test_repr(self):
repr(self.full)
def test_str(self):
self.full.prediction = RecordPrediction()
self.assertIn("Undetermined", str(self.full))
self.full.data.prediction = {
"Prediction": RecordPrediction(value="Good")
}
self.assertIn("Good", str(self.full))
self.full.extra.update(dict(hi=5))
self.assertIn("5", str(self.full))
self.full.extra = dict()
self.assertNotIn("5", str(self.full))
def test_merge(self):
null = Record("null")
null.merge(self.full)
self.assertIn("half", null.extra)
self.assertTrue(null.extra["half"])
def test_key(self):
return self.full.data.key
def test_evaluated(self):
old_last_updated = self.full.data.last_updated
results = {"new": "feature"}
self.full.evaluated({"feed": "face"})
self.assertIn("feed", self.full.data.features)
self.assertEqual("face", self.full.data.features["feed"])
self.full.evaluated(results, overwrite=True)
self.assertEqual(self.full.data.features, results)
self.assertLessEqual(old_last_updated, self.full.data.last_updated)
def test_features(self):
self.assertIn("dead", self.full.features())
self.assertIn("dead", self.full.features(["dead"]))
self.assertFalse(self.full.features(["dead", "beaf"]))
def test_predicted(self):
old_prediction = self.full.data.prediction.copy()
old_last_updated = self.full.data.last_updated
self.full.predicted("target_name", "feed", 1.00)
self.assertNotEqual(old_prediction, self.full.data.prediction)
self.assertLessEqual(old_last_updated, self.full.data.last_updated)
def test_prediction(self):
self.full.predicted("target_name", "feed", 1.00)
self.assertTrue(self.full.prediction("target_name"))
