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)