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 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)
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)