def main():
"""Read the configuration and run the network"""
args = parse_args()
# Heaps are sized for the j11_v2 network. Changing the network will
# require updating network_heap_size and param_heap_size
config_file = '../test/testvecs/config/infer/tidl_config_j11_v2.txt'
configuration = Configuration()
configuration.read_from_file(config_file)
configuration.enable_api_trace = False
configuration.num_frames = args.num_frames
# Heap sizes for this network determined using Configuration.showHeapStats
configuration.param_heap_size = (3 << 20)
configuration.network_heap_size = (20 << 20)
num_dsp = Executor.get_num_devices(DeviceType.DSP)
num_eve = Executor.get_num_devices(DeviceType.EVE)
if num_dsp == 0 or num_eve == 0:
print('This example requires EVEs and DSPs.')
return
enable_time_stamps("2eo_opt_timestamp.log", 16)
run(num_eve, num_dsp, configuration)
def main():
"""Read the configuration and run the network"""
args = parse_args()
# Heaps are sized for the j11_v2 network. Changing the network will
# require updating network_heap_size and param_heap_size
config_file = '../test/testvecs/config/infer/tidl_config_j11_v2.txt'
configuration = Configuration()
configuration.read_from_file(config_file)
configuration.enable_api_trace = False
configuration.num_frames = args.num_frames
num_dsp = Executor.get_num_devices(DeviceType.DSP)
num_eve = Executor.get_num_devices(DeviceType.EVE)
if num_dsp == 0 and num_eve == 0:
print('No TIDL API capable devices available')
return
enable_time_stamps("1eo_timestamp.log", 16)
run(num_eve, num_dsp, configuration)
return
def run(num_eve, num_dsp, c):
""" Run the network on the specified device type and number of devices"""
print('Running on {} EVEs, {} DSPs'.format(num_eve, num_dsp))
dsp_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_dsp])
eve_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_eve])
c.layer_index_to_layer_group_id = {
12: DSP_LAYER_GROUP_ID,
13: DSP_LAYER_GROUP_ID,
14: DSP_LAYER_GROUP_ID
}
try:
print('TIDL API: performing one time initialization ...')
eve = Executor(DeviceType.EVE, eve_device_ids, c, EVE_LAYER_GROUP_ID)
dsp = Executor(DeviceType.DSP, dsp_device_ids, c, DSP_LAYER_GROUP_ID)
num_eve_eos = eve.get_num_execution_objects()
num_dsp_eos = dsp.get_num_execution_objects()
eops = []
num_pipe = max(num_eve_eos, num_dsp_eos)
for i in range(num_pipe):
eops.append(
ExecutionObjectPipeline(
[eve.at(i % num_eve_eos),
dsp.at(i % num_dsp_eos)]))
allocate_memory(eops)
# Open input, output files
f_in = open(c.in_data, 'rb')
f_out = open(c.out_data, 'wb')
print('TIDL API: processing input frames ...')
num_eops = len(eops)
for frame_index in range(c.num_frames + num_eops):
eop = eops[frame_index % num_eops]
if eop.process_frame_wait():
write_output(eop, f_out)
if read_frame(eop, frame_index, c, f_in):
eop.process_frame_start_async()
f_in.close()
f_out.close()
free_memory(eops)
except TidlError as err:
print(err)
def run(num_eve, num_dsp, configuration):
""" Run the network on the specified device type and number of devices"""
print('Running network across {} EVEs, {} DSPs'.format(num_eve, num_dsp))
dsp_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_dsp])
eve_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_eve])
# Heap sizes for this network determined using Configuration.showHeapStats
configuration.param_heap_size = (3 << 20)
configuration.network_heap_size = (20 << 20)
try:
print('TIDL API: performing one time initialization ...')
# Collect all EOs from EVE and DSP executors
eos = []
if len(eve_device_ids) != 0:
eve = Executor(DeviceType.EVE, eve_device_ids, configuration, 1)
for i in range(eve.get_num_execution_objects()):
eos.append(eve.at(i))
if len(dsp_device_ids) != 0:
dsp = Executor(DeviceType.DSP, dsp_device_ids, configuration, 1)
for i in range(dsp.get_num_execution_objects()):
eos.append(dsp.at(i))
allocate_memory(eos)
# Open input, output files
f_in = open(configuration.in_data, 'rb')
f_out = open(configuration.out_data, 'wb')
print('TIDL API: processing input frames ...')
num_eos = len(eos)
for frame_index in range(configuration.num_frames + num_eos):
execution_object = eos[frame_index % num_eos]
if execution_object.process_frame_wait():
report_time(execution_object)
write_output(execution_object, f_out)
if read_frame(execution_object, frame_index, configuration, f_in):
execution_object.process_frame_start_async()
f_in.close()
f_out.close()
free_memory(eos)
except TidlError as err:
print(err)
def run(device_type, num_devices, configuration):
""" Run the network on a single device and dump output of each layer"""
print('Running network on {} {}'.format(num_devices, device_type))
device_ids = set([DeviceId.ID0])
try:
print('TIDL API: performing one time initialization ...')
executor = Executor(device_type, device_ids, configuration, 1)
# Collect all EOs from EVE and DSP executors
eos = []
for i in range(executor.get_num_execution_objects()):
eos.append(executor.at(i))
allocate_memory(eos)
# Open input, output files
f_in = open(configuration.in_data, 'rb')
print('TIDL API: processing input frames ...')
num_eos = len(eos)
for frame_index in range(configuration.num_frames + num_eos):
execution_object = eos[frame_index % num_eos]
if execution_object.process_frame_wait():
execution_object.write_layer_outputs_to_file()
if read_frame(execution_object, frame_index, configuration, f_in):
execution_object.process_frame_start_async()
f_in.close()
free_memory(eos)
except TidlError as err:
print(err)
def main():
"""Read the configuration and run the network"""
#logging.basicConfig(level=logging.INFO)
args = parse_args()
config_file = '../test/testvecs/config/infer/tidl_config_j11_v2.txt'
labels_file = '../imagenet/imagenet_objects.json'
configuration = Configuration()
configuration.read_from_file(config_file)
if os.path.isfile(args.input_file):
configuration.in_data = args.input_file
else:
print('Input image {} does not exist'.format(args.input_file))
return
print('Input: {}'.format(args.input_file))
num_eve = Executor.get_num_devices(DeviceType.EVE)
num_dsp = Executor.get_num_devices(DeviceType.DSP)
if num_eve == 0 and num_dsp == 0:
print('No TIDL API capable devices available')
return
# use 1 EVE or DSP since input is a single image
# If input is a stream of images, feel free to use all EVEs and/or DSPs
if num_eve > 0:
num_eve = 1
num_dsp = 0
else:
num_dsp = 1
run(num_eve, num_dsp, configuration, labels_file)
return
def main():
""" Parse arguments, read configuration and run network"""
parser = argparse.ArgumentParser(
description='Dump output of each network layer to file.')
parser.add_argument(
'-c',
'--config_file',
default='../test/testvecs/config/infer/tidl_config_j11_v2.txt',
help='Path to TIDL config file')
args = parser.parse_args()
# Run network for 1 frame since we interested in intermediate layer outputs
num_frames = 1
# Read configuration from file
configuration = Configuration()
configuration.read_from_file(args.config_file)
configuration.enable_layer_dump = True
configuration.num_frames = num_frames
num_dsp = Executor.get_num_devices(DeviceType.DSP)
num_eve = Executor.get_num_devices(DeviceType.EVE)
if num_dsp == 0 and num_eve == 0:
print('No TIDL API capable devices available')
return
if num_eve > 0:
device_type = DeviceType.EVE
else:
device_type = DeviceType.DSP
# Since we are dumping layer outputs, just run on one device
run(device_type, 1, configuration)
def main():
"""Read the configuration and run the network"""
args = parse_args()
config_file = '../test/testvecs/config/infer/tidl_config_mnist_lenet.txt'
labels_file = '../test/testvecs/input/digits10_labels_10x1.y'
configuration = Configuration()
configuration.read_from_file(config_file)
num_eve = Executor.get_num_devices(DeviceType.EVE)
num_dsp = 0
if num_eve == 0:
print('MNIST network currently supported only on EVE')
return
run(num_eve, num_dsp, configuration, labels_file)
return
def run(num_eve, num_dsp, configuration, labels_file):
""" Run the network on the specified device type and number of devices"""
logging.info('Running network across {} EVEs, {} DSPs'.format(
num_eve, num_dsp))
dsp_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_dsp])
eve_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_eve])
# Heap sizes for this network determined using Configuration.showHeapStats
configuration.param_heap_size = (3 << 20)
configuration.network_heap_size = (20 << 20)
try:
logging.info('TIDL API: performing one time initialization ...')
# Collect all EOs from EVE and DSP executors
eos = []
if eve_device_ids:
eve = Executor(DeviceType.EVE, eve_device_ids, configuration, 1)
for i in range(eve.get_num_execution_objects()):
eos.append(eve.at(i))
if dsp_device_ids:
dsp = Executor(DeviceType.DSP, dsp_device_ids, configuration, 1)
for i in range(dsp.get_num_execution_objects()):
eos.append(dsp.at(i))
eops = []
num_eos = len(eos)
for j in range(PIPELINE_DEPTH):
for i in range(num_eos):
eops.append(ExecutionObjectPipeline([eos[i]]))
allocate_memory(eops)
# open labels file
with open(labels_file) as json_file:
labels_data = json.load(json_file)
configuration.num_frames = 1
logging.info('TIDL API: processing {} input frames ...'.format(
configuration.num_frames))
num_eops = len(eops)
for frame_index in range(configuration.num_frames + num_eops):
eop = eops[frame_index % num_eops]
if eop.process_frame_wait():
process_output(eop, labels_data)
if read_frame(eop, frame_index, configuration):
eop.process_frame_start_async()
free_memory(eops)
except TidlError as err:
print(err)
def run(num_eve, num_dsp, configuration, labels_file):
""" Run the network on the specified device type and number of devices"""
print('Running network across {} EVEs, {} DSPs'.format(num_eve, num_dsp))
dsp_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_dsp])
eve_device_ids = set(
[DeviceId.ID0, DeviceId.ID1, DeviceId.ID2, DeviceId.ID3][0:num_eve])
# Heap sizes for this network determined using Configuration.showHeapStats
configuration.param_heap_size = (3 << 20)
configuration.network_heap_size = (20 << 20)
try:
print('TIDL API: performing one time initialization ...')
# Collect all EOs from EVE and DSP executors
eos = []
if eve_device_ids:
eve = Executor(DeviceType.EVE, eve_device_ids, configuration, 1)
for i in range(eve.get_num_execution_objects()):
eos.append(eve.at(i))
if dsp_device_ids:
dsp = Executor(DeviceType.DSP, dsp_device_ids, configuration, 1)
for i in range(dsp.get_num_execution_objects()):
eos.append(dsp.at(i))
eops = []
num_eos = len(eos)
for j in range(PIPELINE_DEPTH):
for i in range(num_eos):
eops.append(ExecutionObjectPipeline([eos[i]]))
allocate_memory(eops)
# Open input, output files
f_in = open(configuration.in_data, 'rb')
f_labels = open(labels_file, 'rb')
input_size = os.path.getsize(configuration.in_data)
configuration.num_frames = int(
input_size / (configuration.height * configuration.width))
print('TIDL API: processing {} input frames ...'.format(
configuration.num_frames))
num_eops = len(eops)
num_errors = 0
for frame_index in range(configuration.num_frames + num_eops):
eop = eops[frame_index % num_eops]
if eop.process_frame_wait():
num_errors += process_output(eop, f_labels)
if read_frame(eop, frame_index, configuration, f_in):
eop.process_frame_start_async()
f_in.close()
f_labels.close()
free_memory(eops)
if num_errors == 0:
print("mnist PASSED")
else:
print("mnist FAILED")
except TidlError as err:
print(err)
