def precision_recall(data,
cls,
prob_threshold,
iou_treshold,
pred_field='predictions',
gt_field='ground_truth'):
TP = 0.0
TPFP = 0.0 # total positive results / pred
TPFN = 0.0 # total existing cases / rel
for obj in data:
ground_truth = (obj[gt_field]
| mp.where(lambda x: x['tag'] == cls)
| mp.as_list)
TPFN += len(ground_truth)
predictions = (
obj[pred_field]
|
mp.where(lambda x: x['tag'] == cls and x['prob'] > prob_threshold)
| mp.as_list)
for gt_box in ground_truth:
pred_boxes = (
predictions
| mp.apply(
['x1', 'y1', 'width', 'height'], 'iou',
lambda x: intersection_over_union(x, (gt_box['x1'], gt_box[
'y1'], gt_box['width'], gt_box['height'])))
| mp.filter('iou', lambda x: x < iou_treshold)
| mp.as_list)
if len(pred_boxes) > 0:
TP += 1
TPFP += len(pred_boxes)
return (float(TP > 0) if TPFP == 0 else TP / TPFP,
float(TP > 0) if TPFN == 0 else TP / TPFN)
def coco_to_custom_vision(stream, project_id, trainer, data_dir):
stream = stream | mp.as_list
tags = stream | mp.select_field('class_id') | mp.dedup() | mp.as_list
cv_tags = {tag: trainer.create_tag(project_id, tag) for tag in tags}
stream = (
stream
| mp.apply(['width', 'height', 'ground_truth'], 'ground_truth',
lambda x: x[2]
| mp.where(lambda box: (box['width'] >= x[0] * 0.1) and
(box['height'] >= x[1] * 0.1))
| mp.as_list)
| mp.filter('ground_truth', lambda x: len(x) > 0)
| mp.apply(
['width', 'height', 'ground_truth'], 'regions', lambda x: x[2]
| mp.select(lambda box: Region(tag_id=cv_tags[box['tag']].id,
left=box['x1'] / x[0],
top=box['y1'] / x[1],
width=box['width'] / x[0],
height=box['height'] / x[1]))
| mp.as_list)
| mp.apply(['filename', 'regions'], 'tagged_img',
lambda x: ImageFileCreateEntry(
name=x[0],
contents=open(join(data_dir, x[0]), mode="rb").read(),
regions=x[1]))
| mp.as_list)
tagged_images_with_regions = stream | mp.select_field(
'tagged_img') | mp.as_list
for i in range(0, len(tagged_images_with_regions), 50):
trainer.create_images_from_files(
project_id, images=tagged_images_with_regions[i:i + 50])
k = int(sys.argv[1])
n = int(sys.argv[2])
config.base_dir = config.base_dir_batch
config.data_dir = config.data_dir_batch
else:
k, n = 0, 1
(mp.get_datastream(data_dir, ext=".full.mp4")
| batch(k, n)
| mp.fapply('video', resize_video.load_resize)
| execute)
resized_file_names = (mp.get_datastream(data_dir, ext=".resized.mp4")
| mp.select_field("filename")
| mp.as_list)
# use only the first threshold
scene_changes = get_scene_changes(resized_file_names, data_dir)[40]
(mp.get_datastream(data_dir, ext=".resized.mp4")
| mp.filter("filename", lambda f: os.path.abspath(f) not in scene_changes)
| cachecomputex(".resized.mp4", ".optflow.npy", create_denseflow.calcflow,
functools.partial(skip, s="creating dense flow"))
| cachecomputex(".resized.mp4", ".vgg.npy", create_vgg.calcvgg,
functools.partial(skip, s="creating VGG"))
| cachecomputex(".resized.mp4", ".audiofeatures.npy",
create_audio_features.calcaudio,
functools.partial(skip, s="creating audio features"))
| close_moviepy_video()
| execute)
face.BaseUrl.set(conf['FaceApi']['Endpoint'])
face.Key.set(conf['FaceApi']['Key'])
classes = mp.get_classes(args.dir)
data = mp.get_datastream(args.dir, classes=classes) | mp.as_list
print("Person Group Trainer Utility")
print(" + found {} people".format(len(classes)))
print(" + Creating face group {}".format(args.facegroup))
face.person_group.create(args.facegroup, name=args.facegroup)
people = {}
for p in classes.keys():
photos = data | mp.filter('class_name', lambda x: x == p) | mp.as_list
print("Adding person {} - {} pics".format(p, len(photos)))
pers = face.person.create(args.facegroup, p)
people[pers['personId']] = p
for x in photos:
print(" + Adding photo {}".format(x['filename']), end='')
try:
face.person.add_face(x['filename'], args.facegroup,
pers['personId'])
print("-> ok")
except:
print("-> error")
print("Training...")
face.person_group.train(args.facegroup)
print("All done")
print(metrics.classification_report(yte, y_pred))
print(metrics.confusion_matrix(yte, y_pred))
# plotConfusion(yte, y_pred, title=title)
return y_pred, clf
cls = SVM(X_tr, X_te, Y_tr, Y_te, C=25)
print(cls)
exit(0)
trainstream, valstream = data | mp.make_train_test_split
no_intervals = 200
no_features = 34
no_train = data | mp.filter('split',
lambda x: x == mp.SplitType.Train) | mp.count
no_test = data | mp.filter('split',
lambda x: x == mp.SplitType.Test) | mp.count
print("Training samples = {}\nTesting samples = {}".format(no_train, no_test))
batchsize = 32
model = Sequential()
#model.add(Conv1D(10,5,input_shape=(no_features,no_intervals),data_format='channels_first'))
#model.add(MaxPooling1D(data_format='channels_first'))
#model.add(Conv1D(20,5,input_shape=(no_features,no_intervals),data_format='channels_first'))
#model.add(MaxPooling1D(data_format='channels_first'))
model.add(Flatten(input_shape=(no_features, no_intervals)))
model.add(Dropout(0.3))
model.add(
Dense(3, activation='softmax',
kernel_initializer='glorot_uniform')) #kernel_regularizer=l2(0.01)))
print(" + Loading descriptions from {}".format(dir))
def loadjs(fn):
with open(fn) as f:
return json.load(f)
min_size = size / 3 if args.ignore_small else 0
max_faces_no = 2 if args.ignore_multiface else 99999
data = (mp.get_files(dir, ext='.json')
| mp.as_field('filename')
| mp.apply('filename', 'descr', loadjs)
| mp.filter('descr', lambda x: len(x) > 0 and len(x) < max_faces_no)
| mp.unroll('descr')
| mp.filter(
'descr', lambda x: abs(x['faceAttributes']['headPose']['yaw']) < 15
and abs(x['faceAttributes']['headPose']['pitch']) < 15)
| mp.filter(
'descr', lambda x: x['faceLandmarks']['pupilRight']['x'] - x[
'faceLandmarks']['pupilLeft']['x'] > min_size)
| mp.as_list)
print(" + Found {} faces".format(len(data)))
print(" + Storing dataset...")
@mp.Pipe
res = face.face.detect(fn,True,True,'')
if not args.nocache:
cache[h] = res
res = res[0]['faceLandmarks']
#print(res[0]['faceLandmarks'])
except:
pass
return res
print(" + Loading images from {}".format(dir))
data = (
mp.get_files(dir)
| mp.as_field('filename')
| mp.apply_nx('filename','image',lambda x: cv2.imread(x),print_exceptions=False)
| mp.filter('image',lambda x: x is not None)
| mp.as_list)
print(" + Found {} images".format(len(data)))
print(" + Extracting facial landmarks...")
data = (
data
| mp.apply(['filename','image'],'landmarks',detect)
| mp.filter('landmarks',lambda x: x!=[])
| mp.as_list
)
if not args.nocache:
print(" + Saving cache...")
def merge(images, wts=None):
res = np.zeros_like(images[0], dtype=np.float32)
if wts is None:
wts = np.ones(len(images))
wts /= np.sum(wts)
for n, i in enumerate(images):
res += wts[n] * i.astype(np.float32)
return res.astype(np.int32)
data = (mp.get_files(dir, ext='.json')
| mp.as_field('filename')
| mp.apply('filename', 'descr', loadjs)
| mp.unroll('descr')
| mp.filter(
'descr', lambda x: person_id == "" or
('candidates' in x and person_id in
[z['personId'] for z in x['candidates']]))
| mp.filter(
'descr', lambda x: abs(x['faceAttributes']['headPose']['yaw']) < 15
and abs(x['faceAttributes']['headPose']['pitch']) < 15)
| mp.filter(
'descr', lambda x: x['faceLandmarks']['pupilRight']['x'] - x[
'faceLandmarks']['pupilLeft']['x'] > 50)
| mp.as_list)
print("Found {} faces".format(len(data)))
def get_transform(descr):
f = descr['faceLandmarks']
mc_x = (f['mouthLeft']['x'] + f['mouthRight']['x']) / 2.0
season = match["Season"].replace("/", "")
h = max(0, int(match["Half"]))
print(f"Processing {match['Video']} ({match['Id']})\n")
videoFilePath = os.path.join(source_dir,match["Video"])
marksFilePath = os.path.join(source_dir,"Marks.jsonl")
video = VideoFileClip(videoFilePath)
data = []
with open(marksFilePath,'r') as f:
for cnt, line in enumerate(f):
data.append(json.loads(line))
# Get list of times when match halves start
mt = data | mp.filter('eventType', lambda x: "start" in x) | mp.select_field('matchTime') | mp.as_list
mt = convtime(mt[h])
# Shots are fine, added also Goal which are not marked as shots
cuts = data | mp.filter('eventType', shotFilter) | mp.apply('matchTime', 'start', convtime)
# Consider, for negative examples, also Attacks, which are Shots nearby the goal area (or in other places of the field)
# They are also filtered (later), removing those overlapping with shots/goals
attacks = data | mp.filter('eventType', attackFilter) | mp.apply('matchTime', 'start', convtime)
clipTrimTime = float(args.clipTrimTime) # +/- X seconds centered on event time
clipTrimAttackTimeRange = float(args.clipTrimAttackTimeRange) # +/- X seconds centered on event time
clipTrimAttackStart = float(args.clipTrimAttackStart) # when attack clip starts (before event time)
clipTrimAttackEnd = float(args.clipTrimAttackEnd) # when attack clip ends (after event time)
