def recognize_from_image():
# prepare input data
org_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
)
input_data = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='127.5',
gen_input_ailia=True)
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict([input_data])
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict([input_data])
# postprocessing
detections = but.postprocess(preds_ailia)
# generate detections
for detection in detections:
but.plot_detections(org_img, detection, save_image_path=args.savepath)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
org_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
)
input_data = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='127.5',
gen_input_ailia=True)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# compute execution time
for i in range(5):
start = int(round(time.time() * 1000))
# preds_ailia = net.predict(input_data)
input_blobs = net.get_input_blob_list()
net.set_input_blob_data(input_data, input_blobs[0])
net.update()
preds_ailia = net.get_results()
end = int(round(time.time() * 1000))
print(f'ailia processing time {end - start} ms')
# postprocessing
detections = postprocess(preds_ailia)
# generate detections
for detection in detections:
plot_detections(org_img, detection, save_image_path=args.savepath)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
input_data = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='ImageNet',
gen_input_ailia=True)
src_img = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None')
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(input_data)
# postprocessing
res_img = postprocess(src_img, preds_ailia)
cv2.imwrite(args.savepath, res_img)
print('Script finished successfully.')
def image_style_transfer():
# prepare input data
input_img = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True)
src_h, src_w, _ = cv2.imread(args.input).shape
style_img = load_image(args.style, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True)
# net initialize
vgg = ailia.Net(VGG_MODEL_PATH, VGG_WEIGHT_PATH, env_id=args.env_id)
decoder = ailia.Net(DEC_MODEL_PATH, DEC_WEIGHT_PATH, env_id=args.env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = style_transfer(vgg, decoder, input_img, style_img)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = style_transfer(vgg, decoder, input_img, style_img)
res_img = cv2.cvtColor(preds_ailia[0].transpose(1, 2, 0),
cv2.COLOR_RGB2BGR)
res_img = cv2.resize(res_img, (src_w, src_h))
cv2.imwrite(args.savepath, np.clip(res_img * 255 + 0.5, 0, 255))
print('Script finished successfully.')
def recognize_from_image(filename, net, onnx=False):
# face alignment
aligned = align_face(filename, args, face_alignment_path, face_detector_path)
if aligned is not None:
path = os.path.join(ALIGNED_PATH, filename.split('/')[-1])
aligned.save(path)
else:
path = filename
input_img = load_image(
path,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True,
)
input_img_resized = load_image(
path,
(RESIZE_HEIGHT, RESIZE_WIDTH),
normalize_type='255',
gen_input_ailia=True,
)
input_img_resized = (input_img_resized * 2) - 1
input_batch = [add_aging_channel(input_img_resized[0], age) for age in args.target_age.split(',')]
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
# ailia prediction
if not onnx:
start = int(round(time.time() * 1000))
result_batch = run_on_batch(input_batch, net)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
# onnx runtime prediction
else:
start = int(round(time.time() * 1000))
result_batch = run_on_batch(input_batch, net, onnx=True)
end = int(round(time.time() * 1000))
logger.info(f'\tonnx runtime processing time {end - start} ms')
else:
# ailia prediction
if not onnx:
result_batch = run_on_batch(input_batch, net)
# onnx runtime prediction
else:
result_batch = run_on_batch(input_batch, net, onnx=True)
# post processing
res = post_processing(result_batch, input_img)
# save results
savepath = get_savepath(args.savepath, filename)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res)
def estimate_from_image():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
org_img = load_image(
image_path,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
org_img = cv2.cvtColor(org_img, cv2.COLOR_BGR2RGB)
input_data = load_image(
image_path,
(IMAGE_HEIGHT, IMAGE_WIDTH),
rgb=False,
normalize_type='None',
gen_input_ailia=True,
)
# inference
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
logger.info(f"\tailia processing time {end - start} ms")
else:
preds_ailia = net.predict(input_data)
# estimated crowd count
et_count = int(np.sum(preds_ailia))
# density map
density_map = (255 * preds_ailia / np.max(preds_ailia))[0][0]
density_map = cv2.resize(density_map, (IMAGE_WIDTH, IMAGE_HEIGHT))
heatmap = cv2.applyColorMap(density_map.astype(np.uint8),
cv2.COLORMAP_JET)
cv2.putText(
heatmap,
f'Est Count: {et_count}',
(40, 440), # position
cv2.FONT_HERSHEY_SIMPLEX, # font
0.8, # fontscale
(255, 255, 255), # color
2, # thickness
)
res_img = np.hstack((org_img, heatmap))
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
logger.info('Script finished successfully.')
def recognize_from_image():
# prepare input data
num = lambda val: int(re.sub("\\D", "", val))
sorted_inputs_path = sorted(os.listdir(args.input), key=num)
input_blob = np.empty((1, 3, args.duration, IMAGE_HEIGHT, IMAGE_WIDTH))
for i, input_path in enumerate(sorted_inputs_path[0:args.duration]):
img = load_image(args.input + '/' + input_path,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
gen_input_ailia=True)
input_blob[0, :, i, :, :] = img
next_input_index = args.duration
input_frame_size = len(sorted_inputs_path)
# # net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
net.set_input_shape((1, 3, args.duration, IMAGE_HEIGHT, IMAGE_WIDTH))
# inferece
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
result = net.predict(input_blob)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
while (next_input_index < input_frame_size):
if cv2.waitKey(1) & 0xFF == ord('q'):
break
result = net.predict(input_blob)
print_mars_result(result)
preview_img = cv2.imread(args.input + '/' +
sorted_inputs_path[next_input_index -
args.duration])
cv2.imshow('preview', preview_img)
for i in range(args.duration - 1):
input_blob[0, :, i, :, :] = input_blob[0, :, i + 1, :, :]
img = load_image(args.input + '/' +
sorted_inputs_path[next_input_index],
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
gen_input_ailia=True)
input_blob[0, :, args.duration - 1, :, :] = img
next_input_index += 1
print('Script finished successfully.')
def get_batch():
number_of_pairs = ((batch_size + 1) // 2) // 2
singles = sample(singleton_folders, k=batch_size - number_of_pairs * 2)
multiples = sample(multiple_folders, k=number_of_pairs)
batch = []
for m in multiples:
ms = sample(image_paths[m], k=2)
# print(ms)
for filename in ms:
batch.append(image_utils.load_image(os.path.join(m, filename), training_params.shape))
for s in singles:
batch.append(image_utils.load_image(os.path.join(s, image_paths[s][0]), training_params.shape))
return np.array(batch)
def prepare_input_data(image_path):
if args.arch == "vggface2":
image = load_image(image_path, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
gen_input_ailia=False)
return preprocess_image_vggface2(image)
else:
# arcface
image = load_image(image_path,
image_shape=(IMAGE_HEIGHT, IMAGE_WIDTH),
rgb=False,
normalize_type='None')
return preprocess_image_arcface(image)
def extract_feature_vec_from_image():
# prepare input data
input_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
input_data = prepare_input_data(input_img)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
fe_net = ailia.Net(FE_MODEL_PATH, FE_WEIGHT_PATH, env_id=env_id)
fe_net.set_input_shape(input_data.shape)
input_dict = {'data': input_data}
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
_ = fe_net.predict(input_dict)[0]
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
_ = fe_net.predict(input_dict)[0]
# Extracting the output of a specifc layer
idx = fe_net.find_blob_index_by_name('encode1')
preds_ailia = fe_net.get_blob_data(idx)
print(preds_ailia.reshape(preds_ailia.shape[0], -1))
print('Script finished successfully.')
def _data_generator(
self, image_files: List[PurePath]) -> Tuple[np.array, np.array]:
"""Generate data from samples in specified batch."""
# initialize images and labels tensors for faster processing
X = np.empty((len(image_files), *self.target_size, 3))
invalid_image_idx = []
for i, image_file in enumerate(image_files):
# load and randomly augment image
img = load_image(image_file=image_file,
target_size=self.target_size,
grayscale=False)
if img is not None:
X[i, :] = img
else:
invalid_image_idx.append(i)
self.invalid_image_idx.append(self.counter)
self.counter += 1
if invalid_image_idx:
X = np.delete(X, invalid_image_idx, axis=0)
# apply basenet specific preprocessing
# input is 4D numpy array of RGB values within [0, 255]
X = self.basenet_preprocess(X)
return X
def recognize_from_image():
# prepare input data
input_img = cv2.imread(args.input)
data = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True)
# net initalize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# compute execution time
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(data)[0]
end = int(round(time.time() * 1000))
print(f'ailia processing time {end - start} ms')
visualize_plots(input_img, preds_ailia)
cv2.imwrite(args.savepath, input_img)
# Confidence Map
channels = preds_ailia.shape[0]
cols = 8
plot_images('confidence',
preds_ailia,
tile_shape=((int)((channels + cols - 1) / cols), cols))
print('Script finished successfully.')
def recognize_from_image():
# net initialize
pose = ailia.PoseEstimator(MODEL_PATH,
WEIGHT_PATH,
env_id=args.env_id,
algorithm=ALGORITHM)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
src_img = cv2.imread(image_path)
input_image = load_image(image_path, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None')
input_data = cv2.cvtColor(input_image, cv2.COLOR_RGB2BGRA)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
_ = pose.compute(input_data)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
_ = pose.compute(input_data)
# post-processing
count = pose.get_object_count()
logger.info(f'person_count={count}')
display_result(src_img, pose)
# cv2.imwrite(args.savepath, src_img)
cv2.imwrite(get_savepath(args.savepath, image_path), src_img)
logger.info('Script finished successfully.')
def recognize_from_image():
# prepare input data
input_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
input_data = cv2.cvtColor(input_img, cv2.COLOR_BGR2BGRA)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
classifier = ailia.Classifier(MODEL_PATH,
WEIGHT_PATH,
env_id=env_id,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32)
# compute execution time
for i in range(5):
start = int(round(time.time() * 1000))
classifier.compute(input_data, MAX_CLASS_COUNT)
count = classifier.get_class_count()
end = int(round(time.time() * 1000))
print(f'ailia processing time {end - start} ms')
# postprocessing
for idx in range(count):
# print result
print(f'+ idx={idx}')
info = classifier.get_class(idx)
print(f' category={info.category}' +\
f'[ {inceptionv3_labels.imagenet_category[info.category]} ]')
print(f' prob={info.prob}')
print('Script finished successfully.')
def recognize_from_image():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
src_img = cv2.imread(image_path)
input_data = load_image(
image_path,
(IMAGE_HEIGHT, IMAGE_WIDTH),
)
input_data = input_data[np.newaxis, :, :, :]
net.set_input_shape(input_data.shape)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(input_data)
# postprocessing
pred = preds_ailia.reshape((IMAGE_HEIGHT, IMAGE_WIDTH))
dst = transfer(src_img, pred)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, dst)
logger.info('Script finished successfully.')
def recognize_from_image():
# prepare input data
img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
if args.add_noise:
img = add_noise(img)
img = img / 255.0
input_data = img.transpose(2, 0, 1)
input_data.shape = (1, ) + input_data.shape
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# compute execution time
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
print(f'ailia processing time {end - start} ms')
# postprocessing
output_img = preds_ailia[0].transpose(1, 2, 0) * 255
output_img = np.clip(output_img, 0, 255)
output_img = cv2.cvtColor(output_img, cv2.COLOR_RGB2BGR)
cv2.imwrite(args.savepath, output_img)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
input_data = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
gen_input_ailia=False)
input_data = cv2.cvtColor(input_data.astype(np.float32),
cv2.COLOR_RGB2BGRA).astype(np.uint8)
# net initialize
classifier = ailia.Classifier(MODEL_PATH,
WEIGHT_PATH,
env_id=args.env_id,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
range=ailia.NETWORK_IMAGE_RANGE_S_FP32)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
classifier.compute(input_data, MAX_CLASS_COUNT)
# count = classifier.get_class_count()
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
classifier.compute(input_data, MAX_CLASS_COUNT)
# count = classifier.get_class_count()
# show results
print_results(classifier, efficientnet_labels.imagenet_category)
print('Script finished successfully.')
def recognize_tag_from_image():
# prepare input data
input_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
input_data = prepare_input_data(input_img)
# net initialize
tag_net = ailia.Net(TAG_MODEL_PATH, TAG_WEIGHT_PATH, env_id=args.env_id)
tag_net.set_input_shape(input_data.shape)
if check_file_existance(TAG_PATH):
tags = np.array(json.loads(open(TAG_PATH, 'r').read()))
assert(len(tags) == 1539)
input_dict = {'data': input_data}
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = tag_net.predict(input_dict)[0]
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = tag_net.predict(input_dict)[0]
prob = preds_ailia.reshape(preds_ailia.shape[0], -1)
preds = estimate_top_tags(prob, tags, 512) # TODO how to decide n_tag?
pprint(apply_threshold(preds, THRESHOLD))
print('Script finished successfully.')
def unwarp_from_image():
org_img = cv2.imread(args.input)
img = load_image(args.input, (WC_IMG_HEIGHT, WC_IMG_WIDTH),
normalize_type='255',
gen_input_ailia=True)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
bm_net = ailia.Net(BM_MODEL_PATH, BM_WEIGHT_PATH, env_id=env_id)
wc_net = ailia.Net(WC_MODEL_PATH, WC_WEIGHT_PATH, env_id=env_id)
# compute exectuion time
for i in range(5):
start = int(round(time.time() * 1000))
wc_output = wc_net.predict(img)[0]
pred_wc = np.clip(wc_output, 0, 1.0).transpose(1, 2, 0)
bm_input = cv2.resize(pred_wc,
(BM_IMG_WIDTH, BM_IMG_HEIGHT)).transpose(
2, 0, 1)
bm_input = np.expand_dims(bm_input, 0)
outputs_bm = bm_net.predict(bm_input)[0]
uwpred = unwarp(org_img, outputs_bm) # This is not on GPU!
end = int(round(time.time() * 1000))
print("ailia processing time {} ms".format(end - start))
cv2.imwrite(args.savepath, uwpred * 255)
print('Script finished successfully.')
def unwarp_from_image():
org_img = cv2.imread(args.input)
img = load_image(args.input, (WC_IMG_HEIGHT, WC_IMG_WIDTH),
normalize_type='255',
gen_input_ailia=True)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
bm_net = ailia.Net(BM_MODEL_PATH, BM_WEIGHT_PATH, env_id=env_id)
wc_net = ailia.Net(WC_MODEL_PATH, WC_WEIGHT_PATH, env_id=env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
uwpred = run_inference(wc_net, bm_net, img, org_img)
end = int(round(time.time() * 1000))
print("\tailia processing time {} ms".format(end - start))
else:
uwpred = run_inference(wc_net, bm_net, img, org_img)
cv2.imwrite(args.savepath, uwpred * 255)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
org_img = cv2.imread(args.input)
img = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
rgb=False,
normalize_type='None')
img = cv2.equalizeHist(img)
if platform.system() == 'Darwin': # For Mac OS (FP16)
data = img[np.newaxis, np.newaxis, :, :] / 255.0 - 0.5
else:
data = img[np.newaxis, np.newaxis, :, :] / 127.5 - 1.0
eyeI = np.concatenate((data, data), axis=0)
eyeI = eyeI.reshape(2, IMAGE_HEIGHT, IMAGE_WIDTH, 1)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# compute execution time
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(eyeI)
preds_ailia = net.get_blob_data(
net.find_blob_index_by_name(OUTPUT_BLOB_NAME))
end = int(round(time.time() * 1000))
print(f'ailia processing time {end - start} ms')
# postprocessing
img = plot_on_image(org_img, preds_ailia)
cv2.imwrite(args.savepath, img)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
src_img = cv2.imread(args.input)
input_data = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
)
input_data = input_data[np.newaxis, :, :, :]
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
net.set_input_shape(input_data.shape)
# compute execution time
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
print(f'ailia processing time {end - start} ms')
# postprocessing
pred = preds_ailia.reshape((IMAGE_HEIGHT, IMAGE_WIDTH))
dst = transfer(src_img, pred)
cv2.imwrite(args.savepath, dst)
def recognize_from_image():
# prepare input data
input_data = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True
)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(input_data)
# postprocessing
output_img = preds_ailia[0].transpose((1, 2, 0))
output_img = cv2.cvtColor(output_img, cv2.COLOR_RGB2BGR)
cv2.imwrite(args.savepath, output_img * 255)
print('Script finished successfully.')
def unwarp_from_image():
# net initialize
bm_net = ailia.Net(BM_MODEL_PATH, BM_WEIGHT_PATH, env_id=args.env_id)
wc_net = ailia.Net(WC_MODEL_PATH, WC_WEIGHT_PATH, env_id=args.env_id)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
org_img = cv2.imread(image_path)
img = load_image(
image_path,
(WC_IMG_HEIGHT, WC_IMG_WIDTH),
normalize_type='255',
gen_input_ailia=True,
)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
uwpred = run_inference(wc_net, bm_net, img, org_img)
end = int(round(time.time() * 1000))
logger.info("\tailia processing time {} ms".format(end-start))
else:
uwpred = run_inference(wc_net, bm_net, img, org_img)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, uwpred * 255)
logger.info('Script finished successfully.')
def recognize_from_image():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
input_data = load_image(
image_path,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='ImageNet',
gen_input_ailia=True,
)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(args.benchmark_count):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(input_data)
print_results(preds_ailia, mobilenetv3_labels.imagenet_category)
logger.info('Script finished successfully.')
def recognize_from_image():
# prepare input data
src_img = cv2.imread(args.input)
input_data = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
)
input_data = input_data[np.newaxis, :, :, :]
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
net.set_input_shape(input_data.shape)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(input_data)
# postprocessing
pred = preds_ailia.reshape((IMAGE_HEIGHT, IMAGE_WIDTH))
dst = transfer(src_img, pred)
cv2.imwrite(args.savepath, dst)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
input_data = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
gen_input_ailia=True
)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(input_data)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(input_data)
# postprocessing
if args.smooth:
preds_ailia = smooth_output(preds_ailia)
save_pred(preds_ailia, args.savepath, IMAGE_HEIGHT, IMAGE_WIDTH)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
img = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
rgb=False,
gen_input_ailia=True)
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = net.predict(img)[0]
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = net.predict(img)[0]
# postprocess
fig = gen_img_from_predsailia(img, preds_ailia)
fig.savefig(args.savepath)
print('Script finished successfully.')
def estimate_from_image():
# prepare input data
org_height, org_width, _ = cv2.imread(args.input).shape
input_data = load_image(args.input, (IMAGE_HEIGHT, IMAGE_WIDTH),
gen_input_ailia=True)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
enc_net = ailia.Net(ENC_MODEL_PATH, ENC_WEIGHT_PATH, env_id=env_id)
dec_net = ailia.Net(DEC_MODEL_PATH, DEC_WEIGHT_PATH, env_id=env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
features = enc_net.predict([input_data])
preds_ailia = dec_net.predict(features)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
features = enc_net.predict([input_data])
preds_ailia = dec_net.predict(features)
# postprocessing
disp = preds_ailia[-1]
disp_resized, vmax = result_plot(disp, org_width, org_height)
plt.imsave(args.savepath, disp_resized, cmap='magma', vmax=vmax)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
src_img = cv2.imread(args.input)
input_image = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None'
)
input_data = cv2.cvtColor(input_image, cv2.COLOR_RGB2BGRA)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
pose = ailia.PoseEstimator(
MODEL_PATH, WEIGHT_PATH, env_id=env_id, algorithm=ALGORITHM
)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
_ = pose.compute(input_data)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
_ = pose.compute(input_data)
# postprocessing
count = pose.get_object_count()
print(f'person_count={count}')
display_result(src_img, pose)
cv2.imwrite(args.savepath, src_img)
print('Script finished successfully.')
def check_scipy():
import scipy
vnum = int(scipy.__version__.split('.')[1])
assert vnum>=16,"You must install scipy >=0.16.0"
check_scipy()
from squeezenet import SqueezeNet
import tensorflow as tf
tf.reset_default_graph()
sess = get_session()
SAVE_PATH = 'datasets/squeezenet.ckpt'
print(SAVE_PATH)
#if not os.path.exists(SAVE_PATH):
#raise ValueError("You need to download SqueezeNet!")
model = SqueezeNet(save_path=SAVE_PATH, sess=sess)
#load data for testing
content_img_test = preprocess_image(load_image('tubingen.jpg',size=192))[None]
style_img_test = preprocess_image(load_image('starry_night.jpg',size=192))[None]
answers = np.load('style-transfer-checks.npz')
def content_loss(content_weight,content_curr,content_orig):
return content_weight*tf.reduce_sum(tf.squared_difference(content_curr,content_orig))
def gram_matrix(features,normalize=True):
"""Inputs: the shape of features is (1,H,W,C)"""
features = tf.transpose(features,[0,3,1,2])
shape = tf.shape(features)
features = tf.reshape(features,(shape[0],shape[1],-1))
transpose_features = tf.transpose(features,[0,2,1])
output = tf.matmul(features,transpose_features)
if normalize:
output = tf.div(output,tf.cast(shape[0]*shape[1]*shape[2]*shape[3],tf.float32))
def style_transfer(content_img,style_img,content_size,style_size,content_layer,style_layers,
content_weight,style_weights,tv_weight,init_random=False):
content_pre_img = preprocess_image(load_image(content_img,size=content_size))
feats = model.extract_features(model.image) #extract features of every layer from the input image
content_targets = sess.run(feats[content_layer],{model.image:content_pre_img[None]})
style_pre_img = preprocess_image(load_image(style_img,size = style_size))
style_feats = [feats[idx] for idx in style_layers]
#to transfer gram
style_target=[]
for style_feat_var in style_feats:
style_target.append(gram_matrix(style_feat_var))
style_targets = sess.run(style_target,{model.image:style_pre_img[None]})
if init_random:
img_var = tf.Variable(tf.random_uniform(content_pre_img[None].shape,0,1),name="image")
else:
img_var = tf.Variable(content_pre_img[None], name="image")
# to compute loss
#print(img_var[None].shape)
feat = model.extract_features(img_var)
conloss = content_loss(content_weight,feat[content_layer],content_targets)
styloss = style_loss(style_weights,feat,style_layers,style_targets)
tvloss = TV_loss(img_var,tv_weight)
loss = conloss+styloss+tvloss
#params
initial_lr = 3.0
decayed_lr = 0.1
decayed_lr_at = 180
max_iters = 200
lr_var = tf.Variable(initial_lr,name="lr")
# Create train_op that updates the generated image when run
with tf.variable_scope("optimizer") as opt_scope:
train_op = tf.train.AdamOptimizer(lr_var).minimize(loss,var_list=[img_var])
# Initialize the generated image and optimization variables
opt_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,scope=opt_scope.name)
sess.run(tf.variables_initializer([lr_var,img_var]+opt_vars))
# Create an op that will clamp the image values when run
clamp_image = tf.assign(img_var,tf.clip_by_value(img_var,-1.5,1.5))
#plot
f,s = plt.subplots(1,2)
s[0].axis('off')
s[1].axis('off')
s[0].set_title('content source img')
s[1].set_title('style source img')
s[0].imshow(deprocess_image(content_pre_img))
s[1].imshow(deprocess_image(style_pre_img))
plt.show()
plt.figure()
for i in range(max_iters):
#take a optimization step to update the img
sess.run(train_op)
if i < decayed_lr_at:
sess.run(clamp_image)
if i == decayed_lr_at:
sess.run(tf.assign(lr_var,decayed_lr))
if i % 100 ==0:
print('Iteration:{}'.format(i))
img = sess.run(img_var)
plt.imshow(deprocess_image(img[0],rescale=True))
plt.axis('off')
plt.show()
print('Iteration:{}'.format(i))
img = sess.run(img_var)
plt.imshow(deprocess_image(img[0],rescale=True))
plt.axis('off')
plt.show()
def __init__(self):
self.fontmap = image_utils.load_image("res/textures", "font.png")
self.fontmap.set_colorkey((0, 0, 0))
self.defaultMask = self.fontmap.get_masks()