from model_definition import ModelDefinition from tflite.predictor_lite import PredictorLite from predict.predictor import Predictor from debug.debug_predictor import pretty_prediction from time import time import random import numpy as np model_definition = ModelDefinition() # TF Lite prediction predictor_lite = PredictorLite(model_definition) empty_element = predictor_lite.get_empty_element() # Full TF prediction predictor = Predictor(model_definition) def test_lite_performance(): # Test performance n_repetitions = 1000 print("Testing performance, n. repetitions:", n_repetitions) start = time() for i in range(n_repetitions): predictor_lite.predict(empty_element) end = time() print("Total time:", end - start, "s") print("Prediction performance:", ((end - start) / n_repetitions) * 1000, "ms")
def test(args): from dataio.task_data import TaskData from predict.predictor import Predictor data = TaskData(args.test_data_num) labels, sents = data.read_data( raw_data_path=config["test_path"], data_dir=config["data_dir"], preprocessor=Preprocessor(config["preprocessor"])( stopwords_path=config["stopwords_path"], userdict_path=config["userdict_path"]), is_train=False) lines = list(zip(sents, labels)) processor = Postprocessor( config["postprocessor"])(do_lower_case=args.do_lower_case) label_list = processor.get_labels(config['data_dir'] / "labels.txt") id2label = {i: label for i, label in enumerate(label_list)} test_data = processor.get_test(lines=lines) test_examples = processor.create_examples( lines=test_data, example_type='test', cached_examples_file=config['data_dir'] / "cached_test_examples_{}".format(args.pretrain)) test_features = processor.create_features( examples=test_examples, max_seq_len=args.eval_max_seq_len, cached_features_file=config['data_dir'] / "cached_test_features_{}_{}".format(args.eval_max_seq_len, args.pretrain)) test_dataset = processor.create_dataset(test_features) test_sampler = SequentialSampler(test_dataset) test_dataloader = DataLoader(test_dataset, sampler=test_sampler, batch_size=args.train_batch_size) if config["pretrain"] == "Nopretrain": config["vocab_size"] = processor.vocab_size model = Classifier(config["classifier"], config["pretrain"], config["checkpoint_dir"])(num_labels=len(label_list)) ########### predict ########### logger.info('model predicting....') predictor = Predictor(model=model, logger=logger, n_gpu=args.n_gpu) logits, y_pred = predictor.predict(data=test_dataloader, thresh=0.5) pred_labels = [] for item in y_pred.tolist(): tmp = [] for i, v in enumerate(item): if v == 1: tmp.append(label_list[i]) pred_labels.append(",".join(tmp)) assert len(pred_labels) == y_pred.shape[0] df_pred_labels = pd.DataFrame(pred_labels, columns=["predict_labels"]) df_test_raw = pd.read_csv(config["test_path"]) if args.test_data_num > 0: df_test_raw = df_test_raw.head(args.test_data_num) df_labels = pd.DataFrame(logits, columns=label_list) df = pd.concat([df_test_raw, df_pred_labels, df_labels], axis=1) df.to_csv(config["result"] / "output.csv", index=False)
def main(): parser = argparse.ArgumentParser( "Utility to process an image through the detection model") parser.add_argument( "--model-path", '-p', type=str, required=True, help="path to the trained model") parser.add_argument( "--image", '-i', action='store_true', help="process on image") parser.add_argument( "--video", '-v', action='store_true', help="process on video") parser.add_argument('--device', type=str, help='device to use') parser.add_argument( '--output', '-o', type=str, help="save the results to the specified file") parser.add_argument( '--mean', type=str, default="(0.485, 0.456, 0.406)", help="Expected mean value for the image or video (ImageNet defaults " "(0.485, 0.456, 0.406) are used if not specified)") parser.add_argument( '--std', type=str, default="(0.229, 0.224, 0.225)", help="Expected standard deviation value for the image or video " "(ImageNet defaults (0.229, 0.224, 0.225) are used if not " "specified)") parser.add_argument( "path", type=str, nargs='?', help="file to process (use camera if omitted and " "'--video' is set") args = parser.parse_args() if args.device is None: device = "cuda" if torch.cuda.is_available() else "cpu" else: device = args.device if device.startswith("cuda"): logging.info("Use CUDA") if args.image and args.video: print("Can process either image or video, but not both") sys.exit(-1) mean = literal_eval(args.mean) std = literal_eval(args.std) _, ext = os.path.splitext(args.model_path) onnx_model = (ext == ".onnx") if onnx_model: if onnxruntime is None: raise RuntimeError( "Running ONNX models requires 'onnxruntime' module, " "which is not available") model = ONNXModel(args.model_path) arch = model.arch() class_names = model.class_names else: arch, model, class_names = load( args.model_path, device=device, inference=True) predictor = Predictor(arch, model, device=device, mean=mean, std=std) timer = Timer() if args.image: orig_image = cv2.imread(args.path) predict_and_show(orig_image, predictor, class_names, timer) if args.output is not None: cv2.imwrite(orig_image, args.output) cv2.waitKey(0) elif args.video: if len(args.path) > 0: cap = cv2.VideoCapture(args.path) # capture from file else: cap = cv2.VideoCapture(0) # capture from camera out = None if args.output is not None: frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(cap.get(cv2.CAP_PROP_FPS)) out = cv2.VideoWriter( args.output, cv2.VideoWriter_fourcc(*"mp4v"), fps, (frame_width, frame_height)) while True: ret, orig_image = cap.read() if not ret or orig_image is None: break predict_and_show(orig_image, predictor, class_names, timer) if out is not None: out.write(orig_image) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() if out is not None: out.release() cv2.destroyAllWindows()
def main(): parser = argparse.ArgumentParser( description="Calculate Pascal VOC evaluation metrics") parser.add_argument("--model-path", '-p', type=str, required=True, help="path to the trained model") parser.add_argument('--dataset-style', type=str, required=True, help="style of dataset " "(supported are 'pascal-voc' and 'coco')") parser.add_argument('--image-set', type=str, default="test", help='image set (annotation file basename for COCO) ' 'to use for evaluation') parser.add_argument("--dataset", type=str, help="dataset directory path") parser.add_argument("--metric", '-m', type=str, default='pascal-voc', help="metric to calculate ('pascal-voc' or 'coco')") parser.add_argument("--nms-method", type=str, default="hard") parser.add_argument("--iou-threshold", type=float, default=0.5, help="IOU threshold (for Pascal VOC metric)") parser.add_argument( "--use-2007", action='store_true', help="Use 2007 calculation algorithm (for Pascal VOC metric)") parser.add_argument('--device', type=str, help='device to use') args = parser.parse_args() if args.device is None: device = "cuda" if torch.cuda.is_available() else "cpu" else: device = args.device if device.startswith("cuda"): logging.info("Use CUDA") timer = Timer() dataset = load_dataset(args.dataset_style, args.dataset, args.image_set) arch, model, class_names = load(args.model_path, device=device, inference=True) model.eval() if dataset.class_names != class_names: print("Dataset classes don't match the classes " "the specified model is trained with. " "No chance to get valid results, so I give up.") sys.exit(-1) mean, std = mean_std(args.dataset_style, args.dataset, args.image_set) predictor = Predictor(arch, model, device=device, mean=mean, std=std) if args.metric == 'pascal-voc': logging.info("Calculating Pascal VOC metric...") pascal_voc.eval(dataset, predictor, iou_threshold=args.iou_threshold, use_2007_metric=args.use_2007) elif args.metric == 'coco': logging.info("Calculating COCO metric...") coco.eval(dataset, predictor) else: print("Metric %s is not supported" % args.metric) sys.exit(-2)
import configure_tf_log # Must be FIRST import from model_definition import ModelDefinition from predict.predictor import Predictor from time import time import json # Read model definition model_definition = ModelDefinition() print("Reading exported model") predictor = Predictor(model_definition) # Sample input: First file word (sequence with all pad elements) input = predictor.get_empty_element() print(input) json_test = json.dumps(input) print("Prediction:", predictor.predict(input)) n_repetitions = 1000 print("Testing performance, n. repetitions:", n_repetitions) start = time() for i in range(n_repetitions): predictor.predict_json(json_test) end = time() print("Total time:", end - start, "s") print("Prediction performance:", ((end - start) / n_repetitions) * 1000, "ms") # RNN: House computer (Linux): # seq_len = 16, rnn size = 64 -> With GPU: 1.7 ms / With CPU: 0.85 ms # seq_len= 64, rnn_size = 256 -> With GPU: 2.76 ms / With CPU: 4.24 ms
import configure_tf_log # Must be FIRST import from model_definition import ModelDefinition from predict.predictor import Predictor from debug_ds import pretty from time import time import json import tensorflow as tf from data_directory import DataDirectory from debug.debug_predictor import pretty_prediction model_definition = ModelDefinition() data_definition = model_definition.data_definition predictor = Predictor(model_definition) data_dir = DataDirectory(["data/PAlcCanFac.csv"]) ds = model_definition.dataset_class(data_dir, data_definition, shuffle=False, debug_columns=False) ds.dataset = ds.dataset.batch(1).take(1) #ds.dataset = ds.dataset.take(3) # TODO: I think this was done to debug GPT only. Make it work with rnn too? for row in ds.dataset: input = row[0] expected_output = row[1] #print(input) batched_logits = predictor.model(input) #print(batched_logits)