def run(self, inputs, **kwargs): # type: (Any, **Any) -> Tuple[Any, ...]
"""
Computes the prediction.
See :meth:`migraphx.program.run`.
"""
if isinstance(inputs, list):
inps = {}
for i, name in enumerate(self._input_names):
inps[name] = migraphx.argument(inputs[i])
mgx_outputs = self._program.run(inps)
outs = []
for out in mgx_outputs:
outs.append(np.array(out))
return outs
else:
inp = self._program.get_parameter_shapes().keys()
if len(inp) != 1:
raise RuntimeError("Model expect {0} inputs".format(len(inp)))
inps = {inp[0]: migraphx.argument(inputs)}
mgx_outputs = self._program.run(inps)
outs = []
for out in mgx_outputs:
outs.append(np.array(out))
return self._program.run(inps)
def test_input():
if sys.version_info >= (3, 0):
test_shape([4])
test_shape([2, 3])
else:
data = list(range(4))
m = create_buffer('f', data, [4])
a1 = migraphx.argument(m)
a2 = migraphx.argument(bytearray(a1))
check_shapes(a2, m)
assert_eq(a1.tolist(), m.tolist())
def test_add_scalar():
p = migraphx.parse_onnx("add_scalar_test.onnx")
print(p)
s1 = p.get_output_shapes()[-1]
print("Compiling ...")
p.compile(migraphx.get_target("cpu"))
print(p)
s2 = p.get_output_shapes()[-1]
assert s1 == s2
d0 = list(range(120))
arg0 = create_buffer("B", d0, [2, 3, 4, 5])
d1 = [1]
arg1 = create_buffer("B", d1, ())
params = {}
params["0"] = migraphx.argument(arg0)
params["1"] = migraphx.argument(arg1)
r = p.run(params)[-1]
print(r)
def run_one_case(model, param_map):
# convert np array to model argument
pp = {}
for key, val in param_map.items():
pp[key] = migraphx.argument(val)
# run the model
model_outputs = model.run(param_map)
# convert argument to np array
outputs = []
for output in model_outputs:
outputs.append(np.array(output))
return outputs
while line:
token = line.split()
filename = token[0]
label = token[1]
img_pil = Image.open(imagedir + "/" + filename)
if img_pil.mode != 'RGB':
img_pil2 = Image.new("RGB", img_pil.size)
img_pil2.paste(img_pil)
img_pil = img_pil2
img_tensor = preprocess(img_pil)
img_tensor.unsqueeze_(0)
img_variable = Variable(img_tensor)
image = img_variable.numpy()
try:
tmp_result = migraphx.to_gpu(migraphx.argument(image))
params['0'] = tmp_result
result = np.array(migraphx.from_gpu(model.run(params)), copy=False)
maxval = result.argmax()
maxlist = result.argsort()
if int(label) == maxlist[0][999]:
ilabel = 'first'
elif int(label) == maxlist[0][998]:
ilabel = 'second'
elif int(label) == maxlist[0][997]:
ilabel = 'third'
elif int(label) == maxlist[0][996]:
ilabel = 'fourth'
elif int(label) == maxlist[0][995]:
ilabel = 'fifth'
else:
def test_shape(shape):
data = list(range(nelements(shape)))
m = create_buffer('f', data, shape)
a = migraphx.argument(m)
check_shapes(a, m)
assert_eq(a.tolist(), data)
finish_time = time.time()
result = np.array(y_out)
idx = np.argmax(result[0])
print('Tensorflow: ')
print('IDX = ', idx)
print('Time = ', '{:8.3f}'.format(finish_time - start_time))
elif framework == 'migraphx':
import migraphx
graph = migraphx.parse_tf(save_file)
if fp16:
graph.quantize_fp16()
graph.compile(migraphx.get_target("gpu"), offload_copy=False)
# allocate space with random params
params = {}
for key, value in graph.get_parameter_shapes().items():
params[key] = migraphx.allocate_gpu(value)
image = load_image(image_file, batch)
for i in range(repeat):
params['input'] = migraphx.to_gpu(migraphx.argument(image))
result = np.array(migraphx.from_gpu(graph.run(params)), copy=False)
start_time = time.time()
for i in range(repeat):
params['input'] = migraphx.to_gpu(migraphx.argument(image))
result = np.array(migraphx.from_gpu(graph.run(params)), copy=False)
finish_time = time.time()
idx = np.argmax(result[0])
print('MIGraphX: ')
print('IDX = ', idx)
print('Time = ', '{:8.3f}'.format(finish_time - start_time))
idx = np.argmax(result[0])
print('Tensorflow: ')
print('IDX = ', idx)
print('Time = ', '{:8.3f}'.format(finish_time - start_time))
elif framework == 'migraphx':
import migraphx
graph = migraphx.parse_tf(save_file)
if fp16:
migraphx.quantize_fp16(graph)
graph.compile(migraphx.get_target("gpu"))
# allocate space with random params
params = {}
#for key,value in graph.get_parameter_shapes().items():
# params[key] = migraphx.allocate_gpu(value)
image = load_image(image_file, batch)
for i in range(repeat):
params['input'] = migraphx.argument(image)
# result = np.array(graph.run(params),copy=False)
result = graph.run(params)
start_time = time.time()
for i in range(repeat):
params['input'] = migraphx.argument(image)
# result = np.array(graph.run(params),copy=False)
result = graph.run(params)
finish_time = time.time()
idx = np.argmax(result[0])
print('MIGraphX: ')
print('IDX = ', idx)
print('Time = ', '{:8.3f}'.format(finish_time - start_time))
count = 0
while (True):
# capture frame by frame
ret, frame = cap.read()
if ret: # check - some webcams need warmup operations on the frame
cropped = frame[16:304, 8:232] # 224x224
trans = cropped.transpose(2, 0, 1) # convert HWC to CHW
# convert to float, normalize and make batch size = 1
image = np.ascontiguousarray(
np.expand_dims(trans.astype('float32') / 256.0, 0))
# display the frame
cv2.imshow('frame', cropped)
params['0'] = migraphx.argument(image)
result = np.array(model.run(params)[0])
idx = np.argmax(result[0])
print idx2label[idx], " ", result[0][idx]
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# when everything is done, release the capture
cap.release()
cv2.destroyAllWindows()
