def _translate(this, value):
value, tag = value.strip(), _.tags[this]
if no(value): return zero
_type, items = _.types[this], _.items
if _type == 'n':
try: return float(value.translate(_._c2d))
except: return zero
elif _type.startswith('d'):
sep = _type[1]
rawdate = value.split(sep)
ref = dt.date.today()
args = {}
for n,in_type in enumerate(_type[2:]):
if in_type == 'd': args['day'] = int(rawdate[n])
elif in_type == 'm': args['month'] = int(rawdate[n])
else: args['year'] = int(rawdate[n])
date = dt.date(**args)
return float((ref-date).days)
elif _type == 'l':
if tag not in items: items[tag] = {}
if value not in items[tag]: items[tag].update({value: len(items[tag])})
return float(items[tag][value])
elif _type.startswith('-'): return float(value.strip(_type[1:]))
elif _type.endswith('-'):
if value.strip() == _type.strip('- '): return 1.
return zero
else:
if value.strip() == _type.strip(): return zero
return 1.
def score_of(x,y, margs={'n_estimators':100}):
_model, scaler = model.classifier, model.scaler
random_state = model.random_state
if no(random_state): random_state = randint(0xFFFFFFFF)
C = Pipeline([('scaler', scaler()), ('model', _model(**margs))])
cv = KFold(model.k, shuffle=True, random_state=random_state)
return cross_val_score(C, x, y, cv=cv)
def select(_, x_by='day', fx=lambda x:True, exclude=['hn'], y_by='outcome', groups={(0,1,2):0, (3,4,5):1}, prediction=0):
def search_outcome_of(state, _from, this):
check = lambda x,y:x>y
if _from<0: check = lambda x,y:x<y
search = state
while search.prev:
out = search.get(y_by)
if check(out, this): this = out
search = search.prev
search = state
while search.next:
out = search.get(y_by)
if check(out, this): this = out
search = search.next
return this
X, Y, off = [], [], exclude + [y_by]
for state in _.states:
if fx(state.get(x_by)):
out, y = state.get(y_by), None
if prediction: out = search_outcome_of(state, prediction, out)
for this in groups:
if out in this: y = groups[this]
if no(y): continue
x = [state.get(var) for var in state.sets if var not in off]
X.append(x)
Y.append(y)
return X,Y
def vars_of(model, start=0, stop=None):
vari, s = model.sorted(start)
index = {var:[i] for var,i in vari}
if no(stop): stop = len(model.best)
for n in range(start+1,stop):
vari, s = model.sorted(n)
for var,i in vari: index[var].append(i)
s_vari = sorted(index.items(), key=lambda x:average(x[1]), reverse=True)
return s_vari
def len(_):
if no(_.DEF): raise Warning('Definition not set')
return len(_.DEF)
def _calculate(_, on, by, targets, outcome_from, model, models, good, bad, threshold, _to=0):
''' partial method, retrieves the number of predicted subjects, this will be edited for online prediction '''
start = _to
DB, _._states = _._db, _._db.states
train, test, p = [], [], [int(r>=on) for r in rand(_._db.ids)]
for n, idset in ni(idsets_of(DB)):
if p[n]: test.append(idset)
else: train += idset
DB.states = train
_.train(on=model, err=_.err)
if no(models): models = len(_.best)
for idset in test:
DB.states = idset
(x,y), ym = DB.select(**_._selargs), []
for ((M,S),s) in _.best[:models]:
try:
X = array(x)
Xs = S.transform(X)
Yp = M.predict(Xs)
ym.append(Yp)
except:
pass
if len(ym) == 0: continue
Y = array(ym).T
p = average(Y)
if not y[0]: p = 1-p
if y[0]==good[0]: _.stats[good[1]].append(p)
else: _.stats[bad[1]].append(p)
if not _.from_end: _.assessed.append(idset[0])
if len(idset)==1 or y[0]==_._ref or len(Y)!=len(idset): continue
ref, target_map = None, {tag:None for tag in targets+['before']}
#assert(len(Y)==len(idset))
for n,state in ni(idset):
yn = average(Y[n])
if y[0]==0: yn = 1-yn
if no(state.next) or yn>=threshold:
ref = state.get(by)
break
if _.from_end:
for state in idset:
if no(state.next):
anticipation = state.get(by)-ref
if anticipation:
target_map['before'] = anticipation
_.dismissed.append(idset[0])
else: _.in_room.append(idset[0])
else:
for state in idset:
if no(target_map['before']) and outcome_from<=state.get(_.outcome):
target_map['before'] = state.get(by)-ref
break
for target in targets:
for state in idset:
if no(target_map[target]) and state.get(target):
target_map[target] = state.get(by)-ref
break
for tag in target_map:
if target_map[tag] is not None: _.stats[tag].append(target_map[tag])
_to+=1
print('from {} to {}...'.format(start, _to))
for tag in _.stats:
print(tag+'\t{:.3f}'.format(average(_.stats[tag]) if len(_.stats[tag])>0 else 0))
DB.states = _._states
return _to