def centralizedTest(isPersonalized):
global users
global testData
checkUserPartitionMapping()
mcl = pm.MongoClient('10.137.172.201:27017')
coll = mcl.DataSet['PMLExpression']
MONKModelPandaStore = mcl.MONKModel['PandaStore']
monkpa = MONKModelPandaStore.find_one({'creator': 'monk', 'name': pandaName}, {'_id':True, 'weights':True, 'z':True}, timeout=False)
z = FlexibleVector(generic=monkpa['z'])
resGTs = {}
for user in testData.keys():
if user == '':
continue
pa = MONKModelPandaStore.find_one({'creator': user, 'name': pandaName}, {'_id':True, 'weights':True, 'z':True}, timeout=False)
if pa == None:
continue
if isPersonalized == True:
wei = FlexibleVector(generic=pa['weights'])
else:
wei = z
resGT = []
for ent in coll.find({'_id': {'$in':testData[user]}}, {'_features':True, 'labels':True}, timeout=False):
fea = FlexibleVector(generic=ent['_features'])
if not len(ent['labels']) == 0:
resGT.append((float(wei.dot(fea)), 1.0))
else:
resGT.append((float(wei.dot(fea)), 0.0))
resGTs[user] = resGT
del wei
mcl.close()
return resGTs
def clone(self, userName, panda):
obj = super(Mantis, self).clone(userName)
obj.mu = FlexibleVector()
obj.dq = FlexibleVector()
obj.q = self.panda.z.clone()
obj.panda = panda
obj.solver = SVMDual(panda.weights, self.eps, self.rho, self.gamma,
self.maxNumIters, self.maxNumInstances)
obj.data = {}
return obj
def __restore__(self):
super(Mantis, self).__restore__()
self.solver = None
try:
self.mu = FlexibleVector(generic=self.mu)
self.q = FlexibleVector(generic=self.q)
self.dq = FlexibleVector(generic=self.dq)
self.data = {ObjectId(k): v for k, v in self.data.iteritems()}
return True
except Exception as e:
logger.error('error {0}'.format(e.message))
logger.error('can not create a solver for {0}'.format(
self.panda.name))
return False
def merge(self, follower, m):
if follower != self.creator:
fdq = crane.mantisStore.load_one(
{
'name': self.name,
'creator': follower
}, {
'dq': True
}).get('dq', [])
fdq = FlexibleVector(generic=fdq)
else:
fdq = self.dq
rd = (fdq.norm() + EPS) / (self.panda.z.norm() + EPS)
if rd < self.eps:
logger.debug('Converged, no need to merge')
return False
else:
self.panda.z.add(fdq, 1.0 / (m + 1 / self.rho))
logger.debug('m = {0}'.format(m))
logger.debug('update z {0}'.format(self.panda.z))
logger.debug('relative difference of z {0}'.format(rd))
metricValue(self, 'rz', rd)
#self.panda.update_fields({self.panda.FCONSENSUS:self.panda.z.generic()})
if fdq is not self.dq:
del fdq
return True
def train(self, leader):
if not self.data:
logger.debug('no data, skip training')
return
logger.debug('gamma in mantis {0}'.format(self.gamma))
# check out z
if leader:
z = crane.pandaStore.load_one(
{
'name': self.panda.name,
'creator': leader
}, {
'z': True
}).get('z', [])
z = FlexibleVector(generic=z)
else:
z = self.panda.z
if z is None:
logger.debug('no consensus checked out')
return
#metricAbs(metricLog, self, '|z|', z)
#metricAbs(metricLog, self, '|q|', self.q)
metricRelAbs(self, 'z~q', self.q, z)
# update mu
self.dq.clear()
self.dq.add(self.mu, -1)
self.mu.add(self.q, 1)
self.mu.add(z, -1)
self.dq.add(self.mu, 1)
metricAbs(self, 'mu', self.mu)
#metricAbs(metricLog, self, '|dmu|', self.dq)
#metricValue(metricLog, self, 'sup(mu)', 2 * self.solver.num_instances * self.solver.maxxnorm() * z.norm())
# update w
self.solver.setModel0(z, self.mu)
#loss = self.solver.status()
#metricValue(metricLog, self, 'loss', loss)
#metricRelAbs(metricLog, self, '|q~w|', self.q, self.panda.weights)
#logger.debug('q = {0}'.format(self.q))
#logger.debug('w = {0}'.format(self.panda.weights))
self.solver.trainModel()
loss = self.solver.status()
metricValue(self, 'loss', loss)
metricValue(self, 'x', self.solver.maxxnorm())
# update q
r = self.rho / float(self.rho + self.gamma)
self.dq.add(self.q, -1)
self.q.clear()
self.q.add(z, r)
self.q.add(self.panda.weights, 1 - r)
self.q.add(self.mu, -r)
self.dq.add(self.q, 1)
if z is not self.panda.z:
del z
logger.debug('q = {0}'.format(self.q))
logger.debug('w = {0}'.format(self.panda.weights))
# measure convergence
#metricAbs(self, '|dq|', self.dq)
#metricAbs(self, '|q|', self.q)
metricRelAbs(self, 'q~w', self.q, self.panda.weights)
# commit changes
self.panda.update_fields(
{self.panda.FWEIGHTS: self.panda.weights.generic()})
self.commit()
def __restore__(self):
super(LinearPanda, self).__restore__()
self.weights = FlexibleVector(generic=self.weights)
self.z = FlexibleVector(generic=self.z)
