def main():
args = xdnn_io.processCommandLine()
ret, handles = xdnn.createHandle(args['xclbin'], "kernelSxdnn_0")
if ret != 0:
sys.exit(1)
fpgaRT = xdnn.XDNNFPGAOp(handles, args)
fpgaOutput = fpgaRT.getOutputs()
fpgaInput = fpgaRT.getInputs()
fcWeight, fcBias = xdnn_io.loadFCWeightsBias(args)
img_paths = xdnn_io.getFilePaths(args['images'])
fcOutput = np.empty((
args['batch_sz'],
args['outsz'],
),
dtype=np.float32,
order='C')
inShape = (args['batch_sz'], ) + tuple(
tuple(fpgaRT.getInputDescriptors().values())[0][1:])
labels = xdnn_io.get_labels(args['labels'])
if args['golden']:
goldenMap = xdnn_io.getGoldenMap(args['golden'])
top5Count = 0
top1Count = 0
firstInput = list(fpgaInput.values())[0]
firstOutput = list(fpgaOutput.values())[0]
for i in range(0, len(img_paths), args['batch_sz']):
pl = []
for j, p in enumerate(img_paths[i:i + args['batch_sz']]):
firstInput[j, ...], _ = xdnn_io.loadImageBlobFromFile(
p, args['img_raw_scale'], args['img_mean'],
args['img_input_scale'], inShape[2], inShape[3])
pl.append(p)
fpgaRT.execute(fpgaInput, fpgaOutput)
xdnn.computeFC(fcWeight, fcBias, firstOutput, fcOutput)
softmaxOut = xdnn.computeSoftmax(fcOutput)
xdnn_io.printClassification(softmaxOut, pl, labels)
if args['golden']:
for j, p in enumerate(img_paths[i:i + args['batch_sz']]):
top1Count += xdnn_io.isTopK(softmaxOut[j], goldenMap, p,
labels, 1)
top5Count += xdnn_io.isTopK(softmaxOut[j], goldenMap, p,
labels, 5)
xdnn.closeHandle()
if args['golden']:
print("\nAverage accuracy (n=%d) Top-1: %.1f%%, Top-5: %.1f%%\n") % (
len(img_paths), float(top1Count) / float(len(img_paths)) * 100.,
float(top5Count) / float(len(img_paths)) * 100.)
# DRAW BOXES w/ LABELS
if display:
draw_boxes(images[i], bboxes, config['names'],
config['colors'])
log.info("Saving results as results.json")
with open("results.json", "w") as fp:
fp.write(json.dumps(results, sort_keys=True, indent=4))
def detect(self, images=None, display=False, coco=False):
self.q_fpga.put({'images': images, 'display': display, 'coco': coco})
def stop(self):
self.q_fpga.put(None)
if __name__ == '__main__':
config = xdnn_io.processCommandLine()
# Define the xyolo instance
with xyolo(batch_sz=len(config["images"]),
in_shape=eval(config["in_shape"]),
quantizecfg=config["quantizecfg"],
xclbin=config["xclbin"],
verbose=True) as detector:
detector.detect(config["images"])
detector.stop()
def main(argv):
args = xdnn_io.processCommandLine(argv)
ret, handles = xdnn.createHandle(args['xclbin'], "kernelSxdnn_0")
# ret = xdnn.createHandle(g_xclbin, "kernelSxdnn_0", g_xdnnLib)
if ret != 0:
sys.exit(1)
labels = xdnn_io.get_labels(args['labels'])
# TODO dict of tuples instead?
fpgaRT = {}
fpgaOutputs = {}
fcWeights = {}
fcBiases = {}
netFiles = {}
confNames = []
args = args['jsoncfg'] # we do not use other args' keys
for netconf_args in args:
confName = str(netconf_args['name'])
confNames += [confName]
# netconf_args['netcfg'] = './data/{}_{}.json'.format(netconf_args['net'], netconf_args['dsp'])
fpgaRT[confName] = xdnn.XDNNFPGAOp(handles, netconf_args)
netconf_args['in_shape'] = tuple((netconf_args['batch_sz'], ) + tuple(
fpgaRT[confName].getInputDescriptors().itervalues().next()[1:]))
(fcWeights[confName],
fcBiases[confName]) = xdnn_io.loadFCWeightsBias(netconf_args)
fpgaOutputs[confName] = np.empty((
netconf_args['batch_sz'],
int(netconf_args['fpgaoutsz']),
),
dtype=np.float32,
order='C')
netFiles[confName] = str(netconf_args['netcfg'])
batchArrays = []
for streamId, netconf_args in enumerate(args):
batchArrays.append(
np.empty(netconf_args['in_shape'], dtype=np.float32, order='C'))
pl = []
img_paths = xdnn_io.getFilePaths(netconf_args['images'])
for j, p in enumerate(img_paths[:netconf_args['batch_sz']]):
batchArrays[-1][j, ...], _ = xdnn_io.loadImageBlobFromFile(
p, netconf_args['img_raw_scale'], netconf_args['img_mean'],
netconf_args['img_input_scale'], netconf_args['in_shape'][2],
netconf_args['in_shape'][3])
pl.append(p)
confName = str(netconf_args['name'])
firstInputName = fpgaRT[confName].getInputs().iterkeys().next()
firstOutputName = fpgaRT[confName].getOutputs().iterkeys().next()
fpgaRT[confName].exec_async({firstInputName: batchArrays[-1]},
{firstOutputName: fpgaOutputs[confName]},
streamId)
for streamId, confName in enumerate(confNames):
fpgaRT[confName].get_result(streamId)
for netconf_args in args:
confName = str(netconf_args['name'])
fcOut = np.empty((netconf_args['batch_sz'], netconf_args['outsz']),
dtype=np.float32,
order='C')
xdnn.computeFC(fcWeights[confName], fcBiases[confName],
fpgaOutputs[confName], fcOut)
softmaxOut = xdnn.computeSoftmax(fcOut)
xdnn_io.printClassification(softmaxOut, netconf_args['images'], labels)
xdnn.closeHandle()