data = list_bench_files[:b] #print data fail = False mean_ptime = 0 mean_ptime_per_img = 0 for i in range(0, args.npasses + 1): #print 'testing batch size =',len(data) classif = dd.post_predict(args.sname, data, parameters_input, parameters_mllib, parameters_output) if classif['status']['code'] == 200: if i == 0: continue # skipping first pass so that the batch resize does not affect timing ptime = classif['head']['time'] ptime_per_img = ptime / b mean_ptime += ptime mean_ptime_per_img += ptime_per_img print 'pass', i, ' batch size =', b, ' / processing time =', ptime, ' / time per image = ', ptime_per_img else: print classif['status'] # reload model data = list_bench_files[:1] classif = dd.post_predict(args.sname, data, parameters_input, parameters_mllib, parameters_output) fail = True break print '>>> batch size =', b, ' / mean processing time =', mean_ptime / args.npasses, ' / mean time per image =', mean_ptime_per_img / args.npasses, ' / fail =', fail #break if autokill: dd.delete_service(args.sname)
#if c >= 10000: # break print 'building index...\n' print 'layer_size=', layer_size t.build(ntrees) t.save('index.ann') s.close() if args.search: s = shelve.open('names.bin') u = AnnoyIndex(s['layer_size'], metric) u.load('index.ann') data = [args.search] classif = dd.post_predict(sname, data, parameters_input, parameters_mllib, parameters_output) near = u.get_nns_by_vector(classif['body']['predictions'][0]['vals'], args.search_size, include_distances=True) print near near_names = [] for n in near[0]: near_names.append(s[str(n)]) print near_names cv2.imshow('query', image_resize(args.search, 224.0)) cv2.waitKey(0) for n in near_names: cv2.imshow('res', image_resize(n, 224.0)) cv2.waitKey(0) dd.delete_service(sname, clear='')
def main(): parser = argparse.ArgumentParser(description="DeepDetect benchmark tool") parser.add_argument("--host", help="server host", default="localhost") parser.add_argument("--port", help="server port", type=int, default=8080) parser.add_argument("--sname", help="service name") parser.add_argument("--img-width", help="image width", type=int, default=224) parser.add_argument("--img-height", help="image height", type=int, default=224) parser.add_argument("--bw", help="whether images are bw", action="store_true") parser.add_argument( "--histogram-equalization", "--eqhist", help="whether we apply an histogram equalization to images", action="store_true", ) parser.add_argument("--gpu", help="whether to bench GPU", action="store_true") parser.add_argument("--gpuid", help="gpu id to use", type=int, default=0) parser.add_argument("--cpu", help="whether to bench CPU", action="store_true") parser.add_argument( "--remote-bench-data-dir", help="when bench data directory, when available remotely on the server", ) parser.add_argument("--max-batch-size", help="max batch size to be tested", type=int, default=256) parser.add_argument( "--max-workspace-size", help="max workspace size for tensort bench", type=int, default=1024, ) parser.add_argument( "--list-bench-files", help="file holding the list of bench files", default="list_bench_files.txt", ) parser.add_argument("--npasses", help="number of passes for every batch size", type=int, default=5) parser.add_argument("--detection", help="whether benching a detection model", action="store_true") parser.add_argument( "--segmentation", help="whether benching a segmentation model", action="store_true", ) parser.add_argument( "--regression", help="whether benching a regression model", action="store_true", ) parser.add_argument( "--search", help="whether benching a similarity search service", action="store_true", ) parser.add_argument( "--search-multibox", help="whether benching a multibox similarity search service", action="store_true", ) parser.add_argument("--create", help="model's folder name to create a service") parser.add_argument( "--nclasses", help="number of classes for service creation", type=int, default=1000, ) parser.add_argument( "--auto-kill", help="auto kill the service after benchmarking", action="store_true", ) parser.add_argument("--csv-output", help="CSV file output") parser.add_argument("--json-output", help="JSON file output") parser.add_argument("--mllib", help="mllib to bench, ie [tensorrt|ncnn|caffe]", default="caffe") parser.add_argument("--datatype", help="datatype for tensorrt [fp16|fp32]", default="fp32") parser.add_argument( "--recreate", help= "recreate service between every batchsize, useful for batch_size dependent precompiling backends (ie tensorRT)", action="store_true", default=False, ) parser.add_argument("--dla", help="use dla", action="store_true", default=False) parser.add_argument("--gpu-resize", help="image resizing on gpu", action="store_true", default=False) parser.add_argument( "--image-interp", help="image interpolation method (nearest, linear, cubic, ...)", ) args = parser.parse_args() host = args.host port = args.port dd = DD(host, port) dd.set_return_format(dd.RETURN_PYTHON) autokill = args.auto_kill def service_create(bs): # Create a service if args.create: description = "image classification service" mllib = args.mllib model = {"repository": args.create} parameters_input = { "connector": "image", "width": args.img_width, "height": args.img_height, "bw": args.bw, "histogram_equalization": args.histogram_equalization, } if args.segmentation: parameters_input["segmentation"] = True if args.regression: parameters_input["regression"] = True if args.dla: parameters_mllib = { "nclasses": args.nclasses, "datatype": args.datatype, "readEngine": True, "writeEngine": True, "maxBatchSize": bs, "dla": 0, "maxWorkspaceSize": args.max_workspace_size, } else: parameters_mllib = { "nclasses": args.nclasses, "datatype": args.datatype, "readEngine": True, "writeEngine": True, "maxBatchSize": bs, "maxWorkspaceSize": args.max_workspace_size, } parameters_output = {} dd.put_service( args.sname, model, description, mllib, parameters_input, parameters_mllib, parameters_output, ) else: pass out_json = [] out_csv = None csv_writer = None if args.csv_output: out_csv = open(args.csv_output, "w+") csv_writer = csv.writer(out_csv) csv_writer.writerow( ["batch_size", "mean processing time", "mean time per img"]) list_bench_files = [] with open(args.list_bench_files) as f: for line in f: list_bench_files.append(args.remote_bench_data_dir + "/" + line.rstrip()) batch_sizes = [] batch_size = 1 while batch_size <= args.max_batch_size: batch_sizes.append(batch_size) if batch_size < 32: batch_size = batch_size * 2 else: batch_size += 16 parameters_input = {} if not args.image_interp == "": parameters_input["interp"] = args.image_interp if args.gpu_resize: parameters_input["cuda"] = args.gpu_resize parameters_mllib = {"gpu": args.gpu, "gpuid": args.gpuid} parameters_output = {} if args.detection: parameters_output["confidence_threshold"] = 0.1 if args.search or args.search_multibox: parameters_output["search"] = True parameters_output["rois"] = "rois" parameters_output["bbox"] = False else: parameters_output["bbox"] = True if args.search_multibox: parameters_output["multibox_rois"] = True elif args.segmentation: parameters_input["segmentation"] = True elif args.regression: parameters_output["regression"] = True elif args.search: parameters_output["search"] = True # First call to load model data = list_bench_files[:1] if not args.recreate: if not args.mllib == "tensorrt" or args.recreate: service_create(1) else: service_create(args.max_batch_size) classif = dd.post_predict(args.sname, data, parameters_input, parameters_mllib, parameters_output) for b in batch_sizes: data = list_bench_files[:b] fail = False if args.recreate: service_create(b) for i in range(5): classif = dd.post_predict( args.sname, data, parameters_input, parameters_mllib, parameters_output, ) mean_ptime = 0 mean_ptime_per_img = 0 for i in range(0, args.npasses + 1): print("testing batch size = %s" % len(data)) classif = dd.post_predict(args.sname, data, parameters_input, parameters_mllib, parameters_output) if classif["status"]["code"] == 200: if i == 0: continue # skipping first pass so that the batch resize does not affect timing ptime = classif["head"]["time"] ptime_per_img = ptime / b mean_ptime += ptime mean_ptime_per_img += ptime_per_img print( "pass %s batch size = %s / processing time = %s / time per image = %s" % (i, b, ptime, ptime_per_img)) else: print(classif["status"]) # reload model data = list_bench_files[:1] classif = dd.post_predict( args.sname, data, parameters_input, parameters_mllib, parameters_output, ) fail = True break mean_processing_time = mean_ptime / args.npasses mean_time_per_img = mean_ptime_per_img / args.npasses print( ">>> batch size = %s / mean processing time = %s / mean time per image = %s / fps = %s / fail = %s" % ( b, mean_ptime / args.npasses, mean_ptime_per_img / args.npasses, 1000 / (mean_ptime_per_img / args.npasses), fail, ), ) out_json.append({ "batch_size": b, "mean_processing_time": mean_processing_time, "mean_time_per_img": mean_time_per_img, }) if args.csv_output: csv_writer.writerow([b, mean_processing_time, mean_time_per_img]) # break if args.recreate: dd.delete_service(args.sname) if args.json_output: with open(args.json_output, "w") as outfile: json.dump(out_json, outfile) if autokill: dd.delete_service(args.sname)
for roi in res: near = u.get_nns_by_vector(roi['vals'],args.search_size,include_distances=True) near_data = [] near_distance = [] for n in near[1]: near_distance.append(n) print('distances: ') print(near_distance) for n in near[0]: near_data.append(s[str(n)]) # print query bbox img = cv2.imread(args.search) bbox = roi['bbox'] cat = roi['cat'] cv2.rectangle(img, (int(bbox['xmin']),int(bbox['ymax'])),(int(bbox['xmax']),int(bbox['ymin'])),(255,0,0),2) cv2.putText(img,cat,(int(bbox['xmin']),int(bbox['ymax'])),cv2.FONT_HERSHEY_PLAIN,1,255) cv2.imshow('query',img) cv2.waitKey(0) for n in near_data: resimg = cv2.imread(n['uri']) bbox = n['bbox'] cat = n['cat'] cv2.rectangle(resimg, (int(bbox['xmin']),int(bbox['ymax'])),(int(bbox['xmax']),int(bbox['ymin'])),(255,0,0),2) cv2.putText(resimg,cat,(int(bbox['xmin']),int(bbox['ymax'])),cv2.FONT_HERSHEY_PLAIN,1,255) cv2.imshow('res',resimg) cv2.waitKey(0) dd.delete_service(sname,clear='')
if name.lower().endswith('.caffemodel'): os.remove(os.path.join(root, name)) # copy new model recentmodel = most_recent_iteration(args.builddir) print('Using model ' + recentmodel) shutil.copy2(os.path.join('builds', args.builddir, 'snapshots', recentmodel), 'dedemodel/model.caffemodel') # setup DeepDetect service if necessary dd = DD('localhost') dd.set_return_format(dd.RETURN_PYTHON) model = {'repository': '/dockershare/ssd/dedemodel'} parameters_input = {'connector': 'image', 'width': 512, 'height': 512} parameters_mllib = {'nclasses': 7} parameters_output = {} detect = dd.delete_service('ssd') detect = dd.put_service('ssd', model, 'single-shot detector', 'caffe', parameters_input, parameters_mllib, parameters_output, 'supervised') # recursively process input directory for root, dirs, files in os.walk(folder_input): for name in sorted(files): name, ext = os.path.splitext(name) if (ext.lower().endswith(('.mp4', '.avi', '.mov')) and os.path.exists(os.path.join(root, name + '.txt')) and (args.video == 'v' or args.video == name)): # start processing the video print('Processing video ' + name + '...')
import sys import json from dd_client import DD with open('config.json', 'r') as f: config = json.load(f) service = sys.argv[1] # setting up DD client host = 'localhost' sname = config['REPO'][service]['NAME'] dd = DD(host) dd.set_return_format(dd.RETURN_PYTHON) dd.delete_service(sname, 'full')
class DNNFeatureExtractor(FeatureGenerator): def __init__(self, dnnmodel, image_files, index_repo, batch_size=32, dd_host='localhost', dd_port=8080, dd_description='image classification', meta_in='', meta_out='', captions_in='', captions_out='', mapi_in='', mapi_out=''): self.dd_host = dd_host self.dd_port = dd_port self.dd_description = dd_description self.dd_mllib = 'caffe' self.meta_in = meta_in self.meta_out = meta_out self.captions_in = captions_in self.captions_out = captions_out self.mapi_in = mapi_in self.mapi_out = mapi_out self.gpuid = 0 self.dnnmodel = dnnmodel if self.dnnmodel.extract_layer: self.dd_mltype = 'unsupervised' else: self.dd_mltype = 'supervised' self.image_files = image_files self.batch_size = batch_size self.binarized = False self.dd = DD(self.dd_host, self.dd_port) self.dd.set_return_format(self.dd.RETURN_PYTHON) self.index_repo = index_repo + '/' + self.dnnmodel.name try: os.mkdir(self.index_repo) except: #logger.warning('directory ' + self.index_repo + ' may alreay exist') pass self.st = {} # shelve used for full tags storage self.stm = {} # in memory tmp storage if self.dd_mltype == 'supervised': self.st = shelve.open(self.index_repo + '/tags.bin') self.delete_dd_service() def __del__(self): if self.dd_mltype == 'supervised': for i, t in self.stm.iteritems(): self.st[i] = t self.st.close() def create_dd_service(self): model = {'repository': self.dnnmodel.model_repo} parameters_input = { 'connector': 'image', 'width': self.dnnmodel.img_width, 'height': self.dnnmodel.img_height } parameters_mllib = { 'nclasses': self.dnnmodel.nclasses, 'gpu': True, 'gpuid': self.gpuid } parameters_output = {} screate = self.dd.put_service(self.dnnmodel.name, model, self.dd_description, self.dd_mllib, parameters_input, parameters_mllib, parameters_output, self.dd_mltype) outcode = screate['status']['code'] if outcode != 201 and outcode != 403: logger.error('failed creation of DNN service ' + self.dnnmodel.name) #return raise Exception('failed creating DNN service ' + self.dnnmodel.name) return def delete_dd_service(self): self.dd.delete_service(self.dnnmodel.name, clear='') def preproc(self): # none needed with dd at the moment return def index(self): ## feature generation, to be indexed or searched for self.create_dd_service() feature_vectors = [] uris = [] parameters_input = {} parameters_mllib = { 'gpu': True, 'gpuid': self.gpuid, 'extract_layer': self.dnnmodel.extract_layer } if self.dd_mltype == 'unsupervised': parameters_output = {'binarized': self.binarized} # pass one image to get the size of the output layer classif = self.dd.post_predict(self.dnnmodel.name, [self.image_files[0]], parameters_input, parameters_mllib, parameters_output) response_code = classif['status']['code'] if response_code != 200: print 'response=', classif logger.error( 'failed (index) initial prediction call to model ' + self.dnnmodel.name + ' via dd') self.delete_dd_service() return dim = len(classif['body']['predictions']['vals']) else: parameters_output = {'best': self.dnnmodel.best} dim = self.dnnmodel.nclasses c = 0 logger.info('dnn feature prediction and indexing for service ' + self.dnnmodel.name + ' with layer of size ' + str(dim)) with Indexer(dim, self.index_repo) as indexer: for x in batch(self.image_files, self.batch_size): classif = self.dd.post_predict(self.dnnmodel.name, x, parameters_input, parameters_mllib, parameters_output) #print classif response_code = classif['status']['code'] if response_code != 200: print 'response=', classif logger.error( 'failed (index) batch prediction call to model ' + self.dnnmodel.name + ' via dd') continue predictions = classif['body']['predictions'] if self.batch_size == 1 or len(self.image_files) == 1: predictions = [predictions] for p in predictions: if self.dd_mltype == 'unsupervised': indexer.index_single(c, p['vals'], p['uri']) if c > 0 and c % self.batch_size == 0: logger.info('indexed ' + str(c) + ' images') else: puri = str(p['uri']) indexer.index_tags_single(p['classes'], p['uri']) self.stm[puri] = [] for pc in p['classes']: self.stm[puri].append(pc['cat']) c = c + 1 indexer.build_index() indexer.save_index() logger.info('indexed a total of ' + str(c) + ' images') self.delete_dd_service() def search(self, jdataout={}): self.create_dd_service() parameters_input = {} parameters_mllib = { 'gpu': True, 'gpuid': self.gpuid, 'extract_layer': self.dnnmodel.extract_layer } if self.dd_mltype == 'unsupervised': parameters_output = {'binarized': self.binarized} else: parameters_output = {'best': self.dnnmodel.best} logger.info('dnn feature prediction and searching for service ' + self.dnnmodel.name) results = {} with Searcher(self.index_repo, search_size=500) as searcher: searcher.load_index() for x in batch(self.image_files, self.batch_size): classif = self.dd.post_predict(self.dnnmodel.name, x, parameters_input, parameters_mllib, parameters_output) response_code = classif['status']['code'] if response_code != 200: print 'response=', classif logger.error( 'failed batch (search) prediction call to model ' + self.dnnmodel.name + ' via dd') self.delete_dd_service() print classif raise Exception( 'failed batch (search) prediction call to model ' + self.dnnmodel.name) predictions = classif['body']['predictions'] if self.batch_size == 1 or len(self.image_files) == 1: predictions = [predictions] #print 'predictions=',predictions for p in predictions: if self.dd_mltype == 'unsupervised': nns = searcher.search_single(p['vals'], p['uri']) else: puri = str(p['uri']) nns = searcher.search_tags_single(p['classes'], puri) nns['tags_out_all'] = [] for nn in nns['nns_uris']: nns['tags_out_all'].append(self.st[str(nn)]) results[p['uri']] = nns self.delete_dd_service() return self.to_json(results, '/img/reuters/', '/img/tate/', self.dnnmodel.name, self.dnnmodel.description, jdataout, self.meta_in, self.meta_out, self.captions_in, self.captions_out, self.mapi_in, self.mapi_out)
dd.set_return_format(dd.RETURN_PYTHON) if not args.model_name in models_config: print('Unknown model=',args.model_name) sys.exit() model_config = models_config[args.model_name] # info call if args.info: info = dd.info() print(info) sys.exit() if args.delete: delete_service = dd.delete_service(args.model_name,clear='') print(delete_service) sys.exit() # creating ML service if args.create_service: model = {'repository':model_config['path']+args.model_name} parameters_input = {'connector':'image','width':model_config['width'],'height':model_config['height']} parameters_mllib = {'nclasses':model_config['nclasses'],'gpu':True} parameters_output = {} creation = dd.put_service(args.model_name,model,args.model_name,model_config['backend'], parameters_input,parameters_mllib,parameters_output,'supervised') print(creation) if args.img_url: parameters_input = {}
class ModelTrainer: """ Prediction Model trainer class binary char-based model training class """ def __init__(self,structure,logger,config): """ Instanciate a model trainer :param dic structure: Model Trainer specific settings eg: {"model-repo":"../models/mymodel","training-repo":"../training/mytraining","sname":"MyTrainer","test_split":0.01,"base-lr":0.01,"clevel":False,"sequence":140,"iterations":50000,"test_interval":1000,"stepsize":15000,"destroy":True,"resume":False,"finetune":False,"weights":"","nclasses":2,"documents":True,"batch-size":128,"test-batch-size":16,"gpuid":0,"mllib":"xgboost","lregression":False} *model-repo* location of the model *training-repo* location of the training files *sname* service name *test_plit* training split between 0 and < 1,type=float,default=0.01 *base_lr* initial learning rate,default=0.01,type=float *clevel* character-level convolutional net,type=boolean *sequence* sequence length for character level models,default=140,type=int *iterations* number of iterations,default=50000,type=int *test_interval* test interval',default=1000,type=int *stepsize* lr policy stepsize',default=15000,type=int *destroy* whether to destroy model',type=boolean *resume* whether to resume training,type=boolean *finetune* whether to finetune,type=boolean *weights* pre-trained weight file, when finetuning *nclasses* number of classes,type=int,default=2 *documents* whether to train from text documents (as opposed to sentences in one doc),type=boolean *batch_size* batch size,type=int,default=128 *test_batch_size* test batch size,type=int,default=16 *gpu* enable gpu usage is True, default=False *gpuid* specify gpu id,type=int,default=0 *mllib* caffe or xgboost,default='caffe' *lregression* whether to use logistic regression,type=boolean :param obj logger: DFM logger object :param obj storage: DFM storage object :param obj config: DFM global config object :returns: ModelTrainer object (instance of a modeltrainer class) """ self.config=config self.structure=structure self.logger=logger self.nclasses = self.structure['nclasses'] self.description = 'classifier' self.sname=self.structure['sname'] self.mllib = self.structure['mllib'] self.dd = DD(config['DEEP_DETECT_URI'],config['DEEP_DETECT_PORT']) self.dd.set_return_format(self.dd.RETURN_PYTHON) def createMLTrainerService(self): """ Create ML Trainer service in DeepDetect """ if self.structure['lregression']: self.template = 'lregression' else: self.template = 'mlp' layers = [800,500,200] if self.structure['clevel']: self.template = 'convnet' self.layers = ['1CR256','1CR256','4CR256','1024','1024'] self.model = {'templates':'../templates/caffe/','repository':self.structure['model-repo']} self.parameters_input = {'connector':'txt','sentences':False,'characters':self.structure['clevel'],'read_forward':True} if self.structure['documents']: self.parameters_input['sentences'] = False if self.structure['clevel']: self.parameters_input['sequence'] = self.sequence #parameters_input['alphabet'] = 'abcdef0123456789' # hex # parameters_input['alphabet'] = '_-,:?/.(){}*%0123456789abcdefghijklmnopqrstuvwxyz' # opcode #parameters_input['alphabet'] = "abcdefghijklmnopqrstuvwxyz0123456789,;.!?'"#\"/\\|_@#$%^&*~`+-=<>" self.parameters_mllib = {'template':self.template,'nclasses':self.nclasses,'db':True,'dropout':0.5} if self.mllib == 'xgboost': self.parameters_mllib['db'] = False if not self.template == 'lregression': self.parameters_mllib['layers'] = layers #parameters_mllib = {'nclasses':nclasses,'db':True} if self.structure['finetune']: self.parameters_mllib['finetuning'] = True if not self.structure['weights']: logger.error('Finetuning requires weights file') # server will fail on service creation anyways else: self.parameters_mllib['weights'] = self.structure['weights'] self.parameters_output = {} self.logger.debug("dd.put_service("+str(self.structure['sname'])+","+str(self.model)+","+str(self.description)+","+str(self.mllib)+","+str(self.parameters_input)+","+str(self.parameters_mllib)+","+str(self.parameters_output)+")") return self.dd.put_service(self.structure['sname'],self.model,self.description,self.mllib,self.parameters_input,self.parameters_mllib,self.parameters_output) def trainModel(self): """ Train the model. """ self.train_data = [self.structure['training-repo']] self.parameters_input = {'test_split':self.structure['test_split'],'shuffle':True,'db':True} if not self.structure['clevel']: self.parameters_input['min_word_length'] = 5 self.parameters_input['min_count'] = 10 self.parameters_input['count'] = False if self.mllib == 'xgboost': self.parameters_input['tfidf'] = True self.parameters_input['db'] = False else: self.parameters_input['sentences'] = True self.parameters_input['characters'] = True self.parameters_input['sequence'] = self.sequence if self.structure['documents']: self.parameters_input['sentences'] = False if self.mllib == 'caffe': self.parameters_input['db']=True self.parameters_mllib = { 'gpu':self.structure['gpu'], 'gpuid':self.structure['gpuid'], 'resume':self.structure['resume'], 'net':{ 'batch_size':self.structure['batch_size'] }, 'solver':{ 'test_interval':self.structure['test_interval'], 'test_initialization':False, 'base_lr':self.structure['base_lr'], 'solver_type':'ADAM', 'iterations':self.structure['iterations'] } }#,'lr_policy':'step','stepsize':self.structure['stepsize'],'gamma':0.5,'weight_decay':0.0001}} elif self.mllib == 'xgboost': self.parameters_mllib = { 'iterations':self.structure['iterations'], 'objective':'multi:softprob', 'booster_params':{'max_depth':50} } self.parameters_output = {'measure':['mcll','f1','cmdiag','cmfull']} if self.nclasses == 2: self.parameters_output['measure'].append('auc') self.logger.debug("dd.post_train("+self.structure['sname']+","+str(self.train_data)+","+str(self.parameters_input)+","+str(self.parameters_mllib)+","+str(self.parameters_output)+",async="+str(True)+")") self.dd.post_train(self.structure['sname'],self.train_data,self.parameters_input,self.parameters_mllib,self.parameters_output,async=True) time.sleep(1) train_status = '' while True: train_status = self.dd.get_train(self.sname,job=1,timeout=10) if train_status['head']['status'] == 'running': self.logger.debug(train_status['body']['measure']) else: self.logger.debug(train_status) break return train_status def clearMLTrainerService(self,clear=''): """ delete the service, keeping the model :param str clear: use clear='lib' to clear the model as well, default empty. :returns: DeepDetect delete result """ return self.dd.delete_service(self.sname,clear=clear)
mllib = 'caffe' dd = DD(host) dd.set_return_format(dd.RETURN_PYTHON) # creating ML service model = {'repository':model_repo} parameters_input = {'connector':'image','width':width,'height':height} parameters_mllib = {'template':'googlenet','nclasses':nclasses,'finetuning':True,'rotate':False,'mirror':True,'weights':'bvlc_googlenet.caffemodel'} parameters_output = {} dd.put_service(sname,model,description,mllib, parameters_input,parameters_mllib,parameters_output) # training / finetuning from pre-trained network train_data = ['path/to/train/data'] parameters_input = {'test_split':0.1,'shuffle':True} parameters_mllib = {'gpu':True,'net':{'batch_size':64,'test_batch_size':64},'solver':{'test_interval':4000,'iterations':50000,'snapshot':10000,'base_lr':0.01,'solver_type':'NESTEROV','test_initialization':True}} parameters_output = {'measure':['mcll','f1','acc-5']} dd.post_train(sname,train_data,parameters_input,parameters_mllib,parameters_output,async=True) time.sleep(1) train_status = '' while True: train_status = dd.get_train(sname,job=1,timeout=10) if train_status['head']['status'] == 'running': print train_status['body']['measure'] else: print train_status break dd.delete_service(sname)