SmartCache/online_cache.py at main · randomfunction/SmartCache · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
importnumpyasnp
fromcollectionsimportdefaultdict, OrderedDict
fromriverimportlinear_model, preprocessing, metrics

classOnlineMLCache:
def__init__(self, capacity):
self.capacity=capacity
self.cache=OrderedDict()
self.freq=defaultdict(int)
self.model=preprocessing.StandardScaler() |linear_model.LogisticRegression()
self.metric=metrics.Accuracy()
self.hits=0
self.requests=0
self.prev_key=None
self.prev_freq=None

deffeature_dict(self, key):
return {"key": key, "freq": self.freq[key]}

defaccess(self, key):
self.requests+=1
self.freq[key] +=1
feats=self.feature_dict(key)

try:
prob=self.model.predict_proba_one(feats)[1]
exceptAttributeError:
prob=self.model.predict_one(feats)

ifkeyinself.cache:
self.hits+=1
self.cache.move_to_end(key)
else:
iflen(self.cache) >=self.capacity:
scores= {}
forkinself.cache:
f= {"key": k, "freq": self.freq[k]}
try:
scores[k] =self.model.predict_proba_one(f)[1]
exceptAttributeError:
scores[k] =self.model.predict_one(f)
evict=min(scores, key=scores.get)
self.cache.pop(evict)
self.cache[key] =None

ifself.prev_keyisnotNone:
label=int(key==self.prev_key)
prev_feats= {"key": self.prev_key, "freq": self.prev_freq}
y_pred=self.model.predict_one(prev_feats)
self.metric.update(label, y_pred)
self.model.learn_one(prev_feats, label)

self.prev_key=key
self.prev_freq=self.freq[key]

returnprob

defhit_rate(self):
returnself.hits/self.requestsifself.requestselse0

defaccuracy(self):
returnself.metric.get()