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)
