def loadNetwork(self):
modelFile = config.get('networkDir') + 'deploy.prototxt'
meanImage = config.get('meanImagePickle')
self.net = imagenet.ImageNetClassifier(modelFile, self.networkFile, IMAGE_DIM=config.geti('imageSize'), CROPPED_DIM=config.geti('cropSize'), MEAN_IMAGE=meanImage)
self.net.caffenet.set_phase_test()
self.net.caffenet.set_mode_gpu()
self.meanImage = self.net._IMAGENET_MEAN.swapaxes(1, 2).swapaxes(0, 1).astype('float32')
def doValidation(self, epoch):
if epoch % config.geti('validationEpochs') != 0:
return
auxRL = BoxSearchRunner('test')
auxRL.run()
indexType = config.get('evaluationIndexType')
category = config.get('category')
if indexType == 'pascal':
categories, catIndex = bse.get20Categories()
elif indexType == 'relations':
categories, catIndex = bse.getCategories()
elif indexType == 'finetunedRelations':
categories, catIndex = bse.getRelationCategories()
if category in categories:
catI = categories.index(category)
else:
catI = -1
scoredDetections = bse.loadScores(config.get('testMemory'), catI)
groundTruthFile = config.get('testGroundTruth')
#ps,rs = bse.evaluateCategory(scoredDetections, 'scores', groundTruthFile)
pl, rl = bse.evaluateCategory(scoredDetections, 'landmarks',
groundTruthFile)
line = lambda x, y, z: x + '\t{:5.3f}\t{:5.3f}\n'.format(y, z)
#print line('Validation Scores:',ps,rs)
print line('Validation Landmarks:', pl, rl)
def runNetworkTuning(self, pretrained):
my_env = os.environ.copy()
my_env['GLOG_logtostderr']='1'
my_env['GLOG_minloglevel']='0'
args = [config.get('tools') + '/finetune_net.bin', config.get('solverFile'), pretrained]
p = subprocess.Popen(args, env=my_env, cwd=self.directory)
p.wait()
return
def __init__(self, mode):
self.mode = mode
cu.mem('Reinforcement Learning Started')
self.environment = BoxSearchEnvironment(config.get(mode+'Database'), mode, config.get(mode+'GroundTruth'))
self.controller = QNetwork()
cu.mem('QNetwork controller created')
self.learner = None
self.agent = BoxSearchAgent(self.controller, self.learner)
self.task = BoxSearchTask(self.environment, config.get(mode+'GroundTruth'))
self.experiment = Experiment(self.task, self.agent)
def loadNetwork(self):
self.imgDim = config.geti('imageDim')
self.cropSize = config.geti('cropSize')
self.contextPad = config.geti('contextPad')
modelFile = config.get('convnetDir') + config.get('convNetDef')
networkFile = config.get('convnetDir') + config.get('trainedConvNet')
self.net = wrapperv0.ImageNetClassifier(modelFile, networkFile, IMAGE_DIM=self.imgDim, CROPPED_DIM=self.cropSize, MEAN_IMAGE=config.get('meanImage'))
self.net.caffenet.set_mode_gpu()
self.net.caffenet.set_phase_test()
self.imageMean = self.net._IMAGENET_MEAN.swapaxes(1, 2).swapaxes(0, 1).astype('float32')
def doNetworkTraining(self):
if self.checkpoint == 0:
# launch finetuning
self.runNetworkTuning(config.get('pretrainedModel'))
else:
# Resume training
self.runNetworkTuning(config.get('snapshotPrefix')+'_iter_'+str(self.step))
self.checkpoint += self.step
self.writeCheckpoint()
class QNetwork(ActionValueInterface):
networkFile = config.get('networkDir') + config.get(
'snapshotPrefix') + '_iter_' + config.get(
'trainingIterationsPerBatch') + '.caffemodel'
def __init__(self):
self.net = None
print 'QNetwork::Init. Loading ', self.networkFile
if os.path.exists(self.networkFile):
self.loadNetwork()
self.sampler = defaultSampler
def releaseNetwork(self):
if self.net != None:
del self.net
self.net = None
def loadNetwork(self, definition='deploy.prototxt'):
if os.path.isfile(self.networkFile):
modelFile = config.get('networkDir') + definition
self.net = caffe.Net(modelFile, self.networkFile)
self.net.set_phase_test()
self.net.set_mode_gpu()
else:
self.net = None
def getMaxAction(self, state):
values = self.getActionValues(state)
return np.argmax(values, 1)
def getActionValues(self, state):
if self.net == None or self.exploreOrExploit() == EXPLORE:
return self.sampler()
else:
return self.getActivations(state)
def getActivations(self, state):
out = self.net.forward_all(
**{
self.net.inputs[0]:
state.reshape((state.shape[0], state.shape[1], 1, 1))
})
return out['qvalues'].squeeze(axis=(2, 3))
def setEpsilonGreedy(self, epsilon, sampler=None):
if sampler is not None:
self.sampler = sampler
self.epsilon = epsilon
def exploreOrExploit(self):
if self.epsilon > 0:
if random.random() < self.epsilon:
return EXPLORE
return EXPLOIT
def __init__(self, mode):
self.mode = mode
cu.mem('Reinforcement Learning Started')
self.environment = RegionFilteringEnvironment(
config.get(mode + 'Database'), mode)
self.controller = QNetwork()
cu.mem('QNetwork controller created')
self.learner = None
self.agent = RegionFilteringAgent(self.controller, self.learner)
self.task = RegionFilteringTask(self.environment,
config.get(mode + 'GroundTruth'))
self.experiment = Experiment(self.task, self.agent)
def getSensors(self):
# Make a vector represenation of the action that brought the agent to this state (9 features)
prevAction = np.zeros( (bs.NUM_ACTIONS) )
prevAction[self.state.actionChosen] = 1.0
# Compute features of visible region (4096 + 21)
activations = self.cnn.getActivations(self.state.box)
# Concatenate all info in the state representation vector
print activations[config.get('convnetLayer')].shape, prevAction.shape, self.startingActivations[config.get('convnetLayer')].shape
state = np.hstack( (activations[config.get('convnetLayer')], self.startingActivations[config.get('convnetLayer')], prevAction) )
self.scores = activations['prob'].tolist()
return {'image':self.imageList[self.idx], 'state':state, 'negEpisode':self.negativeEpisode}
def runNetworkTraining(self, args):
my_env = os.environ.copy()
my_env['GLOG_logtostderr']='1'
my_env['GLOG_minloglevel']='0'
monitorFile = self.directory + '/' + config.get('snapshotPrefix')+'_iter_'+str(self.checkpoint+self.step)+'.solverstate'
p = subprocess.Popen(args, env=my_env, cwd=self.directory)
while not os.path.isfile(monitorFile):
time.sleep(10)
p.terminate()
if self.checkpoint > 0:
os.remove(self.directory + '/' + config.get('snapshotPrefix')+'_iter_'+str(self.checkpoint)+'.solverstate')
os.remove(self.directory + '/' + config.get('snapshotPrefix')+'_iter_'+str(self.checkpoint))
return
def loadNetwork(self):
modelFile = config.get('networkDir') + 'deploy.prototxt'
meanImage = config.get('meanImagePickle')
self.net = imagenet.ImageNetClassifier(
modelFile,
self.networkFile,
IMAGE_DIM=config.geti('imageSize'),
CROPPED_DIM=config.geti('cropSize'),
MEAN_IMAGE=meanImage)
self.net.caffenet.set_phase_test()
self.net.caffenet.set_mode_gpu()
self.meanImage = self.net._IMAGENET_MEAN.swapaxes(1, 2).swapaxes(
0, 1).astype('float32')
def loadNetwork(self):
self.imgDim = config.geti('imageDim')
self.cropSize = config.geti('cropSize')
self.contextPad = config.geti('contextPad')
modelFile = config.get('convnetDir') + config.get('convNetDef')
networkFile = config.get('convnetDir') + config.get('trainedConvNet')
self.net = wrapperv0.ImageNetClassifier(
modelFile,
networkFile,
IMAGE_DIM=self.imgDim,
CROPPED_DIM=self.cropSize,
MEAN_IMAGE=config.get('meanImage'))
self.net.caffenet.set_mode_gpu()
self.net.caffenet.set_phase_test()
self.imageMean = self.net._IMAGENET_MEAN.swapaxes(1, 2).swapaxes(
0, 1).astype('float32')
def loadNextEpisode(self):
self.episodeDone = False
self.negativeEpisode = False
if self.selectNegativeSample(): return
# Save actions performed during this episode
if self.mode == 'test' and self.testRecord != None:
with open(config.get('testMemory') + self.imageList[self.idx] + '.txt', 'w') as outfile:
json.dump(self.testRecord, outfile)
# Load a new episode
self.idx += 1
if self.idx < len(self.imageList):
# Initialize state
previousImageName = str(int(self.imageList[self.idx])-1)
print 'Preparing starting image {}'.format(previousImageName)
self.cnn.prepareImage(previousImageName)
print 'Initial box for {} at {}'.format(previousImageName, self.groundTruth[previousImageName])
self.startingActivations = self.cnn.getActivations( self.groundTruth[previousImageName][0])
self.cnn.prepareImage(self.imageList[self.idx])
self.state = bs.BoxSearchState(self.imageList[self.idx], groundTruth=self.groundTruth)
print 'Environment::LoadNextEpisode => Image',self.idx,self.imageList[self.idx],'('+str(self.state.visibleImage.size[0])+','+str(self.state.visibleImage.size[1])+')'
else:
if self.mode == 'train':
random.shuffle(self.imageList)
self.idx = -1
self.loadNextEpisode()
else:
print 'No more images available'
# Restart record for new episode
if self.mode == 'test':
self.testRecord = {'boxes':[], 'actions':[], 'values':[], 'rewards':[], 'scores':[]}
def mergeDatasetAndRecords(self, train, val):
numTrain = len(self.dataset) * (1 - config.getf('percentOfValidation'))
numVal = len(self.dataset) * config.getf('percentOfValidation')
random.shuffle(self.dataset)
for i in range(len(self.dataset)):
imgPath = config.get('imageDir') + self.dataset[i]['img'] + '.jpg'
# record format: Action, reward, discountedMaxQ, x1, y1, x2, y2,
record = [self.dataset[i]['A'], self.dataset[i]['R'], 0.0
] + self.dataset[i]['box']
record += [self.dataset[i]['Sp']] + self.dataset[i]['Xp'] + [
self.dataset[i]['Sc']
] + self.dataset[i]['Xc']
record += [self.dataset[i]['Ap']]
if i < numTrain:
try:
train[imgPath].append(record)
except:
train[imgPath] = [record]
else:
try:
val[imgPath].append(record)
except:
val[imgPath] = [record]
return train, val
def train(self):
networkFile = config.get('networkDir') + config.get(
'snapshotPrefix') + '_iter_' + config.get(
'trainingIterationsPerBatch') + '.caffemodel'
interactions = config.geti('trainInteractions')
minEpsilon = config.getf('minTrainingEpsilon')
epochSize = len(self.environment.imageList) / 1
epsilon = 1.0
self.controller.setEpsilonGreedy(epsilon,
self.environment.sampleAction)
epoch = 1
exEpochs = config.geti('explorationEpochs')
while epoch <= exEpochs:
s = cu.tic()
print 'Epoch', epoch, ': Exploration (epsilon=1.0)'
self.runEpoch(interactions, len(self.environment.imageList))
self.task.flushStats()
self.doValidation(epoch)
s = cu.toc('Epoch done in ', s)
epoch += 1
self.learner = QLearning()
self.agent.learner = self.learner
egEpochs = config.geti('epsilonGreedyEpochs')
while epoch <= egEpochs + exEpochs:
s = cu.tic()
epsilon = epsilon - (1.0 - minEpsilon) / float(egEpochs)
if epsilon < minEpsilon: epsilon = minEpsilon
self.controller.setEpsilonGreedy(epsilon,
self.environment.sampleAction)
print 'Epoch', epoch, '(epsilon-greedy:{:5.3f})'.format(epsilon)
self.runEpoch(interactions, epochSize)
self.task.flushStats()
self.doValidation(epoch)
s = cu.toc('Epoch done in ', s)
epoch += 1
maxEpochs = config.geti('exploitLearningEpochs') + exEpochs + egEpochs
while epoch <= maxEpochs:
s = cu.tic()
print 'Epoch', epoch, '(exploitation mode: epsilon={:5.3f})'.format(
epsilon)
self.runEpoch(interactions, epochSize)
self.task.flushStats()
self.doValidation(epoch)
s = cu.toc('Epoch done in ', s)
shutil.copy(networkFile, networkFile + '.' + str(epoch))
epoch += 1
def loadNetwork(self, definition='deploy.prototxt'):
if os.path.isfile(self.networkFile):
modelFile = config.get('networkDir') + definition
self.net = caffe.Net(modelFile, self.networkFile)
self.net.set_phase_test()
self.net.set_mode_gpu()
else:
self.net = None
def coverRegion(self, box, otherImg=None):
boxes = [map(int,box)]
if otherImg is not None:
self.net.caffenet.CoverRegions(boxes, config.get('imageDir') + otherImg + '.jpg', self.id)
else:
self.net.caffenet.CoverRegions(boxes, '', self.id)
self.id += 1
return True
def loadNetwork(self, definition='deploy.prototxt'):
if os.path.isfile(self.networkFile):
modelFile = config.get('networkDir') + definition
self.net = caffe.Net(modelFile, self.networkFile)
self.net.set_phase_test()
self.net.set_mode_gpu()
else:
self.net = None
def coverRegion(self, box, otherImg=None):
boxes = [map(int, box)]
if otherImg is not None:
self.net.caffenet.CoverRegions(
boxes,
config.get('imageDir') + otherImg + '.jpg', self.id)
else:
self.net.caffenet.CoverRegions(boxes, '', self.id)
self.id += 1
return True
def train(self):
networkFile = config.get('networkDir') + config.get('snapshotPrefix') + '_iter_' + config.get('trainingIterationsPerBatch') + '.caffemodel'
interactions = config.geti('trainInteractions')
minEpsilon = config.getf('minTrainingEpsilon')
epochSize = len(self.environment.imageList)/1
epsilon = 1.0
self.controller.setEpsilonGreedy(epsilon, self.environment.sampleAction)
epoch = 1
exEpochs = config.geti('explorationEpochs')
while epoch <= exEpochs:
s = cu.tic()
print 'Epoch',epoch,': Exploration (epsilon=1.0)'
self.runEpoch(interactions, len(self.environment.imageList))
self.task.flushStats()
self.doValidation(epoch)
s = cu.toc('Epoch done in ',s)
epoch += 1
self.learner = QLearning()
self.agent.learner = self.learner
egEpochs = config.geti('epsilonGreedyEpochs')
while epoch <= egEpochs + exEpochs:
s = cu.tic()
epsilon = epsilon - (1.0-minEpsilon)/float(egEpochs)
if epsilon < minEpsilon: epsilon = minEpsilon
self.controller.setEpsilonGreedy(epsilon, self.environment.sampleAction)
print 'Epoch',epoch ,'(epsilon-greedy:{:5.3f})'.format(epsilon)
self.runEpoch(interactions, epochSize)
self.task.flushStats()
self.doValidation(epoch)
s = cu.toc('Epoch done in ',s)
epoch += 1
maxEpochs = config.geti('exploitLearningEpochs') + exEpochs + egEpochs
while epoch <= maxEpochs:
s = cu.tic()
print 'Epoch',epoch,'(exploitation mode: epsilon={:5.3f})'.format(epsilon)
self.runEpoch(interactions, epochSize)
self.task.flushStats()
self.doValidation(epoch)
s = cu.toc('Epoch done in ',s)
shutil.copy(networkFile, networkFile + '.' + str(epoch))
epoch += 1
def getSensors(self):
# Make a vector represenation of the action that brought the agent to this state (9 features)
prevAction = np.zeros((bs.NUM_ACTIONS))
prevAction[self.state.actionChosen] = 1.0
# Compute features of visible region (4096 + 21)
activations = self.cnn.getActivations(self.state.box)
# Concatenate all info in the state representation vector
print activations[config.get(
'convnetLayer')].shape, prevAction.shape, self.startingActivations[
config.get('convnetLayer')].shape
state = np.hstack(
(activations[config.get('convnetLayer')],
self.startingActivations[config.get('convnetLayer')], prevAction))
self.scores = activations['prob'].tolist()
return {
'image': self.imageList[self.idx],
'state': state,
'negEpisode': self.negativeEpisode
}
def __init__(self, imageName, groundTruth=None):
self.imageName = imageName
self.visibleImage = Image.open(config.get('imageDir') + '/' + self.imageName + '.jpg')
self.box = [0,0,0,0]
self.landmarkIndex = {}
self.actionChosen = 2
self.actionValue = 0
self.groundTruth = groundTruth
self.reset()
if self.groundTruth is not None:
self.task = bst.BoxSearchTask()
self.task.groundTruth = self.groundTruth
self.task.loadGroundTruth(self.imageName)
self.stepsWithoutLandmark = 0
def __init__(self, imageName, groundTruth=None):
self.imageName = imageName
self.visibleImage = Image.open(
config.get('imageDir') + '/' + self.imageName + '.jpg')
self.box = [0, 0, 0, 0]
self.landmarkIndex = {}
self.actionChosen = 2
self.actionValue = 0
self.groundTruth = groundTruth
self.reset()
if self.groundTruth is not None:
self.task = bst.BoxSearchTask()
self.task.groundTruth = self.groundTruth
self.task.loadGroundTruth(self.imageName)
self.stepsWithoutLandmark = 0
def doValidation(self, epoch):
if epoch % config.geti('validationEpochs') != 0:
return
auxRL = BoxSearchRunner('test')
auxRL.run()
indexType = config.get('evaluationIndexType')
category = config.get('category')
if indexType == 'pascal':
categories, catIndex = bse.get20Categories()
elif indexType == 'relations':
categories, catIndex = bse.getCategories()
elif indexType == 'finetunedRelations':
categories, catIndex = bse.getRelationCategories()
if category in categories:
catI = categories.index(category)
else:
catI = -1
scoredDetections = bse.loadScores(config.get('testMemory'), catI)
groundTruthFile = config.get('testGroundTruth')
#ps,rs = bse.evaluateCategory(scoredDetections, 'scores', groundTruthFile)
pl,rl = bse.evaluateCategory(scoredDetections, 'landmarks', groundTruthFile)
line = lambda x,y,z: x + '\t{:5.3f}\t{:5.3f}\n'.format(y,z)
#print line('Validation Scores:',ps,rs)
print line('Validation Landmarks:',pl,rl)
def writeSolverFile(self):
out = open(self.directory + '/solver.prototxt','w')
out.write('train_net: "' + self.directory + 'train.prototxt"\n')
out.write('base_lr: ' + config.get('learningRate') + '\n')
out.write('lr_policy: "step"\n')
out.write('gamma: ' + config.get('gamma') + '\n')
out.write('stepsize: ' + config.get('stepSize') + '\n')
out.write('display: 1\n')
out.write('max_iter: ' + config.get('trainingIterationsPerBatch') + '\n')
out.write('momentum: ' + config.get('momentum') + '\n')
out.write('weight_decay: ' + config.get('weightDecay') + '\n')
out.write('snapshot: ' + config.get('trainingIterationsPerBatch') + '\n')
out.write('snapshot_prefix: "' + self.directory + 'multilayer_qlearner"\n')
out.close()
def __init__(self, imageList, mode, groundTruthFile=None):
self.mode = mode
self.cnn = cn.ConvNet()
self.testRecord = None
self.idx = -1
self.imageList = [x.strip() for x in open(imageList)]
self.groundTruth = cu.loadBoxIndexFile(groundTruthFile)
#self.imageList = self.rankImages()
#self.imageList = self.imageList[0:10]
allImgs = set([x.strip() for x in open(config.get('allImagesList'))])
self.negativeSamples = list(allImgs.difference(set(self.groundTruth.keys())))
self.negativeEpisode = False
if self.mode == 'train':
self.negativeProbability = config.getf('negativeEpisodeProb')
random.shuffle(self.imageList)
self.loadNextEpisode()
def __init__(self, imageList, mode, groundTruthFile=None):
self.mode = mode
self.cnn = cn.ConvNet()
self.testRecord = None
self.idx = -1
self.imageList = [x.strip() for x in open(imageList)]
self.groundTruth = cu.loadBoxIndexFile(groundTruthFile)
#self.imageList = self.rankImages()
#self.imageList = self.imageList[0:10]
allImgs = set([x.strip() for x in open(config.get('allImagesList'))])
self.negativeSamples = list(
allImgs.difference(set(self.groundTruth.keys())))
self.negativeEpisode = False
if self.mode == 'train':
self.negativeProbability = config.getf('negativeEpisodeProb')
random.shuffle(self.imageList)
self.loadNextEpisode()
def getActionValues(self, state):
imgName = state[0]
if self.net == None or self.exploreOrExploit() == EXPLORE:
return np.random.random([len(state[1]), config.geti('outputActions')])
else:
boxes = []
stateFeatures = np.zeros( (len(state[1]), 20, 1, 1), dtype=np.float32)
for i in range(len(state[1])):
s = state[1][i]
boxes.append( map(int, s.nextBox) )
stateFeatures[i,0,0,0] = s.prevScore
stateFeatures[i,1:5,0,0] = np.asarray( s.normPrevBox() )
stateFeatures[i,5,0,0] = s.currScore
stateFeatures[i,6:10,0,0] = np.asarray( s.normCurrBox() )
if s.prevAction() >= 0:
stateFeatures[i,10 + s.prevAction(), 0,0] = 1.0
return self.getActivations(config.get('imageDir') + '/' + imgName + '.jpg', boxes, stateFeatures)
def loadNextEpisode(self):
# Save actions performed during this episode
if self.mode == 'test' and self.testRecord != None:
with open(config.get('testMemory') + self.db.image + '.txt', 'w') as outfile:
json.dump(self.testRecord, outfile)
# Load a new episode from the database
self.db.loadNext()
if self.db.image != '':
print 'Environment::LoadNextEpisode => Image',self.db.image,'({:4} boxes)'.format(self.db.boxes.shape[0])
# Initialize state
self.state = lh.LayoutHandler(self.db.boxes)
self.performAction([lh.STAY,0])
else:
print 'No more images available'
# Restart record for new episode
if self.mode == 'test':
self.testRecord = {'boxes':[], 'actions':[], 'values':[], 'rewards':[]}
def loadNextEpisode(self):
self.episodeDone = False
self.negativeEpisode = False
if self.selectNegativeSample(): return
# Save actions performed during this episode
if self.mode == 'test' and self.testRecord != None:
with open(
config.get('testMemory') + self.imageList[self.idx] +
'.txt', 'w') as outfile:
json.dump(self.testRecord, outfile)
# Load a new episode
self.idx += 1
if self.idx < len(self.imageList):
# Initialize state
previousImageName = str(int(self.imageList[self.idx]) - 1)
print 'Preparing starting image {}'.format(previousImageName)
self.cnn.prepareImage(previousImageName)
print 'Initial box for {} at {}'.format(
previousImageName, self.groundTruth[previousImageName])
self.startingActivations = self.cnn.getActivations(
self.groundTruth[previousImageName][0])
self.cnn.prepareImage(self.imageList[self.idx])
self.state = bs.BoxSearchState(self.imageList[self.idx],
groundTruth=self.groundTruth)
print 'Environment::LoadNextEpisode => Image', self.idx, self.imageList[
self.idx], '(' + str(
self.state.visibleImage.size[0]) + ',' + str(
self.state.visibleImage.size[1]) + ')'
else:
if self.mode == 'train':
random.shuffle(self.imageList)
self.idx = -1
self.loadNextEpisode()
else:
print 'No more images available'
# Restart record for new episode
if self.mode == 'test':
self.testRecord = {
'boxes': [],
'actions': [],
'values': [],
'rewards': [],
'scores': []
}
def writeSolverFile(self):
out = open(self.directory + '/solver.prototxt', 'w')
out.write('train_net: "' + self.directory + 'train.prototxt"\n')
out.write('base_lr: ' + config.get('learningRate') + '\n')
out.write('lr_policy: "step"\n')
out.write('gamma: ' + config.get('gamma') + '\n')
out.write('stepsize: ' + config.get('stepSize') + '\n')
out.write('display: 1\n')
out.write('max_iter: ' + config.get('trainingIterationsPerBatch') +
'\n')
out.write('momentum: ' + config.get('momentum') + '\n')
out.write('weight_decay: ' + config.get('weightDecay') + '\n')
out.write('snapshot: ' + config.get('trainingIterationsPerBatch') +
'\n')
out.write('snapshot_prefix: "' + self.directory +
'multilayer_qlearner"\n')
out.close()
def getActionValues(self, state):
imgName = state[0]
if self.net == None or self.exploreOrExploit() == EXPLORE:
return np.random.random(
[len(state[1]), config.geti('outputActions')])
else:
boxes = []
stateFeatures = np.zeros((len(state[1]), 20, 1, 1),
dtype=np.float32)
for i in range(len(state[1])):
s = state[1][i]
boxes.append(map(int, s.nextBox))
stateFeatures[i, 0, 0, 0] = s.prevScore
stateFeatures[i, 1:5, 0, 0] = np.asarray(s.normPrevBox())
stateFeatures[i, 5, 0, 0] = s.currScore
stateFeatures[i, 6:10, 0, 0] = np.asarray(s.normCurrBox())
if s.prevAction() >= 0:
stateFeatures[i, 10 + s.prevAction(), 0, 0] = 1.0
return self.getActivations(
config.get('imageDir') + '/' + imgName + '.jpg', boxes,
stateFeatures)
def prepareImage(self, image):
if self.image != '':
self.net.caffenet.ReleaseImageData()
self.image = config.get('imageDir') + image + '.jpg'
self.net.caffenet.InitializeImage(self.image, self.imgDim, self.imageMean, self.cropSize)
def prepareImage(self, image):
if self.image != '':
self.net.caffenet.ReleaseImageData()
self.image = config.get('imageDir') + image + '.jpg'
self.net.caffenet.InitializeImage(self.image, self.imgDim,
self.imageMean, self.cropSize)
config.readConfiguration(sys.argv[1])
detectionsFile = sys.argv[2]
groundTruth = sys.argv[3]
outputFile = sys.argv[4]
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, SARSA
from pybrain.rl.experiments import Experiment
from ObjectLocalizerEnvironment import ObjectLocalizerEnvironment
from DeepQNetwork import DeepQNetwork
from DeepQLearning import DeepQLearning
from MDPObjectLocalizerTask import MDPObjectLocalizerTask
from ObjectLocalizationAgent import ObjectLocalizationAgent
print 'Starting Environment'
environment = ObjectLocalizerEnvironment(config.get('imageDir'), detectionsFile, 'Testing')
print 'Initializing DeepQNetwork'
controller = DeepQNetwork()
print 'Preparing Agent'
agent = ObjectLocalizationAgent(controller)
print 'Configuring Task'
task = MDPObjectLocalizerTask(environment, groundTruth)
print 'Setting up Experiment'
experiment = Experiment(task, agent)
print 'Main Loop'
while environment.hasMoreEpisodes():
experiment.doInteractions(1)
print 'All test episodes done'
environment.saveRecords(outputFile)
__author__ = "Juan C. Caicedo, [email protected]" import os import utils as cu import numpy as np import caffe from caffe import wrapperv0 import RLConfig as config LAYER = config.get('convnetLayer') class ConvNet(): def __init__(self): self.net = None self.image = '' self.id = 0 self.loadNetwork() def loadNetwork(self): self.imgDim = config.geti('imageDim') self.cropSize = config.geti('cropSize') self.contextPad = config.geti('contextPad') modelFile = config.get('convnetDir') + config.get('convNetDef') networkFile = config.get('convnetDir') + config.get('trainedConvNet') self.net = wrapperv0.ImageNetClassifier( modelFile, networkFile, IMAGE_DIM=self.imgDim,
class DeepQNetwork(ActionValueInterface):
networkFile = config.get('networkDir') + config.get(
'snapshotPrefix') + '_iter_' + config.get('trainingIterationsPerBatch')
def __init__(self):
self.net = None
self.epsilon = -1
print self.networkFile
if os.path.exists(self.networkFile):
self.loadNetwork()
def releaseNetwork(self):
if self.net != None:
del self.net
self.net = None
def loadNetwork(self):
modelFile = config.get('networkDir') + 'deploy.prototxt'
meanImage = config.get('meanImagePickle')
self.net = imagenet.ImageNetClassifier(
modelFile,
self.networkFile,
IMAGE_DIM=config.geti('imageSize'),
CROPPED_DIM=config.geti('cropSize'),
MEAN_IMAGE=meanImage)
self.net.caffenet.set_phase_test()
self.net.caffenet.set_mode_gpu()
self.meanImage = self.net._IMAGENET_MEAN.swapaxes(1, 2).swapaxes(
0, 1).astype('float32')
def getMaxAction(self, state):
values = self.getActionValues(state)
return np.argmax(values, 1)
def getActionValues(self, state):
imgName = state[0]
if self.net == None or self.exploreOrExploit() == EXPLORE:
return np.random.random(
[len(state[1]), config.geti('outputActions')])
else:
boxes = []
stateFeatures = np.zeros((len(state[1]), 20, 1, 1),
dtype=np.float32)
for i in range(len(state[1])):
s = state[1][i]
boxes.append(map(int, s.nextBox))
stateFeatures[i, 0, 0, 0] = s.prevScore
stateFeatures[i, 1:5, 0, 0] = np.asarray(s.normPrevBox())
stateFeatures[i, 5, 0, 0] = s.currScore
stateFeatures[i, 6:10, 0, 0] = np.asarray(s.normCurrBox())
if s.prevAction() >= 0:
stateFeatures[i, 10 + s.prevAction(), 0, 0] = 1.0
return self.getActivations(
config.get('imageDir') + '/' + imgName + '.jpg', boxes,
stateFeatures)
def getActivations(self, imagePath, boxes, state):
n = len(boxes)
activations = cu.emptyMatrix([n, config.geti('outputActions')])
numBatches = (n + config.geti('deployBatchSize') -
1) / config.geti('deployBatchSize')
boxes += [[0, 0, 0, 0]
for x in range(numBatches * config.geti('deployBatchSize') -
n)]
stateFeatures = np.zeros((len(boxes), 20, 1, 1), dtype=np.float32)
stateFeatures[0:n, :, :, :] = state
dims = self.net.caffenet.InitializeImage(imagePath,
config.geti('imageSize'),
self.meanImage,
config.geti('cropSize'))
for k in range(numBatches):
s, f = k * config.geti('deployBatchSize'), (
k + 1) * config.geti('deployBatchSize')
e = config.geti('deployBatchSize') if f <= n else n - s
# Forward this batch
#self.net.caffenet.ForwardRegions(boxes[s:f], config.geti('contextPad'))
self.net.caffenet.ForwardRegionsAndState(
boxes[s:f], config.geti('contextPad'),
[stateFeatures[s:f, :, :, :]])
outputs = self.net.caffenet.blobs
f = n if f > n else f
# Collect outputs
activations[s:f, :] = outputs['prob'].data[0:e, :, :, :].reshape(
[e, config.geti('outputActions')])
# Release image data
self.net.caffenet.ReleaseImageData()
return activations
def setEpsilonGreedy(self, epsilon):
self.epsilon = epsilon
def exploreOrExploit(self):
if self.epsilon > 0:
if random.random() < self.epsilon:
return EXPLORE
return EXPLOIT
def __init__(self, alpha=0.5, gamma=0.99):
ValueBasedLearner.__init__(self)
self.alpha = alpha
self.gamma = gamma
self.netManager = cnm.CaffeConvNetManagement(config.get('networkDir'))
config.readConfiguration(sys.argv[1])
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, SARSA
from pybrain.rl.experiments import Experiment
from ObjectLocalizerEnvironment import ObjectLocalizerEnvironment
from DeepQNetwork import DeepQNetwork
from DeepQLearning import DeepQLearning
from MDPObjectLocalizerTask import MDPObjectLocalizerTask
from ObjectLocalizationAgent import ObjectLocalizationAgent
print 'Starting Environment'
epsilon = 1.0
environment = ObjectLocalizerEnvironment(config.get('imageDir'),
config.get('candidatesFile'),
'Training')
print 'Initializing DeepQNetwork'
controller = DeepQNetwork()
controller.setEpsilonGreedy(epsilon)
print 'Initializing Q Learner'
learner = DeepQLearning()
print 'Preparing Agent'
agent = ObjectLocalizationAgent(controller, learner)
print 'Configuring Task'
task = MDPObjectLocalizerTask(environment, config.get('groundTruth'))
print 'Setting up Experiment'
experiment = Experiment(task, agent)
i = 0
print 'Main Loop'
def __init__(self, alpha=0.5):
ValueBasedLearner.__init__(self)
self.alpha = alpha
self.gamma = config.getf('gammaDiscountReward')
self.netManager = CaffeMultiLayerPerceptronManagement(
config.get('networkDir'))
aConfig = configTemplate.format(basePath=basePath, **parametersDict)
configName = 'rl{}.config'.format('_'.join(['{key}{value}'.format(key=key, value=value) for key, value in parametersDict.iteritems()]))
configPath = os.path.join(configDir, configName)
print 'Generating config file {}'.format(configPath)
outputConfig = open(configPath, 'w')
outputConfig.write(aConfig)
outputConfig.close()
#run experiments
configNames = os.listdir(configDir)
for configName in configNames:
configPath = os.path.join(configDir, configName)
print 'Reading {} config'.format(configPath)
config.readConfiguration(configPath)
#erase models and memory
networkDir = config.get('networkDir')
snapshotPrefix = config.get('snapshotPrefix')
testMemory = config.get('testMemory')
if os.path.exists(testMemory):
print 'Removing {}'.format(testMemory)
shutil.rmtree(testMemory)
os.mkdir(testMemory)
for fileName in os.listdir(networkDir):
if fileName.startswith(snapshotPrefix):
print 'Removing {}'.format(fileName)
os.remove(os.path.join(networkDir, fileName))
outFile = open(os.path.join(outputDir, configName + '.out'), 'w')
errFile = open(os.path.join(outputDir, configName + '.err'), 'w')
process = subprocess.Popen(['time', 'python', 'BoxSearchRunner.py', configPath], stdout=outFile, stderr=errFile)
process.wait()
if not process.returncode == 0:
__author__ = "Juan C. Caicedo, [email protected]" import os import utils as cu import numpy as np import caffe from caffe import wrapperv0 import RLConfig as config LAYER = config.get('convnetLayer') class ConvNet(): def __init__(self): self.net = None self.image = '' self.id = 0 self.loadNetwork() def loadNetwork(self): self.imgDim = config.geti('imageDim') self.cropSize = config.geti('cropSize') self.contextPad = config.geti('contextPad') modelFile = config.get('convnetDir') + config.get('convNetDef') networkFile = config.get('convnetDir') + config.get('trainedConvNet') self.net = wrapperv0.ImageNetClassifier(modelFile, networkFile, IMAGE_DIM=self.imgDim, CROPPED_DIM=self.cropSize, MEAN_IMAGE=config.get('meanImage')) self.net.caffenet.set_mode_gpu() self.net.caffenet.set_phase_test() self.imageMean = self.net._IMAGENET_MEAN.swapaxes(1, 2).swapaxes(0, 1).astype('float32')
detectionsFile = sys.argv[2]
groundTruth = sys.argv[3]
outputFile = sys.argv[4]
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, SARSA
from pybrain.rl.experiments import Experiment
from ObjectLocalizerEnvironment import ObjectLocalizerEnvironment
from DeepQNetwork import DeepQNetwork
from DeepQLearning import DeepQLearning
from MDPObjectLocalizerTask import MDPObjectLocalizerTask
from ObjectLocalizationAgent import ObjectLocalizationAgent
print 'Starting Environment'
environment = ObjectLocalizerEnvironment(config.get('imageDir'),
detectionsFile, 'Testing')
print 'Initializing DeepQNetwork'
controller = DeepQNetwork()
print 'Preparing Agent'
agent = ObjectLocalizationAgent(controller)
print 'Configuring Task'
task = MDPObjectLocalizerTask(environment, groundTruth)
print 'Setting up Experiment'
experiment = Experiment(task, agent)
print 'Main Loop'
while environment.hasMoreEpisodes():
experiment.doInteractions(1)
print 'All test episodes done'
environment.saveRecords(outputFile)
def __init__(self, alpha=0.5):
ValueBasedLearner.__init__(self)
self.alpha = alpha
self.gamma = config.getf('gammaDiscountReward')
self.netManager = CaffeMultiLayerPerceptronManagement(config.get('networkDir'))
configPath = os.path.join(
configDir, configName)
print 'Generating config file {}'.format(
configPath)
outputConfig = open(configPath, 'w')
outputConfig.write(aConfig)
outputConfig.close()
#run experiments
configNames = os.listdir(configDir)
for configName in configNames:
configPath = os.path.join(configDir, configName)
print 'Reading {} config'.format(configPath)
config.readConfiguration(configPath)
#erase models and memory
networkDir = config.get('networkDir')
snapshotPrefix = config.get('snapshotPrefix')
testMemory = config.get('testMemory')
if os.path.exists(testMemory):
print 'Removing {}'.format(testMemory)
shutil.rmtree(testMemory)
os.mkdir(testMemory)
for fileName in os.listdir(networkDir):
if fileName.startswith(snapshotPrefix):
print 'Removing {}'.format(fileName)
os.remove(os.path.join(networkDir, fileName))
outFile = open(os.path.join(outputDir, configName + '.out'), 'w')
errFile = open(os.path.join(outputDir, configName + '.err'), 'w')
process = subprocess.Popen(
['time', 'python', 'BoxSearchRunner.py', configPath],
stdout=outFile,
# Draw all plots
ax[1,0].plot(range(len(epochRewards)), epochRewards)
ax[1,0].set_title('Average Reward Per Epoch')
recall = np.zeros( (len(epochRecall),2) )
recall[:,0] = epochRecall
recall[:,1] = epochLandmarks
ax[0,1].plot(range(len(epochRecall)), recall)
ax[0,1].set_title('Recall per Epoch')
ax[1,1].plot(range(len(epochIoU)), epochIoU)
ax[1,1].set_title('MaxIoU per Epoch')
pos = positives.keys(); pos.sort()
neg = negatives.keys(); neg.sort()
ind = np.arange(len(pos)); width = 0.35
rp = ax[0,2].bar(ind , [positives[k] for k in pos], width=0.35, color='g' )
rn = ax[0,2].bar(ind + width, [negatives[k] for k in neg], width=0.35, color='r' )
ax[0,2].set_title('Distribution of rewards per action')
ax[0,2].legend( (rp[0], rn[0]), ('Positive','Negative') )
ax[0,2].set_xticks(ind + width)
ax[0,2].set_xticklabels( ('XU','YU','SU','AU','XD','YD','SD','AD','LM','SR') )
ax[1,2].plot(range(len(validationLandmarks)), validationLandmarks)
ax[1,2].set_title('% Landmarks in Validation Set')
# Save Plot
plt.savefig(params['outdir'] + '/report' + config.get('category') + '.png')
recall = np.zeros((len(epochRecall), 2))
recall[:, 0] = epochRecall
recall[:, 1] = epochLandmarks
ax[0, 1].plot(range(len(epochRecall)), recall)
ax[0, 1].set_title('Recall per Epoch')
ax[1, 1].plot(range(len(epochIoU)), epochIoU)
ax[1, 1].set_title('MaxIoU per Epoch')
pos = positives.keys()
pos.sort()
neg = negatives.keys()
neg.sort()
ind = np.arange(len(pos))
width = 0.35
rp = ax[0, 2].bar(ind, [positives[k] for k in pos], width=0.35, color='g')
rn = ax[0, 2].bar(ind + width, [negatives[k] for k in neg],
width=0.35,
color='r')
ax[0, 2].set_title('Distribution of rewards per action')
ax[0, 2].legend((rp[0], rn[0]), ('Positive', 'Negative'))
ax[0, 2].set_xticks(ind + width)
ax[0, 2].set_xticklabels(
('XU', 'YU', 'SU', 'AU', 'XD', 'YD', 'SD', 'AD', 'LM', 'SR'))
ax[1, 2].plot(range(len(validationLandmarks)), validationLandmarks)
ax[1, 2].set_title('% Landmarks in Validation Set')
# Save Plot
plt.savefig(params['outdir'] + '/report' + config.get('category') + '.png')
config.readConfiguration(sys.argv[1])
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, SARSA
from pybrain.rl.experiments import Experiment
from ObjectLocalizerEnvironment import ObjectLocalizerEnvironment
from DeepQNetwork import DeepQNetwork
from DeepQLearning import DeepQLearning
from MDPObjectLocalizerTask import MDPObjectLocalizerTask
from ObjectLocalizationAgent import ObjectLocalizationAgent
print 'Starting Environment'
epsilon = 1.0
environment = ObjectLocalizerEnvironment(config.get('imageDir'), config.get('candidatesFile'), 'Training')
print 'Initializing DeepQNetwork'
controller = DeepQNetwork()
controller.setEpsilonGreedy(epsilon)
print 'Initializing Q Learner'
learner = DeepQLearning()
print 'Preparing Agent'
agent = ObjectLocalizationAgent(controller, learner)
print 'Configuring Task'
task = MDPObjectLocalizerTask(environment, config.get('groundTruth'))
print 'Setting up Experiment'
experiment = Experiment(task, agent)
i = 0
print 'Main Loop'
while i < config.geti('maximumEpochs'):
print 'Epoch',i,'(epsilon:{:5.3f})'.format(epsilon)
