def getGlobalFeatureVector(self):
globalFV = FeatureVector()
curState = self
while curState.localFV != None:
globalFV.add(curState.localFV)
curState = curState.prevState
return globalFV
def getFeatureVector(self, features_list):
"""
:param features_list:list(string)
:return:FeatureVector
"""
fv = FeatureVector()
for feature in features_list:
if feature in self.featureIndexer.ObjectToIndex:
fv.add(self.featureIndexer.ObjectToIndex[feature])
return fv
def Task(self, trainType, inputQueue, resultQueue):
''' parallelising function
'''
while 1:
inputOne = inputQueue.get()
# terminal signal
if inputOne is None:
break
# update model paraments
if inputOne[0] is None:
self.model.setParam(inputOne[1])
continue
# train decode
if inputOne[1] is None:
states = self.decodeBeamSearch(inputOne[0], trainType)
# evaluate decode
else:
states = self.decodeBeamSearch(inputOne[1], "test")
resultQueue.put((inputOne[0], states[1].getFinalResult()))
continue
gradient = FeatureVector()
if trainType == 'MIRA':
K = 0 # number of candidates
for kk in xrange(1, len(states)):
if states[kk] != None:
K += 1
else:
break
b = [0.0 for kk in xrange(K)]
lam_dist = [0.0 for kk in xrange(K)]
dist = [FeatureVector() for kk in xrange(K)]
goldFV = states[0].getGlobalFeatureVector()
for kk in xrange(K):
# the score difference between
# gold-standard tree and auto tree
lam_dist[kk] = (states[0].getScore()
- states[kk+1].getScore())
b[kk] = self.loss(states[0], states[kk+1])
b[kk] -= lam_dist[kk]
#the FV difference
dist[kk] = FeatureVector.getDistVector(goldFV,
states[kk+1].getGlobalFeatureVector())
alpha = QPSolver.hildreth(dist, b)
for kk in xrange(K):
gradient.add(dist[kk], alpha[kk])
else:
if not states[1].IsGold():
gradient.add(states[0].getGlobalFeatureVector())
gradient.subtract(states[1].getGlobalFeatureVector())
resultQueue.put(gradient)
def makeVector(w, lang=None):
fv = FeatureVector()
for ind, c in enumerate(w):
fv.add(str(ind) + "-" + c)
for ind, f in enumerate(splitWord(w,2)):
fv.add(str(ind) + "-" + f)
for ind, f in enumerate(splitWord(w, 3)):
fv.add(str(ind) + "-" + f)
if lang is not None:
fv.setLabel(lang)
return fv
def trainForStructureLinearModel(self, trainSet, devSet, Iter, miniSize,
numThreads, trainType, evaluateWhileTraining):
''' Main training function
Args:
trainSet: SentenceReader, train set in the form of SentenceReader
devSet: SentenceReader, dev set in the form of SentenceReader
Iter: count of iteration
miniSize: int, num of train samples per thread #useless
numThreads: int, num of threads
trainType: str, MIRA or Standard or ...
evaluateWhileTraining: bool, true for eval while training
Returns:
None
Raise:
None
'''
bestAccuracy = 0.0
bestIter = 0
bestParams = None
trainSet.reset()
sentences = []
while trainSet.hasNext():
sentences.append(trainSet.next())
# number of sentences for each batch
num = miniSize * numThreads
# number of batch for each iteration
batchSize = int(math.ceil(1.0*len(sentences)/num))
print('Iterate %d times, '
'the batch size for each iteration is %d'%(Iter, batchSize))
# build multi-process pool
resultQueue = multiprocessing.Queue()
inputQueue = multiprocessing.Queue()
workerPool = []
for k in xrange(numThreads):
worker = multiprocessing.Process(target=self.Task,
args=(trainType, inputQueue, resultQueue))
worker.daemon = True
workerPool.append(worker)
for worker in workerPool:
worker.start()
# train iteration
for it in xrange(Iter):
print "Iteration %d\n Batch:"%it
startTime = time.time()
random.shuffle(sentences)
for i in xrange(batchSize):
# send model paraments
for worker in workerPool:
inputQueue.put([None, self.model.getParam()])
# send sentences
start = num * i
end = start + num
end = min(end, len(sentences))
if i%10 == 0:
print i,
sys.stdout.flush()
for k in xrange(start, end):
inputQueue.put([sentences[k], None])
# calculate gradient
gradient = FeatureVector()
factor = 1.0/(end - start)
# parse result
for k in xrange(end - start):
gradient.add(resultQueue.get(), factor)
avg_upd = 1.0 * Iter * batchSize - (batchSize*(it-1)+(i+1)) + 1
# avg_upd = 1.0
self.model.perceptronUpdate(gradient, avg_upd)
# batch iter end
print '\nTrain Time: %f'%(time.time() - startTime)
# evaluate and update model paraments
if evaluateWhileTraining:
startTime = time.time()
averageParams = self.model.averageParam()
# update model paraments
for worker in workerPool:
inputQueue.put([None, averageParams])
# evaluate averageParams
accuracy = self.evaluate(devSet, numThreads, miniSize, inputQueue, resultQueue)
print 'Dev Acc is %f'%accuracy
if accuracy >= bestAccuracy:
bestIter = it
bestAccuracy = accuracy
bestParams = averageParams
print 'Eval time: %f'%(time.time() - startTime)
# train iter end
for k in xrange(numThreads):
inputQueue.put(None)
for worker in workerPool:
worker.join()
if bestParams:
self.model.setParam(bestParams)
print 'The best iteration is %d'%bestIter
def makeVector(w, lang):
fv = FeatureVector()
for f in splitWord(w,2):
fv.add(f)
fv.setLabel(lang)
return fv
