class MiscRandomInterest(RandomInterest):
"""
Add some features to the RandomInterest random babbling class.
Allows to query the recent interest in the whole space,
the recent competence on the babbled points in the whole space,
the competence around a given point based on a mean of the knns.
"""
def __init__(self, conf, expl_dims, win_size, competence_mode, k,
progress_mode):
RandomInterest.__init__(self, conf, expl_dims)
self.conf = conf
self.win_size = win_size
self.competence_mode = competence_mode
self.dist_max = np.linalg.norm(self.bounds[0, :] - self.bounds[1, :])
self.k = k
self.progress_mode = progress_mode
self.data_xc = Dataset(len(expl_dims), 1)
self.data_sr = Dataset(len(expl_dims), 0)
self.current_progress = 0.
self.current_interest = 0.
def save(self):
return [self.data_xc.data, self.data_sr.data]
def forward(self, data, iteration, progress, interest):
self.data_xc.add_xy_batch(data[0][0][:iteration],
data[0][1][:iteration])
self.data_sr.data[0] = self.data_sr.data[0] + data[1][0][:iteration]
self.data_sr.size += len(data[1][0][:iteration])
self.current_progress = progress
self.current_interest = interest
def competence_measure(self, sg, s, dist_max):
return competence_dist(sg, s,
dist_max=dist_max) / dist_max # Normalize
#return competence_dist(sg, s, dist_max=dist_max)
def add_xc(self, x, c):
self.data_xc.add_xy(x, [c])
def add_sr(self, x):
self.data_sr.add_xy(x)
def update_interest(self, i):
i = i / len(self.conf.s_dims)
self.current_progress += (1. / self.win_size) * (i -
self.current_progress)
self.current_interest = abs(self.current_progress)
def update(self, xy, ms, snnp=None, sp=None):
c = self.competence_measure(xy[self.expl_dims],
ms[self.expl_dims],
dist_max=self.dist_max)
if self.progress_mode == 'local':
interest = self.interest_xc(xy[self.expl_dims], c)
self.update_interest(interest)
elif self.progress_mode == 'global':
pass
self.add_xc(xy[self.expl_dims], c)
self.add_sr(ms[self.expl_dims])
return interest
def n_points(self):
return len(self.data_xc)
def competence_global(self, mode='sw'):
if self.n_points() > 0:
if mode == 'all':
return np.mean(self.data_c)
elif mode == 'sw':
idxs = range(self.n_points())[-self.win_size:]
return np.mean([self.data_xc.get_y(idx) for idx in idxs])
else:
raise NotImplementedError
else:
return 0.
def mean_competence_pt(self, x):
if self.n_points() > self.k:
_, idxs = self.data_xc.nn_x(x, k=self.k)
return np.mean([self.data_xc.get_y(idx) for idx in idxs])
else:
return self.competence()
def interest_xc(self, x, c):
if self.n_points() > 0:
idx_sg_NN = self.data_xc.nn_x(x, k=1)[1][0]
sr_NN = self.data_sr.get_x(idx_sg_NN)
c_old = self.competence_measure(x, sr_NN, self.dist_max)
return c - c_old
else:
return 0.
def interest_pt(self, x):
if self.n_points() > self.k:
_, idxs = self.data_xc.nn_x(x, k=self.k)
idxs = sorted(idxs)
v = [self.data_xc.get_y(idx) for idx in idxs]
n = len(v)
comp_beg = np.mean(v[:int(float(n) / 2.)])
comp_end = np.mean(v[int(float(n) / 2.):])
return np.abs(comp_end - comp_beg)
else:
return self.interest_global()
def interest_global(self):
if self.n_points() < 2:
return 0.
else:
idxs = range(self.n_points())[-self.win_size:]
v = [self.data_xc.get_y(idx) for idx in idxs]
n = len(v)
comp_beg = np.mean(v[:int(float(n) / 2.)])
comp_end = np.mean(v[int(float(n) / 2.):])
return np.abs(comp_end - comp_beg)
def competence(self):
return self.competence_global()
def progress(self):
return self.current_progress
def interest(self):
if self.progress_mode == 'local':
return self.current_interest
elif self.progress_mode == 'global':
return self.interest_global()
else:
raise NotImplementedError
class MiscRandomInterest(RandomInterest):
"""
Add some features to the RandomInterest random babbling class.
Allows to query the recent interest in the whole space,
the recent competence on the babbled points in the whole space,
the competence around a given point based on a mean of the knns.
"""
def __init__(self, conf, expl_dims, win_size, competence_mode, k,
progress_mode):
RandomInterest.__init__(self, conf, expl_dims)
self.win_size = win_size
self.competence_mode = competence_mode
self.dist_max = np.linalg.norm(self.bounds[0, :] - self.bounds[1, :])
self.k = k
self.progress_mode = progress_mode
self.data_xc = Dataset(len(expl_dims), 0)
self.data_sr = Dataset(len(expl_dims), 0)
self.data_sp = Dataset(len(expl_dims), 0)
self.current_competence_progress = 0.
self.current_prediction_progress = 0.
self.current_progress = 0.
self.current_interest = 0.
self.alpha = 0.5
self.beta = 1. - self.alpha
def save(self):
return [self.data_xc.data, self.data_sr.data]
def forward(self, data, iteration, progress, interest):
self.data_xc.add_xy_batch(data[0][0][:iteration],
data[0][1][:iteration])
self.data_sr.data[0] = self.data_sr.data[0] + data[1][0][:iteration]
self.data_sr.size += len(data[1][0][:iteration])
self.current_progress = progress
self.current_interest = interest
def competence_measure(self, sg, s, dist_max):
return competence_dist(sg, s, dist_max=dist_max)
def add_xc(self, x):
self.data_xc.add_xy(x)
def add_sr(self, x):
self.data_sr.add_xy(x)
def add_sp(self, x):
self.data_sp.add_xy(x)
def update_interest(self, cp, pp):
self.current_competence_progress += (1. / self.win_size) * (
cp - self.current_competence_progress)
self.current_prediction_progress += (1. / self.win_size) * (
pp - self.current_prediction_progress)
self.current_progress = self.alpha * self.current_competence_progress + self.beta * self.current_prediction_progress
self.current_interest = self.alpha * abs(
self.current_competence_progress) + self.beta * abs(
self.current_prediction_progress)
def update(self, xy, ms, sp=None):
if sp is not None:
c = self.competence_measure(xy[self.expl_dims],
ms[self.expl_dims],
dist_max=self.dist_max)
p = self.competence_measure(sp,
ms[self.expl_dims],
dist_max=self.dist_max)
cp = self.new_competence_progress(xy[self.expl_dims], c)
pp = self.new_prediction_progress(ms[self.expl_dims], p)
self.update_interest(cp, pp)
self.add_xc(xy[self.expl_dims])
self.add_sr(ms[self.expl_dims])
self.add_sp(sp)
def n_points(self):
return len(self.data_xc)
def new_competence_progress(self, x, c):
if self.n_points() > 0:
idx_sg_NN = self.data_xc.nn_x(x, k=1)[1][0]
sr_NN = self.data_sr.get_x(idx_sg_NN)
c_old = self.competence_measure(x, sr_NN, self.dist_max)
return c - c_old
else:
return 0.
def new_prediction_progress(self, sr, p):
if self.n_points() > 0:
idx_sr_NN = self.data_sr.nn_x(sr, k=1)[1][0]
sp_NN = self.data_sp.get_x(idx_sr_NN)
p_old = self.competence_measure(sr, sp_NN, self.dist_max)
return p - p_old
else:
return 0.
def interest_pt(self, x):
if self.n_points() > self.k:
_, idxs = self.data_xc.nn_x(x, k=self.k)
idxs = sorted(idxs)
v = [self.data_xc.get_y(idx) for idx in idxs]
n = len(v)
comp_beg = np.mean(v[:int(float(n) / 2.)])
comp_end = np.mean(v[int(float(n) / 2.):])
return np.abs(comp_end - comp_beg)
else:
return 0.
def progress(self):
return self.current_progress
def interest(self):
return self.current_interest