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()