def main():
if args.task == 'monodepth':
check_and_download_models(WEIGHT_MONODEPTH_PATH, MODEL_MONODEPTH_PATH,
REMOTE_PATH)
if args.onnx:
import onnxruntime
net = onnxruntime.InferenceSession(WEIGHT_MONODEPTH_PATH)
else:
net = ailia.Net(MODEL_MONODEPTH_PATH,
WEIGHT_MONODEPTH_PATH,
env_id=args.env_id)
elif args.task == 'segmentation':
check_and_download_models(WEIGHT_SEGMENTATION_PATH,
MODEL_SEGMENTATION_PATH, REMOTE_PATH)
if args.onnx:
import onnxruntime
net = onnxruntime.InferenceSession(WEIGHT_SEGMENTATION_PATH)
else:
net = ailia.Net(MODEL_SEGMENTATION_PATH,
WEIGHT_SEGMENTATION_PATH,
env_id=args.env_id)
if args.video is not None:
# video mode
recognize_from_video(net)
else:
# image mode
recognize_from_image(net)
def main():
info = {
("celeba", 256):
(WEIGHT_CELEBA256_PATH, MODEL_CELEBA256_PATH, (256, 256)),
("places", 256):
(WEIGHT_PLACES256_PATH, MODEL_PLACES256_PATH, (256, 256)),
("places", 512):
(WEIGHT_PLACES512_PATH, MODEL_PLACES512_PATH, (512, 512)),
("places", 1024):
(WEIGHT_PLACES1024_PATH, MODEL_PLACES1024_PATH, (1024, 1024))
}
key = (args.model, args.img_res)
if key not in info:
logger.error("(MODEL = %s, IMG_RESOLUTION = %s) is unmatch." % key)
logger.info("appropriate settings:\n"
"\t(MODEL = celeba, IMG_RESOLUTION = 256)\n"
"\t(MODEL = places, IMG_RESOLUTION = 256 or 512 or 1024)")
sys.exit(-1)
if "FP16" in ailia.get_environment(
args.env_id).props or platform.system() == 'Darwin':
logger.warning('This model do not work on FP16. So use CPU mode.')
args.env_id = 0
# model files check and download
weight_path, model_path, img_shape = info[key]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
# net initialize
net = ailia.Net(model_path, weight_path, env_id=args.env_id)
recognize_from_image(net, img_shape)
def main():
# model files check and download
logger.info('Checking detect_landmarks model...')
check_and_download_models(WEIGHT_LANDMARK_PATH, MODEL_LANDMARK_PATH,
REMOTE_PATH)
dic_model = {
'yolov3': (WEIGHT_YOLOV3_PATH, MODEL_YOLOV3_PATH),
'faster-rcnn': (WEIGHT_FASTERRCNN_PATH, MODEL_FASTERRCNN_PATH),
}
weight_path, model_path = dic_model[args.detector]
logger.info('Check face_detector model...')
check_and_download_models(weight_path, model_path, REMOTE_PATH)
env_id = args.env_id
# initialize
face_detector = ailia.Net(model_path, weight_path, env_id=env_id)
landmark_detector = ailia.Net(MODEL_LANDMARK_PATH,
WEIGHT_LANDMARK_PATH,
env_id=env_id)
if args.video is not None:
recognize_from_video(landmark_detector, face_detector)
else:
recognize_from_image(landmark_detector, face_detector)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
ailia_model = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
tokenizer = DistilBertTokenizer.from_pretrained(
'distilbert-base-uncased-finetuned-sst-2-english')
model_inputs = tokenizer.encode_plus(args.input, return_tensors="pt")
inputs_onnx = {
k: v.cpu().detach().numpy()
for k, v in model_inputs.items()
}
logger.info("Input : " + str(args.input))
# inference
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
score = ailia_model.predict(inputs_onnx)
end = int(round(time.time() * 1000))
logger.info("\tailia processing time {} ms".format(end - start))
else:
score = ailia_model.predict(inputs_onnx)
score = numpy.exp(score) / numpy.exp(score).sum(-1, keepdims=True)
label_name = ["negative", "positive"]
label_id = numpy.argmax(numpy.array(score))
logger.info("Label : " + str(label_name[label_id]))
logger.info("Score : " + str(score[0][0][label_id]))
logger.info('Script finished successfully.')
def main():
logger.info('=== FERPlus model ===')
dic_model = {
'majority': (WEIGHT_MAJOR_PATH, MODEL_MAJOR_PATH),
'probability': (WEIGHT_PROB_PATH, MODEL_PROB_PATH),
'crossentropy': (WEIGHT_CRSE_PATH, MODEL_CRSE_PATH),
'multi_target': (WEIGHT_MLTT_PATH, MODEL_MLTT_PATH),
}
weight_path, model_path = dic_model[args.model_name]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
if args.video or args.detection:
logger.info('=== face detection model ===')
check_and_download_models(FACE_WEIGHT_PATH, FACE_MODEL_PATH,
FACE_REMOTE_PATH)
env_id = args.env_id
# initialize
net = ailia.Net(model_path, weight_path, env_id=env_id)
detector = None
if args.video or args.detection:
detector = ailia.Net(FACE_MODEL_PATH, FACE_WEIGHT_PATH, env_id=env_id)
if args.video is not None:
recognize_from_video(net, detector)
else:
recognize_from_image(net, detector)
def main():
# model files check and download
logger.info('=== GMM model ===')
check_and_download_models(WEIGHT_GMM_PATH, MODEL_GMM_PATH, REMOTE_PATH)
logger.info('=== TOM model ===')
check_and_download_models(WEIGHT_TOM_PATH, MODEL_TOM_PATH, REMOTE_PATH)
if args.video or not args.keypoints:
logger.info('=== detector model ===')
check_and_download_models(WEIGHT_YOLOV3_PATH, MODEL_YOLOV3_PATH,
REMOTE_YOLOV3_PATH)
logger.info('=== pose model ===')
check_and_download_models(WEIGHT_POSE_PATH, MODEL_POSE_PATH,
REMOTE_POSE_PATH)
if args.video or not args.parse:
logger.info('=== human segmentation model ===')
check_and_download_models(WEIGHT_SEG_PATH, MODEL_SEG_PATH,
REMOTE_SEG_PATH)
# initialize
if args.onnx:
import onnxruntime
GMM_net = onnxruntime.InferenceSession(WEIGHT_GMM_PATH)
TOM_net = onnxruntime.InferenceSession(WEIGHT_TOM_PATH)
else:
GMM_net = ailia.Net(MODEL_GMM_PATH,
WEIGHT_GMM_PATH,
env_id=args.env_id)
TOM_net = ailia.Net(MODEL_TOM_PATH,
WEIGHT_TOM_PATH,
env_id=args.env_id)
if args.video or not args.keypoints:
det_net = ailia.Detector(
MODEL_YOLOV3_PATH,
WEIGHT_YOLOV3_PATH,
80,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV3,
env_id=args.env_id,
)
pose_net = ailia.Net(MODEL_POSE_PATH,
WEIGHT_POSE_PATH,
env_id=args.env_id)
else:
det_net = pose_net = None
if args.video or not args.parse:
seg_net = ailia.Net(MODEL_SEG_PATH,
WEIGHT_SEG_PATH,
env_id=args.env_id)
else:
seg_net = None
if args.video is not None:
# video mode
recognize_from_video(GMM_net, TOM_net, det_net, pose_net, seg_net)
else:
# image mode
recognize_from_image(GMM_net, TOM_net, det_net, pose_net, seg_net)
def main():
# check model choice, defaults to glasses-removal
global WEIGHT_PATH
global MODEL_PATH
global MODEL
model_choice = [args.glasses, args.m2f, args.anime]
if sum(model_choice) > 1:
raise ValueError('Please select only one model (-g, -m, or -a)')
elif sum(model_choice) == 0:
pass
else:
MODEL = np.argmax(model_choice)
global WEIGHT_PATH
global MODEL_PATH
WEIGHT_PATH = WEIGHT_PATH[MODEL]
MODEL_PATH = MODEL_PATH[MODEL]
# print(WEIGHT_PATH, MODEL_PATH)
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
if args.video is not None:
# video mode
process_video()
else:
# image mode
transform_image()
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
if args.arch == 'bert-base-cased' or args.arch == 'bert-base-uncased':
tokenizer = BertTokenizer.from_pretrained(args.arch)
else:
tokenizer = BertJapaneseTokenizer.from_pretrained("cl-tohoku/" +
args.arch)
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
net.set_input_blob_shape((1, PADDING_LEN),
net.find_blob_index_by_name("token_type_ids"))
net.set_input_blob_shape((1, PADDING_LEN),
net.find_blob_index_by_name("input_ids"))
net.set_input_blob_shape((1, PADDING_LEN),
net.find_blob_index_by_name("attention_mask"))
with codecs.open(args.input[0], 'r', 'utf-8', 'ignore') as f:
s = f.readlines()
for text in s:
tokenized_text = tokenizer.tokenize(text)
original_text_len = len(tokenized_text)
for j in range(len(tokenized_text), PADDING_LEN):
tokenized_text.append('[PAD]')
score = numpy.zeros((len(tokenized_text)))
suggest = {}
for i in range(0, len(tokenized_text)):
masked_index = i
if tokenized_text[masked_index] == '[PAD]':
continue
tokenized_text_saved = tokenized_text[masked_index]
tokenized_text[masked_index] = '[MASK]'
outputs = inference(net, tokenizer, tokenized_text, masked_index,
original_text_len)
target_ids = tokenizer.convert_tokens_to_ids(
[tokenized_text_saved])
index = target_ids[0]
score[masked_index] = outputs[0][0, masked_index][index]
predictions = torch.from_numpy(outputs[0][0, masked_index]).topk(1)
index = predictions.indices[0]
top_token = tokenizer.convert_ids_to_tokens([index])[0]
suggest[masked_index] = top_token
tokenized_text[masked_index] = tokenized_text_saved
fine_text = colorize(tokenized_text, score, suggest)
print(fine_text)
print('Script finished successfully.')
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
env_id = args.env_id
if args.detector:
detector = ailia.Detector(MODEL_PATH,
WEIGHT_PATH,
len(COCO_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_BGR,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_U_INT8,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOX,
env_id=env_id)
if args.detection_width != -1 or args.detection_height != -1:
detector.set_input_shape(args.detection_width,
args.detection_height)
else:
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
if args.detection_width != -1 or args.detection_height != -1:
global WIDTH, HEIGHT
WIDTH = args.detection_width
HEIGHT = args.detection_height
detector.set_input_shape((1, 3, HEIGHT, WIDTH))
if args.video is not None:
# video mode
recognize_from_video(detector)
else:
# image mode
recognize_from_image(detector)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
# net initialize
if args.detector:
detector = ailia.Detector(
MODEL_PATH,
WEIGHT_PATH,
len(COCO_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV4,
env_id=args.env_id,
)
else:
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
detector.set_input_shape((1, 3, IMAGE_HEIGHT, IMAGE_WIDTH))
if args.video is not None:
# video mode
recognize_from_video(detector)
else:
# image mode
recognize_from_image(detector)
def main():
dic_model = {
'mobilenetv2': (WEIGHT_MOBILENETV2_PATH, MODEL_MOBILENETV2_PATH),
'resnet50': (WEIGHT_RESNET50_PATH, MODEL_RESNET50_PATH),
}
# weight_path, model_path = dic_model[args.model]
weight_path, model_path = dic_model[args.model_type]
# model files check and download
check_and_download_models(weight_path, model_path, REMOTE_PATH)
# load model
env_id = args.env_id
# net initialize
if not args.onnx:
net = ailia.Net(model_path, weight_path, env_id=env_id)
else:
import onnxruntime
net = onnxruntime.InferenceSession(weight_path)
if args.video is not None:
# video mode
recognize_from_video(net)
else:
# image mode
recognize_from_image(net)
def main():
dic_model = {
'sneaker': (WEIGHT_SNEAKER_PATH, MODEL_SNEAKER_PATH, ('Footwear',)),
'chair': (WEIGHT_CHAIR_PATH, MODEL_CHAIR_PATH, ('Chair',)),
'cup': (WEIGHT_CUP_PATH, MODEL_CUP_PATH, ('Coffee cup', 'Mug')),
'camera': (WEIGHT_CAMERA_PATH, MODEL_CAMERA_PATH, ('Camera',)),
}
weight_path, model_path, labels = dic_model[args.model]
logger.info("=== detection model ===")
check_and_download_models(WEIGHT_DETECTION_PATH, MODEL_DETECTION_PATH, REMOTE_PATH)
logger.info("=== regression model ===")
check_and_download_models(weight_path, model_path, REMOTE_PATH)
env_id = args.env_id
# initialize
det_net = ailia.Net(MODEL_DETECTION_PATH, WEIGHT_DETECTION_PATH, env_id=env_id)
reg_net = ailia.Net(model_path, weight_path, env_id=env_id)
if args.video is not None:
# video mode
recognize_from_video(det_net, reg_net, labels)
else:
# image mode
recognize_from_image(det_net, reg_net, labels)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
ailia_model = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
tokenizer = BertJapaneseTokenizer.from_pretrained(
'cl-tohoku/bert-base-japanese-whole-word-masking')
model_inputs = tokenizer.encode_plus(args.input, return_tensors="pt")
inputs_onnx = {
k: v.cpu().detach().numpy()
for k, v in model_inputs.items()
}
print("Text : ", args.input)
print("Input : ", inputs_onnx)
# inference
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
score = ailia_model.predict(inputs_onnx)
end = int(round(time.time() * 1000))
print("\tailia processing time {} ms".format(end - start))
else:
score = ailia_model.predict(inputs_onnx)
print("Output : ", score)
label_name = ["positive", "negative"]
print("Label : ", label_name[numpy.argmax(numpy.array(score))])
print('Script finished successfully.')
def main():
# model files check and download
logger.info('=== age-gender-recognition model ===')
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
if args.video or args.detection:
logger.info('=== face detection model ===')
check_and_download_models(FACE_WEIGHT_PATH, FACE_MODEL_PATH,
FACE_REMOTE_PATH)
# load model
env_id = args.env_id
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
detector = None
if args.video or args.detection:
detector = ailia.Net(FACE_MODEL_PATH, FACE_WEIGHT_PATH, env_id=env_id)
# image mode
if args.video is not None:
# video mode
recognize_from_video(net, detector)
else:
# image mode
recognize_from_image(net, detector)
def main():
# model files check and download
info = {
'lip': (WEIGHT_LIP_PATH, MODEL_LIP_PATH,
(IMAGE_LIP_SIZE, IMAGE_LIP_SIZE), CATEGORY_LIP),
'atr': (WEIGHT_ATR_PATH, MODEL_ATR_PATH,
(IMAGE_ATR_SIZE, IMAGE_ATR_SIZE), CATEGORY_ATR),
'pascal': (WEIGHT_PASCAL_PATH, MODEL_PASCAL_PATH,
(IMAGE_PASCAL_SIZE, IMAGE_ATR_SIZE), CATEGORY_PASCAL),
}
weight_path, model_path, img_size, category = info[args.arch]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
# Workaround for accuracy issue on
# ailia SDK 1.2.4 + opset11 + gpu (metal/vulkan)
detector = ailia.Net(model_path, weight_path, env_id=args.env_id)
params = {'img_size': img_size, 'category': category}
if args.video is not None:
# video mode
recognize_from_video(args.video, detector, params)
else:
# image mode
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
recognize_from_image(image_path, detector, params)
logger.info('Script finished successfully.')
def main():
dic_model = {
'fc': (WEIGHT_CAPTIONING_FC_PATH, MODEL_CAPTIONING_FC_PATH),
'fc_rl': (WEIGHT_CAPTIONING_FC_RL_PATH, MODEL_CAPTIONING_FC_RL_PATH),
'fc_nsc':
(WEIGHT_CAPTIONING_FC_NSC_PATH, MODEL_CAPTIONING_FC_NSC_PATH),
}
weight_path, model_path = dic_model[args.model]
# model files check and download
print("=== Captioning model ===")
check_and_download_models(weight_path, model_path, REMOTE_PATH)
print("=== Feature model ===")
check_and_download_models(WEIGHT_FEAT_PATH, MODEL_FEAT_PATH, REMOTE_PATH)
# initialize
net = ailia.Net(model_path, weight_path, env_id=args.env_id)
my_resnet = ailia.Net(MODEL_FEAT_PATH,
WEIGHT_FEAT_PATH,
env_id=args.env_id)
if args.video is not None:
recognize_from_video(args.video, net, my_resnet)
else:
recognize_from_image(args.input, net, my_resnet)
def main():
# model files check and download
logger.info('Check vehicle-attributes-recognition model...')
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
if args.video or args.detection:
logger.info('Check object detection model...')
check_and_download_models(DT_WEIGHT_PATH, DT_MODEL_PATH,
DT_REMOTE_PATH)
env_id = args.env_id
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
if args.video or args.detection:
detector = ailia.Detector(
DT_MODEL_PATH,
DT_WEIGHT_PATH,
len(COCO_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV3,
env_id=env_id,
)
else:
detector = None
if args.video:
# video mode
recognize_from_video(net, detector)
else:
# image mode
recognize_from_image(net, detector)
def main():
# model files check and download
logger.info('=== detector model ===')
check_and_download_models(WEIGHT_DETECTOR_PATH, MODEL_DETECTOR_PATH, REMOTE_PATH)
logger.info('=== blazepose model ===')
info = {
'lite': (WEIGHT_LITE_PATH, MODEL_LITE_PATH),
'full': (WEIGHT_FULL_PATH, MODEL_FULL_PATH),
'heavy': (WEIGHT_HEAVY_PATH, MODEL_HEAVY_PATH),
}
weight_path, model_path = info[args.model]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
env_id = args.env_id
# initialize
det_net = ailia.Net(MODEL_DETECTOR_PATH, WEIGHT_DETECTOR_PATH, env_id=env_id)
net = ailia.Net(model_path, weight_path, env_id=env_id)
if args.video is not None:
# video mode
recognize_from_video(net, det_net)
else:
# image mode
recognize_from_image(net, det_net)
def main():
# model files check and download
logger.info('=== MMFashion model ===')
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
if args.preprocess:
info = {
'large': (WEIGHT_U2NET_LARGE_PATH, MODEL_U2NET_LARGE_PATH),
'small': (WEIGHT_U2NET_SMALL_PATH, MODEL_U2NET_SMALL_PATH),
}
weight_path, model_path = info[args.preprocess]
logger.info('=== U square net model ===')
check_and_download_models(weight_path, model_path, REMOTE_U2NET_PATH)
else:
weight_path = model_path = None
# initialize
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
if weight_path:
pp_net = ailia.Net(model_path, weight_path, env_id=args.env_id)
else:
pp_net = None
if args.video is not None:
# video mode
recognize_from_video(args.video, detector, pp_net)
else:
# image mode
# input image loop
for image_path in args.input:
recognize_from_image(image_path, detector, pp_net)
logger.info('Script finished successfully.')
def main():
# model files check and download
info = {
'camvid': (WEIGHT_CAMVID_PATH, MODEL_CAMVID_PATH,
(IMAGE_CAMVID_HEIGTH, IMAGE_CAMVID_WIDTH), CATEGORY_CAMVID),
'cityscapes': (WEIGHT_CITYSCAPES_PATH, MODEL_CITYSCAPES_PATH,
(IMAGE_CITYSCAPES_HEIGHT, IMAGE_CITYSCAPES_WIDTH), CATEGORY_CITYSCAPES),
}
weight_path, model_path, img_size, category = info[args.model_type]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
if args.onnx:
import onnxruntime
net = onnxruntime.InferenceSession(weight_path)
else:
net = ailia.Net(model_path, weight_path, env_id=args.env_id)
params = {
'img_size': img_size,
'category': category
}
if args.video is not None:
# video mode
recognize_from_video(net, params)
else:
# image mode
# image mode
recognize_from_image(net, params)
def main():
info = {
"resnet18": (WEIGHT_RESNET18_PATH, MODEL_RESNET18_PATH,
("140", "156", "172"), 448, 100),
"wide_resnet50_2":
(WEIGHT_WIDE_RESNET50_2_PATH, MODEL_WIDE_RESNET50_2_PATH,
("356", "398", "460"), 1792, 550),
}
# model files check and download
weight_path, model_path, feat_names, t_d, d = info[args.arch]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
params = {
"feat_names": feat_names,
"t_d": t_d,
"d": d,
}
def _create_net():
return ailia.Net(model_path, weight_path, env_id=args.env_id)
# net initialize
if True:
create_net = _create_net
net = None
else:
create_net = None
net = _create_net()
# check input
if len(args.input) == 0:
logger.error("Input file not found")
return
recognize_from_image(net, create_net, params)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
env_id = args.env_id
# initialize
if not args.onnx:
logger.info("This model requires 10GB or more memory.")
memory_mode = ailia.get_memory_mode(reduce_constant=True,
ignore_input_with_initializer=True,
reduce_interstage=False,
reuse_interstage=True)
net = ailia.Net(MODEL_PATH,
WEIGHT_PATH,
env_id=env_id,
memory_mode=memory_mode)
else:
import onnxruntime
net = onnxruntime.InferenceSession(WEIGHT_PATH)
if args.video is not None:
recognize_from_video(net)
else:
recognize_from_image(net)
def main():
# model files check and download
logger.info('=== head model ===')
check_and_download_models(WEIGHT_HEAD_PATH, MODEL_HEAD_PATH, REMOTE_PATH)
logger.info('=== neck model ===')
check_and_download_models(WEIGHT_NECK_PATH, MODEL_NECK_PATH, REMOTE_PATH)
logger.info('=== baby model ===')
check_and_download_models(WEIGHT_BABY_PATH, MODEL_BABY_PATH, REMOTE_PATH)
logger.info('=== tail model ===')
check_and_download_models(WEIGHT_TAIL_PATH, MODEL_TAIL_PATH, REMOTE_PATH)
logger.info('=== gird model ===')
check_and_download_models(WEIGHT_GIRD_PATH, MODEL_GIRD_PATH, REMOTE_PATH)
# initialize
net_head = ailia.Net(MODEL_HEAD_PATH, WEIGHT_HEAD_PATH, env_id=args.env_id)
net_neck = ailia.Net(MODEL_NECK_PATH, WEIGHT_NECK_PATH, env_id=args.env_id)
net_baby = ailia.Net(MODEL_BABY_PATH, WEIGHT_BABY_PATH, env_id=args.env_id)
net_tail = ailia.Net(MODEL_TAIL_PATH, WEIGHT_TAIL_PATH, env_id=args.env_id)
net_gird = ailia.Net(MODEL_GIRD_PATH, WEIGHT_GIRD_PATH, env_id=args.env_id)
dict_net = {
"head": net_head,
"neck": net_neck,
"baby": net_baby,
"tail": net_tail,
"gird": net_gird,
}
recognize_from_image(args.input, dict_net)
def main():
# model files check and download
print("=== ST-GCN model ===")
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
print("=== OpenPose model ===")
check_and_download_models(WEIGHT_POSE_PATH, MODEL_POSE_PATH,
REMOTE_POSE_PATH)
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
if args.arch == "pyopenpose":
pose = op.WrapperPython()
params = dict(model_folder='.', model_pose='COCO')
pose.configure(params)
pose.start()
else:
pose = ailia.PoseEstimator(MODEL_POSE_PATH,
WEIGHT_POSE_PATH,
env_id=args.env_id,
algorithm=POSE_ALGORITHM)
if args.arch == "openpose":
pose.set_threshold(0.1)
if args.video is not None:
# realtime mode
recognize_realtime(args.video, pose, net)
else:
# offline mode
recognize_from_file(args.input, pose, net)
def main():
dic_model = {
'blouse': (WEIGHT_BLOUSE_PATH, MODEL_BLOUSE_PATH, IMAGE_BLOUSE_PATH),
'dress': (WEIGHT_DRESS_PATH, MODEL_DRESS_PATH, IMAGE_DRESS_PATH),
'outwear':
(WEIGHT_OUTWEAR_PATH, MODEL_OUTWEAR_PATH, IMAGE_OUTWEAR_PATH),
'skirt': (WEIGHT_SKIRT_PATH, MODEL_SKIRT_PATH, IMAGE_SKIRT_PATH),
'trousers':
(WEIGHT_TROUSERS_PATH, MODEL_TROUSERS_PATH, IMAGE_TROUSERS_PATH),
}
weight_path, model_path, img_path = dic_model[args.clothing_type]
# model files check and download
check_and_download_models(weight_path, model_path, REMOTE_PATH)
# initialize
net = ailia.Net(model_path, weight_path, env_id=args.env_id)
if args.video is not None:
# video mode
recognize_from_video(args.video, net)
else:
# image mode
# input image loop
for image_path in args.input:
logger.info(image_path)
recognize_from_image(image_path, net)
logger.info('Script finished successfully.')
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH_T2M, MODEL_PATH_T2M, REMOTE_PATH_T2M)
check_and_download_models(WEIGHT_PATH_SSRM, MODEL_PATH_SSRM,
REMOTE_PATH_SSRM)
generate_sentence(args.input)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
# load audio
for input_data_path in args.input:
logger.info('=' * 80)
logger.info(f'input: {input_data_path}')
data = sf.read(input_data_path)
# create instance
session = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for c in range(5):
start = int(round(time.time() * 1000))
label, conf = crnn(data, session)
end = int(round(time.time() * 1000))
logger.info("\tailia processing time {} ms".format(end -
start))
else:
label, conf = crnn(data, session)
logger.info(label)
logger.info(conf)
logger.info('Script finished successfully.')
def main():
info = {
("paris-streetview", "rect"):
(WEIGHT_PARIS_STREETVIEW_PATH, MODEL_PARIS_STREETVIEW_PATH, (256,
256)),
("celebahq", "rect"):
(WEIGHT_CELEBAHQ_256_PATH, MODEL_CELEBAHQ_256_PATH, (256, 256)),
("celebahq-512", "rect"):
(WEIGHT_CELEBAHQ_512_PATH, MODEL_CELEBAHQ_512_PATH, (512, 512)),
("celebahq-512", "stroke"): (WEIGHT_CELEBAHQ_FREEFORM_PATH,
MODEL_CELEBAHQ_FREEFORM_PATH, (512, 512)),
("places2", "stroke"):
(WEIGHT_PLACE2_PATH, MODEL_PLACE2_PATH, (512, 680)),
}
key = (args.model, args.mask_type)
if key not in info:
logger.error("(MODEL = %s, MASK_TYPE = %s) is unmatch." % key)
logger.info("appropriate settings:\n"
"\t(MODEL = paris-streetview, MASK_TYPE = rect)\n"
"\t(MODEL = celebahq, MASK_TYPE = rect)\n"
"\t(MODEL = celebahq-512, MASK_TYPE = rect)\n"
"\t(MODEL = celebahq-512, MASK_TYPE = stroke)\n"
"\t(MODEL = places2, MASK_TYPE = stroke)")
sys.exit(-1)
# model files check and download
weight_path, model_path, img_shape = info[key]
check_and_download_models(weight_path, model_path, REMOTE_PATH)
# net initialize
net = ailia.Net(model_path, weight_path, env_id=args.env_id)
recognize_from_image(net, img_shape)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
recognize_from_keypoints(net)
def main():
# model files check and download
check_and_download_models(WEIGHT_PATH, MODEL_PATH, REMOTE_PATH)
if args.video:
enhance_video()
else:
enhance_image()
