def iterate_one(self):
s=self
parents = s._X.copy()
children = s._mutate_and_crossover()
new_population=np.concatenate((parents,children),axis=0)
new_Y=s.cost_function(new_population)
truncated_Y,rank,cf,indices=base.truncate(new_Y,s.population_size)
s._X=new_population[indices].copy()
s._Y=truncated_Y.copy()
return
def fit(self, X, cls_label, ses_label):
global_tick = time.time()
print "Reordering data..."
data = base.reorder_cls_ses(X, cls_label, ses_label)
X = data['data']
cls_label = data['cls']
ses_label = data['ses']
self.update_iters(X, cls_label, ses_label)
data = base.truncate(X, cls_label, ses_label, self.iters['cls_ind'])
X = data['data']
cls_label = data['cls']
ses_label = data['ses']
ind = data['ind']
self.iters['cls_ind'] = ind
self.H.set_value(self.H.get_value()[0:X.shape[0], ])
if self.normalize:
self.normalize_W_H()
buff = self.generate_buffer_from_lbl(X, cls_label, ses_label,
random=True, truncate=True)
if self.buff_size > X.shape[0]:
self.X_buff.set_value(X.astype(theano.config.floatX))
self.scores.append(self.score_buffer(X, buff))
print 'Fitting NMF model with %d iterations....' % self.n_iter
for it in range(self.n_iter):
if self.dist_mode == 'iter':
for i in range(int(np.max(cls_label)+1)):
Sci = np.hstack(np.where(self.iters['cls'][:,0] == i))
if Sci.shape[0] > 0:
self.class_sum(i, self.n_components, Sci)
for i in range(int(np.max(ses_label)+1)):
Csi = np.hstack(np.where(self.iters['cls'][:,1] == i))
if Csi.shape[0] > 0:
self.ses_sum(i, self.n_components, Csi)
if self.verbose > 0:
if (it+1) % self.verbose == 0:
if 'tick' not in locals():
tick = time.time()
print '\n\n NMF model, iteration {0}/{1}'.format(it+1,
self.n_iter)
buff = self.generate_buffer_from_lbl(X, cls_label, ses_label,
random=True, truncate=True)
self.update_buffer(X, buff, it)
if self.normalize:
self.normalize_W_H()
if self.verbose > 0:
if (it+1) % self.verbose == 0:
self.scores.append(self.score_buffer(X, buff))
if self.NMF_updates == 'beta':
if self.scores[-1] > 0:
print 'Score: %.1f' % self.score[-1]
else:
if self.scores[-1][0][0] > 0:
print 'Score: %.1f' % self.scores[-1][0][0]
print 'Beta-divergence: %.1f' % self.scores[-1][0][1]
print 'Class distance : %.1f (%.1f)' % (self.scores[-1][0][2]*self.lambdas[0],
self.scores[-1][0][2])
print 'Session distance : %.1f (%.1f)' % (self.scores[-1][0][3]*self.lambdas[1],
self.scores[-1][0][3])
print 'Duration=%.1fms' % ((time.time() - tick) * 1000)
sys.stdout.flush()
print 'Total duration=%.1fms' % ((time.time() - global_tick) * 1000)
def iterate_one(self):
s=self
#calculating inertia weight:
s._w=s._w*s.inertia_decay_rate
w=s._w
#particle movement:
#nearest_global_best=np.zeros((s.population_size,s.n_dimensions)) #distance in fitness space
#nearest_projected_best=np.zeros((s.population_size,s.n_dimensions)) #virtual point which ponders the nearest ones to guess the nearest one on the pareto border
nearest_neighbour=np.zeros((s.population_size,s.n_dimensions)) #distance in fitness space
for i in range(s.population_size):
##getting nearest global best
#aux=(((s._global_bestY-s._Y[i])**2).sum(axis=1))**0.5
#aux2=np.where(aux==np.min(aux))[0][0]
#temp=s._global_bestX[aux2]
#nearest_global_best[i]=s._global_bestX[aux2]
##getting nearest projected best:
#aux=(((s._global_bestY-s._Y[i])**2).sum(axis=1))**0.5
#aux2=np.argsort(aux)[:s.n_objectives] #get as many points as necessary to interpolate the pareto front nearest to the point
#if(aux[aux2[0]]==0):
# nearest_projected_best[i]=s._global_bestX[aux2[0]]
#else:
# nearest_projected_best[i]=(s._global_bestX[aux2]*((aux[aux2]**-1).reshape(-1,1))/np.sum(aux[aux2]**-1)).sum(axis=0)
#getting nearest neighbour
aux=(((s._Y-s._Y[i])**2).sum(axis=1))**0.5
aux[i]=np.inf
aux2=np.where(aux==np.min(aux))[0][0]
nearest_neighbour[i]=s._X[aux2]
#if(s._iter%5==0):
# o_global=base.component_sort_order(s._global_bestY)
# o_current=base.component_sort_order(s._Y)
# o_global=o_global*len(o_current)/len(o_global) #make sure the range is the same
# s.nearest_global_best_by_order=np.zeros((s.population_size,s.n_dimensions)) #distance in fitness space
# taken=np.zeros(len(o_global),'bool')
# for i in range(s.population_size):
# #getting nearest by order:
# aux=(((o_global-o_current[i])**2).sum(axis=1))**0.5
# aux2=np.argsort(aux)
# for j in aux2:
# if not taken[j]:
# break
# s.nearest_global_best_by_order[i]=s._global_bestX[j]
# taken[j]=True
if(s._iter%5==0):
aux=len(s._global_bestX)*(np.arange(s.population_size))/s.population_size
#s.designated_target=s._global_bestX[aux.astype('int')]
s.designated_target=s._global_bestX[aux[np.random.permutation(len(aux))].astype('int')]
r1=np.random.random((s.population_size,s.n_dimensions))
r2=np.random.random((s.population_size,s.n_dimensions))
r3=np.random.random((s.population_size,s.n_dimensions))
#r4=np.random.random((s.population_size,s.n_dimensions))-0.5
s._V= w*s._V + \
s.cognitive_coefficient*r1*(s._individual_bestX-s._X) +\
s.social_coefficient*r2*(s.designated_target-s._X) +\
- r3*s.repulsion_coefficient*(nearest_neighbour-s._X) #+\
#r4*0.00001
#s.social_coefficient*r2*(s.nearest_global_best_by_order-s._X) +\
#
#s.social_coefficient*r2*(nearest_projected_best-s._X) +\
#- r3*s.repulsion_coefficient*(nearest_neighbour-s._X)# +\
#s.social_coefficient*r2*(nearest_global_best-s._X) + \
#applying speed limit:
vnorm=((s._V**2).sum(axis=1))**0.5 #norm of the speed
aux=np.where(vnorm>s.maximum_velocity) #particles with velocity greater than expected
s._V[aux]=s._V[aux]*s.maximum_velocity/(vnorm[aux].reshape((-1,1))) #clipping the speed to the maximum speed
#update solutions:
s._X=s._X+s._V
#clipping the search space
s._X=np.minimum(s.ub,s._X)
s._X=np.maximum(s.lb,s._X)
#fitness value calculation:
s._Y = s.cost_function(s._X) # current particle cost
#update memories:
temp_Y=np.concatenate((s._global_bestY,s._Y),axis=0).copy()
temp_X=np.concatenate((s._global_bestX,s._X),axis=0).copy()
Y,rank,cf,indices=base.truncate(temp_Y,1*s.population_size)
#s._global_bestX=temp_X[indices][np.where(rank==1)[0]]
#s._global_bestY=temp_Y[indices][np.where(rank==1)[0]]
s._global_bestX=temp_X[indices]
s._global_bestY=temp_Y[indices]
#debugging code:
#for i in s._global_bestY:
# assert((temp_Y>=i).any(axis=1).all(axis=0))
#print('len_global',len(s._global_bestX),len(s._global_bestY))
#updating individual best:
for i in range(s.population_size):
if (s._individual_bestY[i]>=s._Y[i]).all() and (s._individual_bestY[i]>s._Y[i]).any():
#new solution dominates old one
s._individual_bestY[i]=s._Y[i]
s._individual_bestX[i]=s._X[i]
elif (s._individual_bestY[i]<s._Y[i]).any():
#new solution not dominated by the old one. See if it approaches the pareto front best
#'''
aux=(((s._global_bestY-s._Y[i])**2).sum(axis=1))**0.5
aux2=np.argsort(aux)[:s.n_objectives] #get as many points as necessary to interpolate the pareto front nearest to the point
if(aux[aux2[0]]==0):
aux3=s._global_bestY[aux2[0]]
else:
#average the nearby points weighted by the inverse distance:
aux3=(s._global_bestY[aux2]*((aux[aux2]**-1).reshape(-1,1))/np.sum(aux[aux2]**-1)).sum(axis=0)
new_min=((aux3-s._Y[i])**2).sum()**0.5
aux=(((s._global_bestY-s._individual_bestY[i])**2).sum(axis=1))**0.5
aux2=np.argsort(aux)[:s.n_objectives] #get as many points as necessary to interpolate the pareto front nearest to the point
if(aux[aux2[0]]==0):
aux3=s._global_bestY[aux2[0]]
else:
#average the nearby points weighted by the inverse distance:
aux3=(s._global_bestY[aux2]*((aux[aux2]**-1).reshape(-1,1))/np.sum(aux[aux2]**-1)).sum(axis=0)
old_min=((aux3-s._individual_bestY[i])**2).sum()**0.5
#'''
'''
aux=(((s._global_bestY-s._Y[i])**2).sum(axis=1))**0.5
new_min=np.min(aux)
aux=(((s._global_bestY-s._individual_bestY[i])**2).sum(axis=1))**0.5
old_min=np.min(aux)
'''
if(old_min>new_min):
s._individual_bestY[i]=s._Y[i]
s._individual_bestX[i]=s._X[i]
return
