From 4acbc0580dc5451cb0182e61e9a7c8a66d2a5034 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Tue, 27 Oct 2020 14:12:03 +0300 Subject: [PATCH 01/58] add hpe python demo --- .../human_pose_estimation_demo/README.md | 240 ++++++++++++++++ .../human_pose_estimation.py | 261 ++++++++++++++++++ .../human_pose_estimation_demo/__init__.py | 0 .../human_pose_estimation_demo/decoder.py | 249 +++++++++++++++++ .../human_pose_estimation_demo/model.py | 184 ++++++++++++ .../visualization.py | 44 +++ .../human_pose_estimation_demo/models.lst | 4 + 7 files changed, 982 insertions(+) create mode 100644 demos/python_demos/human_pose_estimation_demo/README.md create mode 100755 demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py create mode 100644 demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/__init__.py create mode 100644 demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py create mode 100644 demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py create mode 100644 demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py create mode 100644 demos/python_demos/human_pose_estimation_demo/models.lst diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md new file mode 100644 index 00000000000..cef4c799e8d --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -0,0 +1,240 @@ +# Object Detection SSD Python* Demo, Async API performance showcase + +This demo showcases Object Detection with SSD and Async API. + +Async API usage can improve overall frame-rate of the application, because rather than wait for inference to complete, +the app can continue doing things on the host, while accelerator is busy. +Specifically, this demo keeps the number of Infer Requests that you have set using `-nireq` flag. +While some of the Infer Requests are processed by IE, the other ones can be filled with new frame data +and asynchronously started or the next output can be taken from the Infer Request and displayed. + +The technique can be generalized to any available parallel slack, for example, doing inference and simultaneously +encoding the resulting (previous) frames or running further inference, like some emotion detection on top of +the face detection results. +There are important performance caveats though, for example the tasks that run in parallel should try to avoid +oversubscribing the shared compute resources. +For example, if the inference is performed on the FPGA, and the CPU is essentially idle, +than it makes sense to do things on the CPU in parallel. But if the inference is performed say on the GPU, +than it can take little gain to do the (resulting video) encoding on the same GPU in parallel, +because the device is already busy. + +This and other performance implications and tips for the Async API are covered in the +[Optimization Guide](https://docs.openvinotoolkit.org/latest/_docs_optimization_guide_dldt_optimization_guide.html). + +Other demo objectives are: +* Video as input support via OpenCV\* +* Visualization of the resulting bounding boxes and text labels (from the `.labels` file) + or class number (if no file is provided) +* Demonstration of the Async API in action. For this, the demo features two modes toggled by the **Tab** key: + - "User specified" mode, where you can set the number of Infer Requests, throughput streams and threads. + Inference, starting new requests and displaying the results of completed requests are all performed asynchronously. + The purpose of this mode is to get the higher FPS by fully utilizing all available devices. + - "Min latency" mode, which uses only one Infer Request. The purpose of this mode is to get the lowest latency. + +## How It Works + +On the start-up, the application reads command-line parameters and loads a network to the Inference +Engine. Upon getting a frame from the OpenCV VideoCapture, it performs inference and displays the results. + +Async API operates with a notion of the "Infer Request" that encapsulates the inputs/outputs and separates +*scheduling and waiting for result*. + +The pipeline is the same for both modes. The difference is in the number of Infer Requests used. +``` +while True: + if (Infer Request containing the next video frame has completed): + get inference results + process inference results + display the frame + elif (one of the Infer Requests is idle and it is not the end of the input video): + capture frame + populate empty Infer Request + start Infer Request +``` + +> **NOTE**: By default, Open Model Zoo demos expect input with BGR channels order. If you trained your model to work +with RGB order, you need to manually rearrange the default channels order in the demo application or reconvert your +model using the Model Optimizer tool with `--reverse_input_channels` argument specified. For more information about +the argument, refer to **When to Reverse Input Channels** section of +[Converting a Model Using General Conversion Parameters](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_Converting_Model_General.html). + +### Async API + +The Inference Engine offers Async API based on the notion of Infer Requests. You can execute a Infer Requests +asynchronously (in the background) and wait until ready, when the result is actually needed. +In a mean time your app can continue : + +```python +# load network as usual +ie = IECore() +net = ie.read_network(model='Model.xml', weights='Model.bin') +# load network to the plugin, setting the maximal number of concurrent Infer Requests to be used +exec_net = ie.load_network(network=net, device_name='GPU', num_requests=2) +# start concurrent Infer Requests (put requests to the queue and immediately return) +for i, request in enumerate(exec_net.requests): + request.async_infer(inputs={'data': imgs[i]}) +# here you can continue execution on the host until results of requests are really needed +# ... +outputs = [request.wait(-1) for request in exec_net.requests] +``` + +Another option is to set a callback on Infer Request completion: + +```python +# load network as usual +ie = IECore() +net = ie.read_network(model='Model.xml', weights='Model.bin') +# load network to the plugin, setting the maximal number of concurrent Infer Requests to be used +exec_net = ie.load_network(network=net, device_name='GPU', num_requests=2) +# define a callback function +def callback(status, py_data): + request, id = py_data + print(id, {key: blob.buffer for key, blob in request.output_blobs.items()}) + +# start concurrent Infer Requests and set their completion callbacks +for i, request in enumerate(exec_net.requests): + request.set_completion_callback(py_callback=callback, py_data=(request, i)) + request.async_infer(inputs={'data': imgs[i]}) + +# here you can continue execution on the host until results of requests are really needed +# ... +``` + +For more details on the requests-based Inference Engine API, including the Async execution, refer to +[Integrate the Inference Engine New Request API with Your Application](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Integrate_with_customer_application_new_API.html). + + +## Running + +Running the application with the `-h` option yields the following usage message: +``` +python3 object_detection_demo_ssd_async.py -h +``` +The command yields the following usage message: +``` +usage: object_detection_demo_ssd_async.py [-h] -m MODEL -i INPUT [-d DEVICE] + [--labels LABELS] + [-t PROB_THRESHOLD] [-r] + [-nireq NUM_INFER_REQUESTS] + [-nstreams NUM_STREAMS] + [-nthreads NUM_THREADS] + [-loop LOOP] [-no_show] + [-u UTILIZATION_MONITORS] + [--keep_aspect_ratio] + +Options: + -h, --help Show this help message and exit. + -m MODEL, --model MODEL + Required. Path to an .xml file with a trained model. + -i INPUT, --input INPUT + Required. Path to an image, video file or a numeric + camera ID. + -d DEVICE, --device DEVICE + Optional. Specify the target device to infer on; CPU, + GPU, FPGA, HDDL or MYRIAD is acceptable. The sample + will look for a suitable plugin for device specified. + Default value is CPU. +Options: + -h, --help Show this help message and exit. + -m MODEL, --model MODEL + Required. Path to an .xml file with a trained model. + -i INPUT, --input INPUT + Required. Path to an image, video file or a numeric + camera ID. + -d DEVICE, --device DEVICE + Optional. Specify the target device to infer on; CPU, + GPU, FPGA, HDDL or MYRIAD is acceptable. The sample + will look for a suitable plugin for device specified. + Default value is CPU. + --labels LABELS Optional. Labels mapping file. + -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD + Optional. Probability threshold for detections + filtering. + -r, --raw_output_message + Optional. Output inference results raw values showing. + -nireq NUM_INFER_REQUESTS, --num_infer_requests NUM_INFER_REQUESTS + Optional. Number of infer requests + -nstreams NUM_STREAMS, --num_streams NUM_STREAMS + Optional. Number of streams to use for inference on + the CPU or/and GPU in throughput mode (for HETERO and + MULTI device cases use format + :,: or just + ) + -nthreads NUM_THREADS, --num_threads NUM_THREADS + -m MODEL, --model MODEL + Required. Path to an .xml file with a trained model. + -i INPUT, --input INPUT + Required. Path to an image, video file or a numeric + camera ID. + -d DEVICE, --device DEVICE + Optional. Specify the target device to infer on; CPU, + GPU, FPGA, HDDL or MYRIAD is acceptable. The sample + will look for a suitable plugin for device specified. + Default value is CPU. + --labels LABELS Optional. Labels mapping file. + -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD + Optional. Probability threshold for detections + filtering. + -r, --raw_output_message + Optional. Output inference results raw values showing. + -nireq NUM_INFER_REQUESTS, --num_infer_requests NUM_INFER_REQUESTS + Optional. Number of infer requests + -nstreams NUM_STREAMS, --num_streams NUM_STREAMS + Optional. Number of streams to use for inference on + the CPU or/and GPU in throughput mode (for HETERO and + MULTI device cases use format + :,: or just + ) + -nthreads NUM_THREADS, --num_threads NUM_THREADS + Optional. Number of threads to use for inference on + CPU (including HETERO cases) + -loop LOOP, --loop LOOP + Optional. Number of times to repeat the input. + -no_show, --no_show Optional. Don't show output + -u UTILIZATION_MONITORS, --utilization_monitors UTILIZATION_MONITORS + Optional. List of monitors to show initially. + --keep_aspect_ratio Optional. Keeps aspect ratio on resize. +``` + +The number of Infer Requests is specified by `-nireq` flag. An increase of this number usually leads to an increase +of performance (throughput), since in this case several Infer Requests can be processed simultaneously if the device +supports parallelization. However, a large number of Infer Requests increases the latency because each frame still +has to wait before being sent for inference. + +For higher FPS, it is recommended that you set `-nireq` to slightly exceed the `-nstreams` value, +summed across all devices used. + +> **NOTE**: This demo is based on the callback functionality from the Inference Engine Python API. + The selected approach makes the execution in multi-device mode optimal by preventing wait delays caused by + the differences in device performance. However, the internal organization of the callback mechanism in Python API + leads to FPS decrease. Please, keep it in mind and use the C++ version of this demo for performance-critical cases. + +Running the application with the empty list of options yields the usage message given above and an error message. +You can use the following command to do inference on GPU with a pre-trained object detection model: +``` +python3 object_detection_demo_ssd_async.py -i /inputVideo.mp4 -m /ssd.xml -d GPU +``` + +To run the demo, you can use public or pre-trained models. You can download the pre-trained models with the OpenVINO +[Model Downloader](../../../tools/downloader/README.md) or from +[https://download.01.org/opencv/](https://download.01.org/opencv/). + +> **NOTE**: Before running the demo with a trained model, make sure the model is converted to the Inference Engine +format (\*.xml + \*.bin) using the +[Model Optimizer tool](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html). + +The only GUI knob is to use **Tab** to switch between the synchronized execution ("Min latency" mode) +and the asynchronous mode configured with provided command-line parameters ("User specified" mode). + +## Demo Output + +The demo uses OpenCV to display the resulting frame with detections (rendered as bounding boxes and labels, if provided). +The demo reports +* **FPS**: average rate of video frame processing (frames per second) +* **Latency**: average time required to process one frame (from reading the frame to displaying the results) +You can use both of these metrics to measure application-level performance. + +## See Also +* [Using Open Model Zoo demos](../../README.md) +* [Model Optimizer](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html) +* [Model Downloader](../../../tools/downloader/README.md) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py new file mode 100755 index 00000000000..f318e9786df --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import logging +import os.path as osp +import sys +from argparse import ArgumentParser, SUPPRESS +from itertools import cycle +from enum import Enum +from time import perf_counter + +import cv2 +import numpy as np +from openvino.inference_engine import IECore + +from human_pose_estimation_demo.model import HPE +from human_pose_estimation_demo.visualization import show_poses + +sys.path.append(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'common')) +import monitors +from helpers import put_highlighted_text + + +logging.basicConfig(format='[ %(levelname)s ] %(message)s', level=logging.INFO, stream=sys.stdout) +log = logging.getLogger() + +def build_argparser(): + parser = ArgumentParser(add_help=False) + args = parser.add_argument_group('Options') + args.add_argument('-h', '--help', action='help', default=SUPPRESS, help='Show this help message and exit.') + args.add_argument('-m', '--model', help='Required. Path to an .xml file with a trained model.', + required=True, type=str) + args.add_argument('-i', '--input', help='Required. Path to an image, video file or a numeric camera ID.', + required=True, type=str) + args.add_argument('-d', '--device', + help='Optional. Specify the target device to infer on; CPU, GPU, FPGA, HDDL or MYRIAD is ' + 'acceptable. The sample will look for a suitable plugin for device specified. ' + 'Default value is CPU.', default='CPU', type=str) + args.add_argument('-t', '--prob_threshold', help='Optional. Probability threshold for detections filtering.', + default=0.5, type=float) + args.add_argument('-r', '--raw_output_message', help='Optional. Output inference results raw values showing.', + default=False, action='store_true') + args.add_argument('-nireq', '--num_infer_requests', help='Optional. Number of infer requests', + default=1, type=int) + args.add_argument('-nstreams', '--num_streams', + help='Optional. Number of streams to use for inference on the CPU or/and GPU in throughput mode ' + '(for HETERO and MULTI device cases use format :,: ' + 'or just )', + default='', type=str) + args.add_argument('-nthreads', '--num_threads', + help='Optional. Number of threads to use for inference on CPU (including HETERO cases)', + default=None, type=int) + args.add_argument('-loop', '--loop', help='Optional. Number of times to repeat the input.', type=int, default=0) + args.add_argument('-no_show', '--no_show', help="Optional. Don't show output", action='store_true') + args.add_argument('-u', '--utilization_monitors', default='', type=str, + help='Optional. List of monitors to show initially.') + args.add_argument('--keep_aspect_ratio', action='store_true', default=False, + help='Optional. Keeps aspect ratio on resize.') + return parser + + +class Modes(Enum): + USER_SPECIFIED = 0 + MIN_LATENCY = 1 + + +class ModeInfo: + def __init__(self): + self.last_start_time = perf_counter() + self.last_end_time = None + self.frames_count = 0 + self.latency_sum = 0 + + +def get_plugin_configs(device, num_streams, num_threads): + config_user_specified = {} + config_min_latency = {} + + devices_nstreams = {} + if num_streams: + devices_nstreams = {device: num_streams for device in ['CPU', 'GPU'] if device in device} \ + if num_streams.isdigit() \ + else dict(device.split(':', 1) for device in num_streams.split(',')) + + if 'CPU' in device: + if num_threads is not None: + config_user_specified['CPU_THREADS_NUM'] = str(num_threads) + if 'CPU' in devices_nstreams: + config_user_specified['CPU_THROUGHPUT_STREAMS'] = devices_nstreams['CPU'] \ + if int(devices_nstreams['CPU']) > 0 \ + else 'CPU_THROUGHPUT_AUTO' + + config_min_latency['CPU_THROUGHPUT_STREAMS'] = '1' + + if 'GPU' in device: + if 'GPU' in devices_nstreams: + config_user_specified['GPU_THROUGHPUT_STREAMS'] = devices_nstreams['GPU'] \ + if int(devices_nstreams['GPU']) > 0 \ + else 'GPU_THROUGHPUT_AUTO' + + config_min_latency['GPU_THROUGHPUT_STREAMS'] = '1' + + return config_user_specified, config_min_latency + + +def main(): + args = build_argparser().parse_args() + + log.info('Initializing Inference Engine...') + ie = IECore() + + config_user_specified, config_min_latency = get_plugin_configs(args.device, args.num_streams, args.num_threads) + + log.info('Loading network...') + completed_request_results = {} + modes = cycle(Modes) + prev_mode = mode = next(modes) + log.info('Using {} mode'.format(mode.name)) + mode_info = {mode: ModeInfo()} + exceptions = [] + + hpes = { + Modes.USER_SPECIFIED: + HPE(ie, args.model, device=args.device, plugin_config=config_user_specified, + results=completed_request_results, max_num_requests=args.num_infer_requests, + keep_aspect_ratio_resize=args.keep_aspect_ratio, + caught_exceptions=exceptions), + Modes.MIN_LATENCY: + HPE(ie, args.model, device=args.device.split(':')[-1].split(',')[0], plugin_config=config_min_latency, + results=completed_request_results, max_num_requests=1, + keep_aspect_ratio_resize=args.keep_aspect_ratio, + caught_exceptions=exceptions) + } + + try: + input_stream = int(args.input) + except ValueError: + input_stream = args.input + cap = cv2.VideoCapture(input_stream) + wait_key_time = 1 + + next_frame_id = 0 + next_frame_id_to_show = 0 + input_repeats = 0 + + log.info('Starting inference...') + print("To close the application, press 'CTRL+C' here or switch to the output window and press ESC key") + print("To switch between min_latency/user_specified modes, press TAB key in the output window") + + presenter = monitors.Presenter(args.utilization_monitors, 55, + (round(cap.get(cv2.CAP_PROP_FRAME_WIDTH) / 4), round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) / 8))) + + while (cap.isOpened() \ + or completed_request_results \ + or len(hpes[mode].empty_requests) < len(hpes[mode].requests)) \ + and not exceptions: + if next_frame_id_to_show in completed_request_results: + frame_meta, raw_outputs = completed_request_results.pop(next_frame_id_to_show) + poses, scores = hpes[mode].postprocess(raw_outputs, frame_meta) + + frame = frame_meta['frame'] + start_time = frame_meta['start_time'] + + origin_im_size = frame.shape[:-1] + presenter.drawGraphs(frame) + show_poses(frame, poses, scores, threshold=args.prob_threshold) + + mode_message = '{} mode'.format(mode.name) + put_highlighted_text(frame, mode_message, (10, int(origin_im_size[0] - 20)), + cv2.FONT_HERSHEY_COMPLEX, 0.75, (10, 10, 200), 2) + + next_frame_id_to_show += 1 + if prev_mode == mode: + mode_info[mode].frames_count += 1 + elif len(completed_request_results) == 0: + mode_info[prev_mode].last_end_time = perf_counter() + prev_mode = mode + + # Frames count is always zero if mode has just been switched (i.e. prev_mode != mode). + if mode_info[mode].frames_count != 0: + fps_message = 'FPS: {:.1f}'.format(mode_info[mode].frames_count / \ + (perf_counter() - mode_info[mode].last_start_time)) + mode_info[mode].latency_sum += perf_counter() - start_time + latency_message = 'Latency: {:.1f} ms'.format((mode_info[mode].latency_sum / \ + mode_info[mode].frames_count) * 1e3) + # Draw performance stats over frame. + put_highlighted_text(frame, fps_message, (15, 20), cv2.FONT_HERSHEY_COMPLEX, 0.75, (200, 10, 10), 2) + put_highlighted_text(frame, latency_message, (15, 50), cv2.FONT_HERSHEY_COMPLEX, 0.75, (200, 10, 10), 2) + + if not args.no_show: + cv2.imshow('Detection Results', frame) + key = cv2.waitKey(wait_key_time) + + ESC_KEY = 27 + TAB_KEY = 9 + # Quit. + if key in {ord('q'), ord('Q'), ESC_KEY}: + break + # Switch mode. + # Disable mode switch if the previous switch has not been finished yet. + if key == TAB_KEY and mode_info[mode].frames_count > 0: + mode = next(modes) + hpes[prev_mode].await_all() + mode_info[prev_mode].last_end_time = perf_counter() + mode_info[mode] = ModeInfo() + log.info('Using {} mode'.format(mode.name)) + else: + presenter.handleKey(key) + + elif hpes[mode].empty_requests and cap.isOpened(): + start_time = perf_counter() + ret, frame = cap.read() + if not ret: + if input_repeats < args.loop or args.loop < 0: + cap.open(input_stream) + input_repeats += 1 + else: + cap.release() + continue + + hpes[mode](frame, next_frame_id, {'frame': frame, 'start_time': start_time}) + next_frame_id += 1 + + else: + hpes[mode].await_any() + + if exceptions: + raise exceptions[0] + + for exec_net in hpes.values(): + exec_net.await_all() + + for mode_value, mode_stats in mode_info.items(): + log.info('') + log.info('Mode: {}'.format(mode_value.name)) + + end_time = mode_stats.last_end_time if mode_stats.last_end_time is not None \ + else perf_counter() + log.info('FPS: {:.1f}'.format(mode_stats.frames_count / \ + (end_time - mode_stats.last_start_time))) + log.info('Latency: {:.1f} ms'.format((mode_stats.latency_sum / \ + mode_stats.frames_count) * 1e3)) + print(presenter.reportMeans()) + + +if __name__ == '__main__': + sys.exit(main() or 0) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/__init__.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py new file mode 100644 index 00000000000..377bb270980 --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py @@ -0,0 +1,249 @@ +import numpy as np +from openvino.inference_engine import IECore +from scipy.optimize import linear_sum_assignment + + +class AssociativeEmbeddingDecoder: + + def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, + ignore_too_much, tag_threshold, tag_per_joint, nms_kernel, + adjust=True, refine=True, delta=0.0): + + self.num_joints = num_joints + self.max_num_people = max_num_people + self.detection_threshold = detection_threshold + self.tag_threshold = tag_threshold + self.tag_per_joint = tag_per_joint + self.use_detection_val = use_detection_val + self.ignore_too_much = ignore_too_much + + if self.num_joints == 17: + self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) + else: + self.joint_order = list(np.arange(self.num_joints)) + + self.do_adjust = adjust + self.do_refine = refine + self.delta = delta + + def match(self, tag_k, loc_k, val_k): + return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) + + def _max_match(self, scores): + r, c = linear_sum_assignment(scores) + tmp = np.stack((r, c), axis=1) + return tmp + + def _match_by_tag(self, inp): + tag_k, loc_k, val_k = inp + + embd_size = tag_k.shape[2] + + class Pose: + def __init__(self, num_joints, tag_size=1): + self.num_joints = num_joints + self.tag_size = tag_size + self.pose = np.zeros((num_joints, 2 + 1 + tag_size), dtype=np.float32) + self.pose_tag = np.zeros(tag_size, dtype=np.float32) + self.valid_points_num = 0 + + def add(self, idx, joint, tag): + self.pose[idx] = joint + self.pose_tag = (self.pose_tag * self.valid_points_num) + tag + self.valid_points_num += 1 + self.pose_tag /= self.valid_points_num + + @property + def tag(self): + if self.valid_points_num > 0: + return self.pose_tag + else: + return None + + all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) + + poses = [] + for idx in self.joint_order: + tags = tag_k[idx] + joints = all_joints[idx] + mask = joints[:, 2] > self.detection_threshold + tags = tags[mask] + joints = joints[mask] + + if joints.shape[0] == 0: + continue + + if len(poses) == 0: + for tag, joint in zip(tags, joints): + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joint, tag) + poses.append(pose) + else: + if self.ignore_too_much and len(poses) == self.max_num_people: + continue + poses_tags = np.stack([p.tag for p in poses], axis=0) + + diff = tags[:, None] - poses_tags[None, :] + diff_normed = np.linalg.norm(diff, ord=2, axis=2) + diff_saved = np.copy(diff_normed) + + if self.use_detection_val: + diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] + + num_added = diff.shape[0] + num_grouped = diff.shape[1] + + if num_added > num_grouped: + diff_normed = np.concatenate( + (diff_normed, + np.zeros((num_added, num_added - num_grouped), + dtype=np.float32) + 1e10), + axis=1) + + pairs = self._max_match(diff_normed) + for row, col in pairs: + if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: + poses[col].add(idx, joints[row], tags[row]) + else: + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joints[row], tags[row]) + poses.append(pose) + + if len(poses): + ans = np.stack([p.pose for p in poses]).astype(np.float32) + tags = np.stack([p.tag for p in poses]).astype(np.float32) + else: + ans = np.empty((0, self.num_joints, 2 + 1 + embd_size), dtype=np.float32) + tags = np.empty((0, embd_size), dtype=np.float32) + return ans, tags + + def top_k(self, heatmaps, tags): + N, K, H, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] + val_k = np.take_along_axis(heatmaps, ind, axis=2) + + tags = tags.reshape(N, K, W * H, -1) + if not self.tag_per_joint: + # FIXME. + tags = tags.expand(-1, self.num_joints, -1, -1) + tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] + tag_k = np.stack(tag_k, axis=3) + + x = ind % W + y = ind // W + ind_k = np.stack((x, y), axis=3) + + ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} + return ans + + def adjust(self, ans, heatmaps): + H, W = heatmaps.shape[-2:] + for n, people in enumerate(ans): + for person in people: + for k, joint in enumerate(person): + heatmap = heatmaps[n, k] + px = int(joint[0]) + py = int(joint[1]) + if 1 < px < W - 1 and 1 < py < H - 1: + diff = np.array([ + heatmap[py, px + 1] - heatmap[py, px - 1], + heatmap[py + 1, px] - heatmap[py - 1, px] + ]) + joint[:2] += np.sign(diff) * .25 + return ans + + def get_peaks(self, tag, prev_tag, heatmap, mask): + ids = np.where(mask)[0] + if len(ids) == 0: + return [], [], [] + tag = tag[mask] + heatmap = heatmap[mask] + + diff = tag[..., 0].copy() + diff -= prev_tag + np.abs(diff, out=diff) + np.floor(diff + 0.5, out=diff) + K, H, W = heatmap.shape + diff -= heatmap + diff = diff.reshape(K, -1) + idx = diff.argmin(axis=1) + y, x = np.divmod(idx, W) + return ids, y, x + + def refine(self, heatmap, tag, keypoints, pose_tag=None): + K, H, W = heatmap.shape + if len(tag.shape) == 3: + tag = tag[..., None] + + if pose_tag is not None: + prev_tag = pose_tag + else: + tags = [] + for i in range(K): + if keypoints[i, 2] > 0: + # save tag value of detected keypoint + x, y = keypoints[i][:2].astype(int) + try: + tags.append(tag[i, y, x]) + except IndexError as ex: + print(x, y, heatmap.shape, tag.shape) + raise ex + # mean tag of current detected person + prev_tag = np.mean(tags, axis=0) + + # Allocate the buffer for tags similarity matrix. + tag_copy = np.empty_like(tag[0, ..., 0]) + for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): + if keypoints[i, 2] > 0: + continue + tag_copy[...] = _tag[..., 0] + diff = tag_copy + diff -= prev_tag + np.abs(diff, out=diff) + np.floor(diff + 0.5, out=diff) + diff -= _heatmap + idx = diff.argmin() + y, x = np.divmod(idx, _heatmap.shape[-1]) + + # detection score at maximum position + val = _heatmap[y, x] + + if val > 0: + keypoints[i, :3] = x, y, val + if 1 < x < W - 1 and 1 < y < H - 1: + diff = np.array([ + _heatmap[y, x + 1] - _heatmap[y, x - 1], + _heatmap[y + 1, x] - _heatmap[y - 1, x] + ]) + keypoints[i, :2] += np.sign(diff) * .25 + + return keypoints + + def __call__(self, heatmaps, tags, nms_heatmaps=None): + ans = self.match(**self.top_k(nms_heatmaps, tags)) + ans, ans_tags = map(list, zip(*ans)) + + if self.do_adjust: + ans = self.adjust(ans, heatmaps) + + if self.delta != 0.0: + for people in ans: + for person in people: + for joint in person: + joint[:2] += self.delta + + scores = [i[:, 2].mean() for i in ans[0]] + + if self.do_refine: + ans = ans[0] + heatmap_numpy = heatmaps[0] + tag_numpy = tags[0] + if not self.tag_per_joint: + tag_numpy = np.tile(tag_numpy, (self.num_joints, 1, 1, 1)) + + for i in range(len(ans)): + ans[i] = self.refine(heatmap_numpy, tag_numpy, ans[i], ans_tags[0][i]) + ans = [ans] + + return ans, scores diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py new file mode 100644 index 00000000000..64d119754ed --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -0,0 +1,184 @@ +import logging +import os.path as osp +import threading +from collections import deque + +import cv2 +import numpy as np + +from .decoder import AssociativeEmbeddingDecoder + + +log = logging.getLogger() + + +class Model: + def __init__(self, ie, xml_file_path, bin_file_path=None, + device='CPU', plugin_config={}, max_num_requests=1, + results=None, caught_exceptions=None): + self.ie = ie + log.info('Reading network from IR...') + if bin_file_path is None: + bin_file_path = osp.splitext(xml_file_path)[0] + '.bin' + self.net = ie.read_network(model=xml_file_path, weights=bin_file_path) + + log.info('Loading network to plugin...') + self.max_num_requests = max_num_requests + self.device = device + self.plugin_config = plugin_config + self.input_shapes = {} + self.exec_net = ie.load_network(network=self.net, device_name=device, config=plugin_config, num_requests=max_num_requests) + + self.requests = self.exec_net.requests + self.empty_requests = deque(self.requests) + self.completed_request_results = results if results is not None else [] + self.callback_exceptions = caught_exceptions if caught_exceptions is not None else {} + self.event = threading.Event() + + def reshape_net(self, inputs): + input_shapes = {name: data.shape for name, data in inputs.items()} + reshape_needed = False + for input_name, input_shape in input_shapes.items(): + blob_shape = self.net.input_info[input_name].input_data.shape + if not np.array_equal(input_shape, blob_shape): + reshape_needed = True + break + if reshape_needed: + self.await_all() + self.net.reshape(input_shapes) + self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) + self.requests = self.exec_net.requests + self.empty_requests = deque(self.requests) + + def unify_inputs(self, inputs): + if not isinstance(inputs, dict): + inputs_dict = {next(iter(self.net.input_info)): inputs} + else: + inputs_dict = inputs + return inputs_dict + + def preprocess(self, inputs): + meta = {} + return inputs, meta + + def postprocess(self, outputs, meta): + return outputs + + def inference_completion_callback(self, status, callback_args): + request, frame_id, frame_meta = callback_args + try: + if status != 0: + raise RuntimeError('Infer Request has returned status code {}'.format(status)) + raw_outputs = {key: blob.buffer for key, blob in request.output_blobs.items()} + self.completed_request_results[frame_id] = (frame_meta, raw_outputs) + self.empty_requests.append(request) + except Exception as e: + self.callback_exceptions.append(e) + self.event.set() + + def __call__(self, inputs, id, meta): + request = self.empty_requests.popleft() + inputs = self.unify_inputs(inputs) + inputs, preprocessing_meta = self.preprocess(inputs) + meta.update(preprocessing_meta) + request.set_completion_callback(py_callback=self.inference_completion_callback, + py_data=(request, id, meta)) + self.event.clear() + self.reshape_net(inputs) + request.async_infer(inputs=inputs) + + def await_all(self): + for request in self.exec_net.requests: + request.wait() + + def await_any(self): + self.event.wait() + + +class HPE(Model): + + def __init__(self, *args, labels_map=None, keep_aspect_ratio_resize=False, **kwargs): + super().__init__(*args, **kwargs) + self.keep_aspect_ratio_resize = keep_aspect_ratio_resize + self.labels_map = labels_map + + self.image_blob_name = self._get_inputs(self.net) + self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] + + self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) + self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) + self.embeddings_blob_name = find_layer_by_name('embeddings', self.net.outputs) + + self.decorer = AssociativeEmbeddingDecoder( + num_joints=17, + adjust=True, + refine=True, + delta=0.0, + unbiased=False, + blur=False, + max_num_people=30, + nms_kernel=5, + tag_per_joint=True, + detection_threshold=0.1, + tag_threshold=1, + use_detection_val=True, + ignore_too_much=False) + + def _get_inputs(self, net): + image_blob_name = None + for blob_name, blob in net.input_info.items(): + if len(blob.input_data.shape) == 4: + image_blob_name = blob_name + else: + raise RuntimeError('Unsupported {}D input layer "{}". Only 2D and 4D input layers are supported' + .format(len(blob.shape), blob_name)) + if image_blob_name is None: + raise RuntimeError('Failed to identify the input for the image.') + return image_blob_name + + @staticmethod + def _resize_image(frame, size, keep_aspect_ratio=False): + if not keep_aspect_ratio: + resized_frame = cv2.resize(frame, size) + else: + h, w = frame.shape[:2] + # FIXME. + scale = max(size[1] / h, size[0] / w) + resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) + return resized_frame + + def preprocess(self, inputs): + img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size), self.keep_aspect_ratio_resize) + img = img[:self.target_size, :self.target_size, :] + meta = {'original_shape': inputs[self.image_blob_name].shape, + 'resized_shape': img.shape} + img = img.transpose((2, 0, 1)) # Change data layout from HWC to CHW + inputs[self.image_blob_name] = img[None, ...] + return inputs, meta + + def postprocess(self, outputs, meta): + heatmaps = outputs[self.heatmaps_blob_name] + nms_heatmaps = outputs[self.nms_heatmaps_blob_name] + aembds = outputs[self.embeddings_blob_name] + poses, scores = self.decorer(heatmaps, aembds, nms_heatmaps=nms_heatmaps) + poses = poses[0] + scores = scores[0] + # Rescale poses to the original image. + original_image_shape = meta['original_shape'] + resized_image_shape = meta['resized_shape'] + scale_x = original_image_shape[1] / resized_image_shape[1] + scale_y = original_image_shape[0] / resized_image_shape[0] + poses[:, :, 0] *= scale_x * 2 + poses[:, :, 1] *= scale_y * 2 + return poses, scores + + +def find_layer_by_name(name, all_outputs): + suitable_layers = [layer_name for layer_name in all_outputs if layer_name.startswith(name)] + if not suitable_layers: + raise ValueError('Suitable layer for "{}" output is not found'.format(name)) + + if len(suitable_layers) > 1: + raise ValueError('More than 1 layer matched to "{}" output: {}'.format(name, suitable_layers)) + + return suitable_layers[0] diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py new file mode 100644 index 00000000000..02ed8893bec --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py @@ -0,0 +1,44 @@ +import colorsys +import random + +import cv2 +import numpy as np + + +default_skeleton = ((16, 14), (14, 12), (17, 15), (15, 13), (12, 13), (6, 12), (7, 13), (6, 7), + (6, 8), (7, 9), (8, 10), (9, 11), (2, 3), (1, 2), (1, 3), (2, 4), (3, 5), (4, 6), (5, 7)) + + +def show_poses(img, poses, scores, threshold=0.5, skeleton=default_skeleton): + if poses.size == 0: + return img + + colors = [[0, 113, 188], + [216, 82, 24], + [236, 176, 31], + [125, 46, 141], + [118, 171, 47], + [76, 189, 237], + [161, 19, 46], + [76, 76, 76], + [153, 153, 153], + [255, 0, 0], + [255, 127, 0], + [190, 190, 0], + [0, 255, 0], + [0, 0, 255], + [170, 0, 255]] + + for idx, kp in enumerate(poses): + points = [(int(p[0]), int(p[1])) for p in kp] + is_visible = [p[2] for p in kp] + if skeleton is not None: + for bone in skeleton: + i = bone[0] - 1 + j = bone[1] - 1 + if is_visible[i] > threshold and is_visible[j] > threshold: + cv2.line(img, points[i], points[j], thickness=2, color=colors[idx % len(colors)]) + for p, v in zip(points, is_visible): + if v: + cv2.circle(img, p, 1, (0, 0, 255), 2) + return img diff --git a/demos/python_demos/human_pose_estimation_demo/models.lst b/demos/python_demos/human_pose_estimation_demo/models.lst new file mode 100644 index 00000000000..90bf5c80433 --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/models.lst @@ -0,0 +1,4 @@ +# This file can be used with the --list option of the model downloader. +human-pose-estimation-0002 +human-pose-estimation-0003 +human-pose-estimation-0004 From 8844834f3029a2a1473d4e782753b03ee512928c Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 30 Oct 2020 19:17:27 +0300 Subject: [PATCH 02/58] add models description --- .../description/human-pose-estimation-0002.md | 44 ++++++++++++++++++ .../human-pose-estimation-0002.png | Bin 0 -> 297280 bytes .../description/human-pose-estimation-0003.md | 44 ++++++++++++++++++ .../human-pose-estimation-0003.png | Bin 0 -> 297280 bytes .../description/human-pose-estimation-0004.md | 44 ++++++++++++++++++ .../human-pose-estimation-0004.png | Bin 0 -> 297280 bytes models/intel/index.md | 5 +- 7 files changed, 136 insertions(+), 1 deletion(-) create mode 100644 models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md create mode 100644 models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.png create mode 100644 models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md create mode 100644 models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.png create mode 100644 models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md create mode 100644 models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.png diff --git a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md new file mode 100644 index 00000000000..52186ba6e78 --- /dev/null +++ b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md @@ -0,0 +1,44 @@ +# human-pose-estimation-0002 + +## Use Case and High-Level Description + +This is a multi-person 2D pose estimation network based on the EfficientHRNet approach. +For every person in an image, the network detects a human pose: a body skeleton consisting of keypoints and connections between them. +The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wrists, hips, knees, and ankles. + +## Example + +![](./human-pose-estimation-0002.png) + +## Specification + +| Metric | Value | +|---------------------------------|-------------------------------------------| +| Average Precision (AP) | 44.6% | +| GFlops | 5.9393 | +| MParams | 8.1504 | +| Source framework | PyTorch* | + +Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). + +## Performance + +## Inputs + +Name: `input`, shape: [1x3x288x288]. An input image in the [BxCxHxW] format , +where: + - B - batch size + - C - number of channels + - H - image height + - W - image width +Expected color order is BGR. + +## Outputs + +The net outputs three blobs: + * "heatmaps" of shape [N, 17, 144, 144] containing location heatmaps for keypoints of all types. + * "nms_heatmaps" of shape [N, 17, 144, 144] containing heatmaps after non-maximum suppression. + * "embeddings" of shape [N, 17, 144, 144, 1] containing associative embedding values, which are used for grouping individual keypoints into poses. + +## Legal Information +[*] Other names and brands may be claimed as the property of others. diff --git a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.png b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.png new file mode 100644 index 0000000000000000000000000000000000000000..d3cfc55c673c69d79850a524183485ffe9a459d9 GIT binary patch literal 297280 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%0AU}nb}V-n&wBBBKq9F6 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

a8_x^k7=NY?`oJXvkbR_oIco!3sOnjBXAghMdC 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 literal 0 HcmV?d00001 diff --git a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md new file mode 100644 index 00000000000..117e577d0cb --- /dev/null +++ b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md @@ -0,0 +1,44 @@ +# human-pose-estimation-0003 + +## Use Case and High-Level Description + +This is a multi-person 2D pose estimation network based on the EfficientHRNet approach. +For every person in an image, the network detects a human pose: a body skeleton consisting of keypoints and connections between them. +The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wrists, hips, knees, and ankles. + +## Example + +![](./human-pose-estimation-0003.png) + +## Specification + +| Metric | Value | +|---------------------------------|-------------------------------------------| +| Average Precision (AP) | 50.3% | +| GFlops | 8.8720 | +| MParams | 8.1504 | +| Source framework | PyTorch* | + +Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). + +## Performance + +## Inputs + +Name: `input`, shape: [1x3x352x352]. An input image in the [BxCxHxW] format , +where: + - B - batch size + - C - number of channels + - H - image height + - W - image width +Expected color order is BGR. + +## Outputs + +The net outputs three blobs: + * "heatmaps" of shape [N, 17, 176, 176] containing location heatmaps for keypoints of all types. + * "nms_heatmaps" of shape [N, 17, 176, 176] containing heatmaps after non-maximum suppression. + * "embeddings" of shape [N, 17, 176, 176, 1] containing associative embedding values, which are used for grouping individual keypoints into poses. + +## Legal Information +[*] Other names and brands may be claimed as the property of others. diff --git a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.png b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.png new file mode 100644 index 0000000000000000000000000000000000000000..d3cfc55c673c69d79850a524183485ffe9a459d9 GIT binary patch literal 297280 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

a8_x^k7=NY?`oJXvkbR_oIco!3sOnjBXAghMdC zSox4)^Tq4h6uN;(Z8gin%;r1m81v-hk*8J;RBci3&S$$Mg%p)4j>&r|*}v_MJMX*y zLFxM?mJ{2zusQjLdGqlb?eNH6{tQx(kmYr%z3(Lt0eDTsH zS%mFWoJ4r+Z*2kBWXnPKuzkgC7~Fm((@3^3REwYKjMUb%GxKxv^8JZC5!t(K$KvU^ z17nOSsB{b{GoGTo=z@5&7$;VKW%gD!c@(EsF$csX!@y$Rqm!3hL%j6o{_NnVeqzrZ zx5Syj>ZD&OVWR*jhzJ5i(z=%9il%32Laf8WXFm7Jv(Ls~`1wAv^6790v8K)Gw zX@%T|!prn*}3BxKqRyF7%e;ul_4^G;oHSq+Do;*q z3%&UFqP%6*6~o$mZX-_duCN@OU7FnV%&=8X`DEnfxN%48ZRbgoXMKix1tSyA^S`qU z)pY<3zgw`~<{~7sUE1^TA*Ji8ulla3njdAgfftQ;uhrY z3?6GFGpv;j?r9e}Ka%!XoBn22uf}5TnkcaV6#^>nZ_^FP zd!N<$4T&asQ|pLaxoE@QoKswcZB=hk^u!F5o?2oCdQI?Tcw}rFL2T(=npJgI>>GC( zsJqLkx#&5Do%^cg&_awHW34zoOLA0Yd7)RX{FndvJ3shcv-|gMAT%**;GuJM)Zm6v zqbG8Hn1J1`DjxpjUw-YEerf5GpS@$Y7#mhR4IlhJf|9<4{WiB)(ju|ckl)D>;ibWmO` zoD&|ThaY_4$l-$$w`y`B!wtzY3}p-(k~pc>Xq@u3HR%K;5qq)H9)9@YyYIeRQf?L< zu^^SjxI){5PI)eyPm}ihU-|0SmsVDhnx{Q+R_8gj3te??;bJQeF=MS;&z<-4k@gvf zE=zlEvlCOa2IXo=HBL$7s)Xu5sJ>@vZk{&?0wqrfC;NjhF0Y<-WyRnEQ#KN}QzPY{ zXhngw`Rq9D<2t#(8d}HHe3of0ZLp5^QTC8;S_yL7Q%1^0SV!k?7P!t7Aro6wMX=pu zl=o&U5D>rhO!{?SB4RetvhQqf=-g-#?!0P2z>J*PFY`M)-#4Y0spJeEmy6oEX0e?_ z9G7>ZoxwPRC!#iTGgG^wt`vG_!1`Qe_Rwr$S*)D3 z(#DKqdHRs3u0mp%7)$}XYLvtn@Kg}`N;#cm>z&so-^yxE2GFr~7+EOm@y>$4+yC)HE}HKs&a^vcG3Y1*arCYtnoqty#v^k!0+ z4Wrpqlk-{$QHIH>E7OyGC~cw;f=3D*bMcpbHP|GYJZr`5HYBtmk^|q_=Yg0F|5$}g#-txbmG^3 z19C_)reM5tGAzp7C=8|;lChVY$(A*$9Bh+)+|86gRz^s9Y+0bY(Q?WtIb-A5COT{qT{-LtUp zzW2XRdN}i#P?oHwzyfy->0{Hur7;MEWJ*C2wfBWIjd<6qY!<)=A8@4Mev{ASbr|^8fXa7 z%E~sYbLg-ukcP;rRNLRiHlAgb?6yV&*NITZ7&ya;R9{&!Lb6y3lGSiz7&vwia0ZaM zt~R&V+r$h+vx+Fshju~FOw!rHV@}_qQb)ucUfN%}{(hc>nZ3z&>_@ri!(?390hxor zemSwNyx1-OrOoObbC)f>9oAYP^Kt1h2o8EZ9`rZ% z@2mIizlv@paRo4U?$q(&+C0&;`B6pLB=sbcE&WuMmR9yPt-<&1n%nJNFUDxrT}Yuz zwTXaM7-Gb0mJSmYXy92ZX^{O3NoruWlVYU#c~`gM?>;- zH3PnT!1Cp$n`4SOeVn6Tn{FrPuyyp#<#{Hfr_z^r?1U)pNkIunkiTqP@d?4+_mxn# z(F#;}qu6%@03La^9_}7(FnHkP(5;fYHa*q6bb3>et(=-WM4vZ+yXMoO9UA|%fr-Gr}vy(2Njx{F6F{DurbS7iOj| zA3AXDyS`I8hNXw@s|$Lrbmt*n<5-WX#6XF$PDMy_R318gVdBh%y?^ij_wxVyzx(F@ z>%aNr*S`^-cxq!9dZWlyte7}*svC@ZWJOHqs8b3un2oR|g*x{p86^(hlg#p>^ko2n zKz_ed2x``|uIDL(5={4Gd@gNHj}m6-Ht11#BlKR^hdH+JOABGuRda)ejp`nT(5wq7 zCZlTL#Ijy2UR^wQ_FTh;@ye^xsrGxn_xq$-tu8}B^tM3i6ftK?Ts~%9whB@iA6#0x zwz08x%grasUSX3m8@Ag7^R_G9Sgvii@{L|!xOJDcYEZvXB6J>SLb#`#xS7F)wL+^F zH;B(u@xpqwP97PEF?Fbm^T?|ja-tMG$71XvbedRcX!5wuOWk+W{4JmZS9%A9 zlSU!e=65eSw~WA^_N*>1tgr0{nldjgK}3hs4U^c!{=EyaT6_MvrwXFUUeBf2*MeZD zWE*6YkQ>qD)rO`;V-pG(2UM&pmF$#+g#hAq&+VNU%$CJuOzzs^YE>mbx3an>YTjmk zzu&-D$ymb}Y?&Odr!5V$t(Cx>+wSM3)#y9gGGS|l+HDkMY27wr)b>&<%LY{^nRrPp zH!y&?+38)vm^xGTn_el#yl#tq>3qNF6(SA`8tcewy@|EnL}W^!XuDWX3^(SgilK^W z#9@TmmE80m)`zT4?cX~ z0}oA2&scCio69L}axhE>=R#|^f!ONRJ$X~3DW$fpn0cx#k}T9#J!t6zhK80v%nQi@ zG~Rh9FWYe-5$teoiQIkLcIH&wlI1pb&F&JmTWypX#s$=^+P3Q#H?x4!l5@Esr6eQF#*^5<&5IB zAJ|hd|M@ST`uHc$efBfUU;LtAws(!Hsl;HN2ADBHAS@Z2nrso+x4upSh@CuQXa+|+ zPrd9GeNCN}nPr==WtZ(MUls2?c3h0?mfFj#+ODg-tt_(Z*Kbzhl=Xq`I0=O%B}1^- z?45Vse&p~WNut}uH0oeUmWwLCbV(4oXAT@V@ZI12z0z7uYZEGCYp=)N_{LDP>+(|L z>&?Dc2-;(5lsFZ=-Xo7cv9>-+DOtJ8_6jHw^Or=dnW16qb3YHp>lb2lU*_+f5iv{! z*`Fke$Q(!a7rhV6%=F^WV`vDum{)rJuh;nEu-4F+c2Wl3u1&K!ft+jo=Ewgv@7$oL~S6}DJWb*B=ayNj0H>l^v&)Jj*$*~|Qf z&DZ~r-#hQhrUisIQ)$^AC)>#xO*3I_jN?=KwzlfnVRM9_+k6S2>z&(o4569K>kW{z zYAXP((1^+KhD2?undT%`zGt_VUlq>vV!E<#Uv=QXuq-bECE&r*)&1wr?2pMgUnJxZ zgRSb8&2^qco5>R(^_zpTU;4&#;uOV!O#sT>P|E-Y@&2VkOhD#BFzTH{hH+SxoLx+7 zQGrZC6B`p$!_ZV0&o3;mtjaUS42|W@TzDTswC62*Y%Nj{l3lURdfj52piOFE)GVc` z>l_ZT<+_8jKm%qpu3A}+4MKF89wqn2B;E7A(dq~o>R`kP9+E=<=Ygo|6}!V|Vfh*W zl^T3WzNm`w%Ag-pf)tSfsc_!qcCLw2j#Qc8wm|0A99&NPZ?lO(Z@TFh#5{R0XRfX5 zEZKo^R%Ft{v)?jOhtAu$sw)(c2G(*g!}hy&L~ascIJzvxwgVke>(o3hKR>ryP?UnjunAxg zqA?CI6MLE1d8aC|*S0;is_!1-kU4Ntymz!9Q3Q?7w!Im+PStoxB`b&^Qd&2}jmgR3 zp+nbx=m+mA+%*R^VXYU)Y3dsF>qY0W0XVq*&pvyJ)1IqWi{Jg-ulZt%v4~7Dku~b& zO>QFQ1;{2z?y`|3(|3i_|AwZhIW`@FhYaAjw0$O{^gZKS~Kl^871zKB?eoc}qzjo!yrSpvl zJM?Ag>;LEf{9ky_yWdR?MQ5iJrCXYD^42m!J=$mhnWEJJK(g$@A;Z8U)#wt5yYub` z{>OjzFTe7&r<@1U#lWtVo>2}k+iE;+c_hnRN=e*(4McD4h-y!nDm?O*bg~GVL*UdJ zP3X}_VoWuHOIQR5bEDPopYFYdgGa8BLcnDzpJn&^ORJ;aq`Ek9L<&#W8{(k0KWFm~ zHqVSanY+g_A=z$ikv(Kc2v#G(jBHFc)^3m4V?u`k9gx%8pBItrXLq%{s$`uQ7Fymx zr{?|qjAxx{lI_TBFTX)<8AN*1Tr-(Sj@uLiB*09#mpe<*7)aD=g>GS9E?GzNmimw*k`K*0UNNjb{Qr1;hYi4)&^{N~$lxk+5j$w7&@ zdg#dc-3yl-UL)*bueY|c|LW!4D@)UmCd*zAvnlk&aLU?q94#jqDynqBf@k*9E@YnGvb7_q zVyHd)vT{(Yho%6SNahLgb& zT#oV8`|l4w`Xfi)`j-AZca{ZSE!;*5%Y;q#Rcz1C6R=d{-Om zu|+mh(AO3&lVLw&O|s??1p{};M^mO1%#UlH**Q1U#fg~mw4ynQsPEmgS2%x~)(*^P z&YTsG{M4y4mo6<{zO>lyP5$Ih{*+YL2rsPoI?T>Yhvyj z@^4+%P$3R_;DHAuqb9JpZ+zqN#NfSkHY9U6W#oxv+<7*)#9xw~I@BqbhK-e{u1~i5 zx2+y*1q0G0yxUlhys{uCR~CSfApY>|l)B zZE;h=9`ncuMjKi3OB^x==W0}1*S007-7`XGOjVv3^bP7Un8&GS(OH~wm^uftaSShQ z?V(n#n{DYxJd;kzB3WLu z{hYigsaRCZ-W^0WHmI@6R_B(b&hDw9T0wK?y`}}(e3LaGK$ z<8F-NTnm-lXv1-u>}i8;UAy~bqp@R*@(4-SEMlJM4Ma^A&iDFFOuZV_QX`5;@~m0p z)f5sUj;cy(PU;XWPhko$XJJ#j&Y0!X)#V-f)BJ++O(fJ5fTIk0H;vNlt3E;{MkQ(v zX0l-g$$N9T*!p`K6|(6Cl#zNM0rs{1!wpOUqj530OB2&vlnDvEL(^#7E&1A_m=fNA z>BwY<0G?&0ZLa0HmjMCx+ue0PXO*qS!WZS~GiPM+gB07$1dh`-m_0t;f`76ro*zVe z3HCyF?6*3)g+;vg_R6$)8qaI!%xAM6TG?K0pEuhdNXjGI8aNJ(3K+t99~y?1wwAwB zAf5}yvz|(cVyaWBHDu1Qu2OA`gmuzby}d7LYu#oyj#6sU(xKY$xJ>EQTThI>|9j^D z>;KmWf9OvfS(v-DYwBWw%bub`bgt0n)-g;(-uv<^<=4Iz{^>t^{J;C}KmF+A@zj~p zm;39qYgiWvC~)&K0R?QcPHb+KJNtF_jwhm2So;4gEASel?y>N6fG>2HO)(c*cu z_4c97t7LiswTNnYWogL7X?sI0bJlIDwMD+kygj3X6?OZYzx~_aeB@C%`uqzozxLYc zOP8*WMuMRg??G0eT97zIUIXA!X)H%W{eft43G}TATyAZxDT)n2oOVY}S`EJY-S2t- z``lWADY!~B6fL=31hroAE>mt5;;!3ZS- z7F<7se1hv42ugrO9C;nxxtJ~>RGQ{CHeILjGiMLUw;`!0Yw{6Y1lI<6S}TA299ktb zq?C)V?MF9YvCSFiPC?_Fi;Z_cXCz`4zKZPI0+H3gX2H(*He~w;*n~`p!Rmu8nQQKV z$#{qJ*SCY)8!-dq=f(I1#uaWfmJa)`Mdou5+U^WFDzzosrF{pk?cKlT{4yYqDokne z(uK)txC?lanKUj~M_sVS(G4C077Q;bcXW&YU_aK=7HVnZgzIs7{d` z`D$2+g{+Mz(S{VHIp;!1z9{XnH%~No*Uheh1z~bs{uZw-Cvb8lo6P`fG2Sx9zI(gw z=RzCre8Ub)&hA#evZll>b8BU~dR$wOqf6jMu2&BxHaNsOFa*cdGl6fr3o;706+~;{VHzPml*OQb>aK>&ucZ#!P zHl;V@hyUT}fBKKl|Hf}zedU#js-6vTHi0t^^t!H;V7>;dnJu-3 zoZ#CLn-Vs&RH+wvs=jOV5{G#Ju>LUN@qN?yA{^eP%z8kj#d) zc=g)Sm%sAWYE-8L){d#Jqo{LX zlv!zHb@A%8mF32(kR%>6+;-dT?|#pFj^A{X(N~EJfAHV|X-g$UJKp>2!1K0=!H;dp zD8|DmC7rbswBcPbZa(3>wQ!OnrsgdkE2HPjBBVnI-{X0KqV|TUgsU@^gY&+8S^}|U zkC6)HbW{op&7bS4^6kw8OF(ujt~v9<+CeRdqvn{#r8>|^d-IK#gEudjrJWAr@P6kD-XBfqhOnzbLaPs}#FZf;@$xw;ct2NW%{Y>Rm06zX9t ziq&277Y-a=Bw8a^3?Jv&&uJi&1n!XSp0izv1KCDgE&NA$qNZGV`-pn<#3&Wg7$ zMDOKffhB}AT!PWcgo{3|Upn>jqhI;_@BPNF{KsGT*T3{{{?%{(hhM&Y=FEcRE34p; zv?vCMBqY#KK1jSv5(nl5I%Rp&UMZy8_Y!RZ{>+ZUnySPY%h|3;~%j z_QL4k>QXOOcH6=>R-o>EHNWeRi#Q>**tc$7v`xP(dEf9xx7~ibq?Xb7IwWpGq8+x2 z)Sac<|9Jk7P3eiWpu8;=TiVmaKyc>VM!S=;jX~$0J|i7<-Wn*Go-2Q=H}V`BrE3Ev zDGLkoY-;G((e7p`ZYn)zmy%Qc7VHQ5yBJedhoL<)b)8axdKl6uxm3OXy$k=3|NFiF z<$rm|(bouGE#11u;1Il{7&lxA5jgPR%U?hLho4yc8-Mee|Ng&!dVTE(xPvuMMeNnw z3p^1Sr1;7a1KU+;vR_6fzzN^TTFG13ZTa=zZ|}`$>4eQ-9XG1l%7Zsc_T&+_I5~Dh z@(Y#37M)Jn`?G|jBTy);g}A3@X8V)V6VtQLJp00xMInM+TVB~%THd&NZFyyFcy)34 zfBeV)^vhrUn)9W2>g(&0k8EmR*Efa@+3V_>9Fa>JW0HXUJKp~G+itr}S)lDt1fgG$ z^yT5hhsD>oMmuKVZv(HPHE6Q)mmOWR%69an^tLD)?d-}zwx-G5IK!umAmE@GZPE~_ z1On#WA-${Y9V#lUN9vb_#Pw?-ePwOsY*~=+sfz;&Xy#=4jJ|D0l+(Dqv5o}PdfwKH zCCMNeY+b3x?y3IJu^hBc!@Sd^+93(F0}{AXUkVwxWdCH>(xm{n^WXjBN5aFFWM9g$ zJzFihBnqkPhnS?4k7Q{J(sC!wWLl=vg_X>Ul2@@_=P2o+D>vU-0bBu$Aw_h!wm!YS z@(}QzlzO4Ij-srEEo`@_4H{sE@H$6D>D4q!-s7NOPEGWtg>}84lGsBiG4?S{mNea? z`N`hCnTg#KJztMrdFH7nzW%jWo`3$EU;El~&pa1mk`R2^)D}-QgdtkS=DoKTRudwV z;-WO&6RgdbNNgoDo@S`6EyQDGwIytm%g@k}2Fyt|1O0RlXlv;d?DUMG!oHa`Z z6gg`5La)vxg}Nq04zj&CF?H^tx1_)Dm+m-rY?$IXMsWL0;rSExp?WyORv0I*U9@L*TL&~WwI0JTAFE+p{*v6GADUy@pPkVBG84$;Iu$( ze*&Hd=5T0+6K=~r^TX81-i@kC6kzT||}IISAN;`>0BJU0wZmjWUW zD>lU)#TK>JJI@(o<4Z}9<8zQ>zGOEXDX+2w+qh;da&Nm??51yPww8ao{a{|h%^t#> z-OCB=?mIg#x%*LXQ0ucwHcxW^>pCPe*ulpE*iJ6bwHhIA?NR%2%ZjJ5?v9Geo)zoA z&UzYB3Ir$yA|dt)Kj;^TE4SZy>0R$$AX;+XBC-=#E*-pj@gTrV%gh6gAcPGA0_&f( zYe(%f+v1+u>0$yo#Gim;vfAYkYDmdD&&u#G=4y=b{Dlkp*agX6krun!oMvWe?G-|l zOuwpjmr@iI-D|JDCWOtQu8~mtC+0qxc0L*B@2qAKj4H*%Sq#7ezJ_4W1VkM^B4-Xe zW%4-9WEE|1?_5jEd8I7d+jtm{QJ~=f`RD%e)q3JX4#bptk#Y%ZWq8DpsJ5&cJG5J;X_69AwMfKAnf{TM1c^ zYdU9}Yi`M^l;aGX3(-=idrCGTDtTq8cS4t9bmR+P>TSTfS}FZygy-J-e)!3sIrM+} zYj6GF2lo-4ba=(VhQ^M{1XFdqsg8F)`SkoR|H{h$@VB4&yZ_*eUlXFvuy0h&kE(uT z0%CNQtaPld+qf4;v*T5li#Qo-<|HE6JW*K3>&RwnWykjbzq!7Y+^H4c@*#MALhROC zuoMoPHqYVu9LLVlrWBL9vv!$CMgokCRph`3R4}=sKf&Z5d-AD&@DKmd6Hh&}xU_QW zjMSoESiH7;M*es4QUZMITi<^F{SPSpi!*~)z_&7F-is;l;)^fM@80d2drTeN>9{GJ zbKX#G7WEYaQFcs^=JtzDMWgPnASYXA6rSWD_q-+sj701RNLN9}@jx2g-lsveLCM@Q z3a)ptn0Q=Jd%j?#+H!T+;sg^Tv>cG%hHN8ih;~Qphs30lkP;$;4)bSP2yI55Qd{i6 zH=d7(*Eb3?P4ZZy!HpWmvvGz?G^8(DMH^TFV%7_PTxrX3iD{Os%Qy2(=QrE3VUpiZ z>h{JEGdQcGGIdAy%}4D1DAS=Nj@DnKs)kx!xm3qf55C2{>)nUf*UxLGd2qfT>SJpw z2kUx1CMII%nk_b4kYRMHVPuIhZPz@cSka9~P9T6s%#b*`az9=lP-QsO>0fX)6 z4?5SmRa3_FU*yK~gw8Ag&16~F#wz1;=cu-@)H^*4B9;KgF$rokKRqEQkmDg4oCz8| zF)GT-lQSEEQ=N!a%VU^YTb@k~JDx=Yx?*1^kDaCa*k!0tceFr?j(g0o#p}$;&@A?& zrcV{(zWw_b_UtvbLBK8RGi)D__eBuYtp^*-U>w-84LUpPkm?W>eg?8H0nt%a%S#y| zmJu5}&xR<<`ZeXR`z<6Snn%Km{pg*uC~hW~k2$oSWA5Giz|oh;jCSRb$&>FDj^j$< zt|6W|eCXHQL7)ONc26W{#et258PJpW(+ci;Sf{MUc< zZ-4Q{FMTDfjb>Ljb~W5DA&kPPjw40ZB|@h&u5hlD9bjkfN*m_39#$biXtpWlTiZ6u zvO=jhCftd`cckkxZ3~;1a z1X9u!SI7`G?#n?lnzs6rf#IoVp8eOq@NfUauYBZ-U-{~@&%G$>d{l)!dk?(h9q*D} zEV7y~gYjcrTfBDp@)d!)OQgMN;HeB+azv1$zBZ zi%GyAkFX5XZRZFfI6yL@n@saN*61C&wr(7Ta~SAbJd3S~!<;!n%rL`EOgC8+i-`?i1S>Xmz?kOOR%h1N5x7cWD@CSm@?hXMC0n$sEyZTu zv~9qWWtvM2!)QUX4BKNITE6CvSSMX=f{5Y=p^76#v_5LM`kn)Wc{3U zzu8uGRM1k2G1wf^2^MV@lRX|8TGH*{@y5jwm73Pnd%T(CC3a0i+vZ0uGStI*h~$`S z??OR-;9aUNP4v$H=no(Nvp;+DpZg2@?zrnB;q#uBDS^i_#a>-cF&z2DUwrAG{i|31 z>A$-0uYck4FwGCc-eH(dl-izDBo$IIZX|69*5Ku9u8r3v#ZG_MfRwCYid;>uLa4PC zmUE;rV`siaXb)@}@W&*G*j@9wk|$qGX35nd$_S99U6wO?1KSR=Z4?wjO5+uae9>!i z)kdwX54{6dh;}}G=KRaAoP6$u7x(W!^zg%Pd;j}BaNxkf;jogGCB|fJSVeh@Z*l3; zmBq!SOP8;#uQ#|kTa^rNVTxQuj~1FCSLdEwGps{cTTee0`w?ms#g-S{C{U;H&QU3& z@NFm&??~Y|#0ieBEF;7acnHNA@ZWH*W-6NDJW!v(x8+XOS~Pw$6xkZ6D|I+yHY$dOL8hL2o^b7crg znagWa-loe(D#J$P|3;E%4Tl@uAEUVq(eQT!EN$F&%}&n=oL!LclY_~A&jI&)qQCpg zD@*cwy|M|g7loHRm}o;msK^a^`Q?|MfBt#-8vty)D5#v_&K~DXrD6&rufzH_%W`G9 zbJf+>Jey?Ko=w@w^ai1cx(5feBn!1u%CY?$9w z^~*?@bm3j7>xtzR7>=q~rOmRXqu_O#a&={=2B}%tEUjDxz&fmBlfB^v9~Gs+taQu0 z`PN&d-dj0>nu9@2%#0q(MN*spx<%IWAcI_3q(+8F))}Ve?RF`qxH5~@m`8IHRT*wV zX*zQ8lF6Gh`Vk6WN()_S9Ee1QH{5=0yX@rofptyuvAKS+aqG>4mBm+F@D8sYJ9ham z{)Kz@EL@(NTJt_QDmgi=?yO#TVRYf_-hclK&wcz47B60!x^lGym{48_h;a=t5IJMf zVMua5%teZjQb1zF2oQ3CirVY7l`VEiHZ3$u*DtN%JTio4JB2vImNYwlJ6$CCb$_1I zLR~aCLeAN?J)zrT?i`5R5}c$qQf7+XxLNEcp1fYz+kwa$c6R@Bb5j;?`Sk zlcSti;8Rj zUGvTsy2h@mww*5YY>SQ9owm6oo!b!5<~P&pa=>kSN;ZAR9ezDeOV}2HH?^T*?T{FX zqO^RAH-EGdNNtN{gDZC{*{zANHYI5oN9+kC?^@-`}xrK$I*Q-Jh2D#~(X{S6nqP*wl=EPEd{PD-X{>64#J5=|}ZJ<4!Mr}?WfCmp$*z#xONw-szwYmQ(JdIIOi6U7wb_|B_` z#4Rig(WSAUic(H8(Ij*F^2j%i;Pm8zANALk8$dfopRi1{?0Rd{^BX#)`Njg98;Eq> zr|lV~JcY7!nK`WZ&VWibkv4NqcZNz)l%iSXg&0-Bt|5JIHDVO(7m@NalG!k_xORs+ z+pLHh$qmQzOU$c?PCLuCXNE^BXmUa~W6y9meU(yrQ%1BvE~h4@4=gRs|LcDxNYC}J ze|6*Or&gMtrSg%ApGz39w0w4>cB?&|*}F`#zV8Hq$CQQn%7Z;bNUf!@qu`B$ z2v$t>I@NS`sa2w?C<~YC%}J{pYm+lm$4(r-?atfpy7#U_M-Cl0y#HXcJutU0p9t4S z)vyl3x?+dut*3_?@01iH;ZsCFcE~-y{+@Tjhko#Q&o2^Iv91ZlDBXMQ>inhidkFUf zjz;yG=CQD#p7+JrbaZ4%IwH~@Bom>IqRypnku3Bg5=|Doh}gB}wU66F$7Cwpe0F(h zK72iD>=UC39?6+kRZK85yKDFE1)-0Lbrb-Kv_29d*TNUl$6QF4zx1UqKl|+S^5+EV z;GK^lIPV*>bS+GmmoeW-BqO!W*vX7^8x!pLo(yt@)t6h%r|l!4a^ACwrEI~XAc>Rl zl3AXfTXdNlnNV^RC3W{Ywo}FCs z1yZ30l{Qi{9nmrxF>SP-b8M+OOa&IMu=$hP_Ufj&HD|PI|Eh`NvLC*b}r6wVldKq6VAyY&YV(aC!3L1(8{0s z5Ptu64<`pNPWCUn=e-ACIk_HSPZjn*`pD8tuhR3+j(+~`nYNkEJIsuHZ_(~mLK(~yZsVIn8AACTL zcJnfLFy9IDVE7bjX+v(C&>qYCp-n;y>88e@<0lK3OZKZ|( zq>P8p3twhZXb$cCfj3s?JA3wogiI}Yt7|!BvDO9viTT7WH^1d=Z@c^6d-fgNPlVF> zV_{+UZuxIvUeHN5-+If5n{S?*-_@V!r<91iwkcEn?EoQ_Md8pB1W$`^e_QzjKX81a zH*{EYOpttvGmz z5jKqr8l^6koOLzgltkAHI@DtD^0TV0f@0_@%@&ASAJ(;0fLadB=oF%MNs>srcHW#6 zhSA^o=tobVKD)NQ!P;xzs>Q@*9}Fh6?|2NP$IPwU2(}Z; z-q_j!?OIOQR;WAk*%Ufwncy+PuYpL*2~Em>6N6@NApfaqZ~imrcF$2L-0Zb0^TTxr zQQ4M=5v#&qo||KEx!EpqO)l!kvH+bGPW!7KC@Zq}XLJmopQms}OdU zPNUG*2O;J5YpN;6I6(l_m4GKto)oCBaAN|eOn7gr*c(^pxo2RuX16_+XgASN@11)H z)}WHUg)R%-#I1GEo(!Yqc=49#$W!c@1SA`DFTgZUfg@&-GBH0 z`|1DR|M-nR{AB&9j~8G1QUp9cst$%UTLqWU1x|_##smcDIpOQ+OdDOFDcZOp9f2h? z67MitJ+f`Qsk~sz0Q3e?LI~I$uY1389$hx}Z>P(Y_;sg&X0Z#)r`kRs%F1=-+}Ypx z=rYNi@7levZ*G2JYI=4s zIVI1ye55Jw+@{!s^01d`u^|R!+fO< zBTm2(Vj4X8DOL(=82~s{rb6AUy2(mi|5ZSUApjvPk-vS ze*GhhmoE!3ljunK-r9NW|KHwUxJi;7+2Wwtz3veS#n4p^YLHs37Hh=A@P{vD#T9jJ#TH7jC=AkyB36{xyTp++x`Ecox0x131t+mIFR2%b7nBDM_-iayg zd6UxZjhMeur7Lx1$E)Ucv2F&tr3cQOSz8}Eom)x`2U&_?gzJ`Bwpm7W6`U8ss3E;nA2s+Uf z43&bW)X9AboI;DMRFzMD>XR0sv@?$)3P)b^iSvISC6dlu(dgP5Sh{#Ps}Unow55(b zLN;I|9g-sz%zSVp?UdW5F`IF@+z=V@J0s}Ms}&AWI)EiV(ggk9&ey;9vuCN?VqWxo z_LqL?ORM_6-LhB-v!uRoRaipGNsDwMg;+Sv0?bs8$xj|`+ZCcD$G8h8s5hqL;}&nf z+&8nHr>>V8?mCZGEm4M97jf4>!!qcXCm}vmyBuZED3}T8nJ2m5xOVNUU;CPc9PQ3F zMj7+YzxmCVtZ9U)@l{uoe7R2Tvb%J$fTu64C!27K8`p{{# z(NasdGJ2-f?#{K>Uj5P+zxd6se+|TN_AHXLIivHwcb8!ry18^KX3kBnQu|V18ZmJM z=mOhs`#7q~P%N>eg6;rsKFs_T)*^R|F7Np^4HGZxjpp$>sE#8&Pem3l_@FZsnjds_(a=M zbziqH%wG^q#9c2RtIl~0*p4td zZ(uOeO?cqlItIS<(o2>aHw4_RJ9kW@mm+;tPEBr?oLg7xTtqr&<4?H}6NTwlfu;_@ z9To$n=fn`8Y!Yc2??bZPrcq6zESzma{RhkHBg^KLbSY)>wB;R2UrPCRC9iZ*3n@vH zh^0bXKD0W=jDDNcd34s9Us-mUgBc%2ogd8d9If9W(J~@vSc&NY17i=N&ci@aCPk(; z@$=6=|Jl!e_9Gwts42XA1IN)Wr&MLY`l_mT>FrG4)>=%bJHFhG?W&ZvX=>4pwNs~0 zZ(KNk?$X7}7tfu2`l;rpfAZ?Z^Y_*ksm)7ss$0|O>GE&<#yzF;eQCCLwwji%TzP5; z5F4Z0@FqPa5~bA;`R<_Sjz0h3XsR-9Ra?&-pE`YN5bM=uTZ>bjKj*&C+K{b0Z3peY z4SS7^%|SMX4ywzgLEO)uJ!6njdxf=qTerP7m##;p9W#rEEK}mH@1%-tOJAIvH35Q$ zC^VscG%SSJuxrcV6nuReF=yuazqHwPr+wU ztUoC{&ZL}eD;?jxeSYs=QeW&vI5qvo=AFf|s=pZPn{u=$##%JL%0Vo@ImD>we!>U5-)bKu)29oAb1xDSr@3?Uh6SE#pK4jniun{i|8#03 z(wWc%5Li8UcWjOUhvO9xdSE%ZH?*Fh;KMF^M2Q-+gAy>PLwOgTkfOeYtrssIENFaI zyaqw+d2nCHGVaWY#~ex;1l8gwHWO9r^6&j;n<9d8$&nbr_Gi2m5&H95ox`L}>44;^ zpmkDKoF+;&1w6!yAA7GmdQYRDZqrpMOQx(;RPN=)mz92F)!ovxrwkG(cK+E(mxEg8 z2uFQ?T8gm^b$5Rg?qSrqs@{)9D2mSGPMlZ-9!i}*P?bDK#kPtb{Dk_D%~y_B=dp-_ zyuQ@ZF536L@WK!L;162(+O&9AdYZ7v9uh6clA>r0byN-y)TZGk=UVFK#wMvIc9NV% zE}idwxK^hL|O+yu`(C0g_T;pf~a6-fNFazPGZi0fSQ=|y;uwct%eR8BF_uc_k#*w zA6lrLHkH1y*}A>V{`D43Bc+mG1+zZfEFL7vOc8j)91iu994rv^dOCGTRT}kqfOn^U zP8AY3TaoB89wpZW%lpXU-ZW;Ln8^cmZt7s^H1dsCdLlxgO35V{<5d+OP(?tau_pc6 z?HfxWbS54akiOnNb*?lG+8fA(&SawE%SVs`F?6|TG~%NJYKL$<1(kZRQAVjYxlE0l zQV(VrEP}*ADm?y0=F%6$8f?evqQCL=uNmyO*3#r8!#4AztmkV!b{K+J#KIloFPWq6 zXK8h4SV2@Kdldr`>O&*?dCo1q)$!^aHW~mRHY-gKu!V6n&j}o^4L~R@^kGV^$hlj$ zHmh9eX}vENCA;H#J1Y(Mgjd$jk_&NpV5Z^n9=RF@;o#dOdh~d3QF?QF9r;d-AYGr2 zW9$qiKUFS3*djBTQwkc##&+w-EEnM4UVJ}w%HQnXg42voEy(>hO^XlMm*x6^R3FGkEV|ydD4K%=<7pd!s^6eX^N@)nDPs&wpoxQwj79Hs2N~KvdiYNut@#ZDa~YZZ?8986UUNS#`dq0B z?H2BYR1VT)>U911M6$_9@;`(ZuEz`MTh(;pM6QF7hcg-=XgVp1?&*EC5iAx{9t4OJ zY{$CYzTY?Mgovs8ZvaQ138k*;s)%_{JF9-js&rPp?c0&g2QVf;v7|{jWy11C2gV7) zs2K5~q)A;^*Rwv6Dn%+iV+%$si$X$)FO*|zWdcDZ=p``>SV`LoYH3tJ7v zuG4ZbZ}L=pS8M4?zp6Hd9Vxw%roQi_+Oa#!=K4?m_>+%c{rXzl5tY<(HnrNE`_*49 zx9?otICJH~<#T7wUNGe(tVQVVy{$j|lRtd@`b}evuF77Bu`n;_;>C+s9y7$-l>q~_ zZhlDF+S;-dfa&*AE0j8@;z~3@!3oTqz1xj#5r|GrLrlHLI~{4dv>#$}G*_9n{c5$7 zSnc7U<@IoQqgI-&`ooMr^Qe(M8a7I9{;5oLkDp7Y(@ZlAeO zNRXW_eb@AR8~66wQlUi~kIENJXOk(<<>roHi;l6mp|Nf+VJg6+R?16NJQ5ldY1`Ke@UKuFCD4zxv5f?w&sNMW%J)b&^FbsW0b# z{nyWJ-MgacOp%oHx<%%fYiE}08_IpkYp=Za@*jTTk6*uWvt2)py6~K{g~$y^Z;H)e zP}YXv{P_V|Kj7y*3h%1C+Z|-$gmZECeOw!X3!fs}WUA9+5^P&lE=5#z)Z~6k;&Nj7 zw)eCnfV>RIlp(U+xGxkfm6%gfhLf8?*Gt6X6PywCw~^2=4ef@THV4_7N2`9*JwZytZ@t0-^Mh z5~~oe)^_%mePyERkryGZL_KCcYSSW1?9n59HPFa&)YNeb19#5b3W-k}?Yu!jh)m;r z#sZOsI}7wMh;dpKqGA7j=4XHQ!yo?e#S0fui$TZAVGCpbv)Iba_Bhx}T1W*=geHQb zhxX2GP{8Vtia%HuH969A?_7O|lyKI2t+n*5J*o7SgsN-r#L7uZBHPI%te$=)znV(D z?d$aR$4B#^D`Gsj!hX~s{5w?;3wLV3e$v-nmENyQFSSMoTTp7wM_+0OpJQ0FOm=rH zW#q%4z<2L$yJENJ3l=VP=EF2$^4pA(jl?;6X3QJG9?PeK+9d?%SZ$<+xoIdhs>y*M z9j8-LpQ-)3sV=Ds2_=<8*GPU#R<9;1TB-JJRj(b^1(zgyn{~AyJ<%g3y6@aj{g!*^ zq6aj(%p{aK9h(b4gzT7c*o=TK2@(?CFK?}rmVf#~KYZ%^ncGQrOWEn`4zcumm;d=c-h1hl zGaa|ods%dUhMyc8&DA?<51gLuad50!8IM9o}1 zGB!1go~W|zB$#Djyvc@izkBCSEhVRsn!R6j_K@ZQ=2;f4Z3nGu%GU<;x982qzPQN& zt!S`fFIlWvjoASI8?yTYF5L-j+a;xj*j~Jr+jU9{8^TS|(RswIK+0fZbSG#$-1W?{ zsntM_a3XC8EEYwLA~p%hU% zvHuPdB$$GQW*`2TI76CD9v!fL6iv=gKJjEqO&ZLng%D3#86xqY%v|F-t0cyuV@&T@ zFX8)$3Jk|$QcED)HNN!$#jPZ6kW4|%If0ZjELx0(d|#rXTxGU1RcQwseegX^6d=h@ z$HZGitCiC-lcognDE|x`CcoPG4NvJL$Ga&H z$^FXo(87mZJ^wGl?>3@&|J;g=PC5l@-}SW*1Y}f|=807=jDuufcgWf077lYIbPk}1 zyNyEe|G_>qG!^)gCUMpmk~9^fC>IiXyz5@n@(lH)MN_J&y~WM%sQy{eJxcf^VuH2A zO^9V~&a{;3s`qaYG@^_d1+|EoGiUFQdW|Ro*e7!epIQCE!xXAbw~7CH_{TFz^Y*Fn zM`xCIh~fx_K7`>p17FVmRv;Q49Kk+vV4<$PPV94NH+1g&h41>rC%*f8zUM<9`H-oh z!A$f@XIPbPYW6D^F5>x4}GJO?aEDX+OQD}0oy&1fH-O|R| zo1vx-94`q8dD}KiGYFWISE;m|a&Fy17{(fi-0`;a@>f)LArw37Y^y1j%&9Ol46y33$e_JdYUIu z)d$MjlE!#+Yv2eHW8Z+--?l^wPM|4~84Ya}(UnmSHn;?MKI$84N`&^MgQP*cVr7Ki z>2xVkAbANBS}fJOgX{ z`Th@n=x2WZ=idGNd(A1Q#8&KWo~yv_R1%lccT`DAk=ko1iCY$RF2Ksd<_?Qo@!*--yv_q}< z+FI@Up{vlH?LF_JVr>YN$b484wJ3ChbbhV2lQ=CGjXCSJmZ3MW{oA&{)gH`6ce%wX z!@V^Yd2YRyQnk|F-k`h@;xY=kZjeFiul5G5kJ$#oHFLF1k9M`*v6t0a{5YpkPctP| znew5i5>K^`J*ZF(k2F_u0pm>5E{4p#)79qO+Rng7XU8*I6)(t$tWTzsi%7T`TlGIGv^RT2?A$3~_T=zk7Sbo2f1+ugl)8_4RwF&h@@X zjJBKj*NuhIZSKedV{T8FfQh6b**;+<3d>^-3aKKfvK}=wCmD@Sc95Ouu-l-3Mnuus z(e{zG@4Mb=^Ge@+_0PYueRnG{H92GT4!YIoU5ToFY@;TVC&2@3=2Y%9>%~r-G?W7m zl5GS7*XS&~+*qWm~_&*XYOr#;H8%0lU7 z=6`ed?q1EuV=Qh_b1Sd)yiRFZC7}>K<~WSnn7k;3MhBQU58<^xvK*oR&|(B<$F@$V zJvFmZMvJT{0F=4?`c9SX-Y**E)hfAZHqV@S{`vR*+~+>`v!DCiV^^+PnAZ}{#$dYV zBBP+h1x=o^$U!X8!X{aH_JC-o`ZDc{l6_6yJ7`{buIwYMDdp0u(TTr7X>U(xHY z3^3{{yL~a)?S@w6b>%*>Jw^fL_Kro!SE*fIzWSuK08Y*F`pw%fz52QlBpJoq7r*$W zm%jPU*I#?hng`l%F;VIJ#Dt#lPd)XNB~xE~@x`lGAGbJY%6WTd_xjD7FTL{WYp-8> z?X_!P|Avt*z4G!aufP2AYp=Za#*Le|ht`9)ZomHe>-L{n0v3ZuRlO-$Z*zX;>eVau zwswjPi+5`1l-d^23eXqyBY`Th!Dv#3gB{%CkUUA_lA7Es28Y`jrC%iv- z;xu6IY!EfOPnqyb#8HnJ4!^3#H8QY@(;4VbSUU#K5^e__5 z7zTXBo5uaZ3v;Qsv_ee4(_1Z#<}5v9aPcF}Ya$;^EDc`I|+CkEc>p#)ZbDZSVK$TLqp_1W+KZsUhB|3*~r z+}#?uGiznSi5FIP>4+5(KUpc=pM!e)<#VRc_UqDwkSzDeKPm zxnKL$#W%jWsI*qb`+Se7vNq&2=jb@rv`s>mbdh?MK~1h1hs&wmo$YHkZ(02O(uH%i z6mz{-eYbgc>-@R1OJ{QvX$NIS)Dks|g~8v~H|_Z?%l~iR+wI&%mWmrdYf*3nNv-Au z+qUmkP1_JL0MdO|079{lzR`#pIE}bj723LSb9-k8$hzuX`Jp@^6s=I0ooOTm+eEB> zK}DiOrpbo_Gl1P6lv75pCg7(1sY#cI zh@V_dXd|(;c6xW?tfdzgnI)0^Z0_xz+Sys0Jx8QjsZVK@s8n53O_X#Dxe5D@OA4(S zjxOx-nAI|)Jr2-l^rx7p93t=zk0OfKC#TfGy@|ZkLWVT9(f^o2Z<>}=r1W!zWqTZ< zDa5f!@D~qDr2G&W#F078;(-j`$OJ=gg~Ta=JOGho2*MpCt_8&Z%WhJlH<^isJXA#d zWU$*Kwo#dlceqysITCIbcAxJ6pHU;)GUKV&BV!v--zM4fBTnv(&Q8s+hX{MNfhOe~ zt?gor1*q^V+^g`FBLujLEIbUQVF)#qGx()WYyBwokBO|2sP@#*wY>Z{tNzb5YhLu8 zXF5T>)Jo#|Bfcb>NT@`o=lflIwe34nPMqX27nN^8ab^fQHd#dXyFU4ezwtN!=Epz& zaoevVJG(=zm!rUB(Dx*3izYFevM7tNisuj|4TGj`+;BNLXEK%A=G0KlbmLQ>xRCXB z!!_*_)Fh7Epn>Xq|Q%O3-vvF`{-3IwKH}(m(DSF_Meqp?)7z5w5voz z`>~Ckz5exUH>}gICAKZwZGi-9=YR9&%`M||ziUM726{8h+OT6GdK-PIhX1zuE-Pm; z_xfE=zspMR-t+GFyzssk-t+v>Fvi9+&pcyKJ^uLP?|RqM=Fp!#dv4%K-PknG9G(1$ zvb7ktKEoCpxMfz)_KtXsKJFY2nRsPH6&Y}jB=L;q51#qtpf7A>8_sx-xT!jfA5rGO ztCv!}Jo11j1jS>(hY#CQL}jMGNhX;ZHnzQzR(7&w=}A`9uFhQCNo`A`_k6CD<@W7G z)}+LXCN<4kYBy7(Z9_SV?Ocxb{Mdys=I)1R0`d$4-y*;~6LSt;QL!2jaynCU659Y0 z)V6IY#Te?%JGWwo(ihd>x1pe1cL}C7xgXM8ToixMhelXIk03+Cy`0{X2qC_3eA?s5 zP-icQoQF=I72j}-*1&R~ULW=X9UOE(=7z<=*UsfFaEN)|nEw@e`z01xj0n!t!$_zl z43Y`kF12`2CvfElZ8m2kiM#0h^~hW`Np)%#sj z@J>EBkExA=LT{&_1b05@7}2+Vu3`nRo_Fk5ofU3>`m>+;>wn{KJoldW^m<@F?`TW$;U8oZB?D|FWVB*1qLi-~YX*7tOuw1pdP>rbS=Zx9(o~ zXaDq7N*jG4^MZ+1mt5(aJMO3<;lLO4WEBn$x`LJVLQWNV8adamNRC1JiO+uouQ_@^R z%%N8}gf$CaL8tY}yVTU^{q3`8;3Tk}=idF?Vma&(MKd}`r0aqi;=Zl9W*$SRx#-Ru zmKg>|9wC8y?~!j*k~kT2g?-e5HAlroPn_@%sskdXPOcnO7}z;lo1YjF49u4(CyqgH zn|up2dZ_S_w;~8Hs`G)Fg*p_OHRzQ20u2-fmIP?->;tGA-_CjkLoiR~66F`1W}URg zQK1PGHnWOS_24_ZYF`t5Cg&%mB&ou=OUrB8{(99rY2E#JN!1JR!fc#%(80kXwHI&3 zBBjo(BHLCb;qi(-aw>#59UO0YuwEfi@$z=cgPSI3Tv3ZA$3d1_E?vE1b-FgJ%G-LC zZ4dtJu5|_Vde*91yRNIfOmsovEs84nrKXCPigeweH$AVJ#Ir_OZ~oMeKYjV~S5?i^ z7Nz9v1M+Tv`5*t&SF1cF=^i&&E5V3WZKzbxFMz5Q3=F$NZ_^!fvn@_;kn?TR@1~K9 zYBCr7bY5=W+v~pi&6mIWjhF83>}^_;z>QN%Y+uLv{a?F&%^Y?s)V!&#>h!F}{oBA44=y)MZoCqW&!MxYHJllacr7Xdz25a5 zs#~icMEOf}CJpPqx`anBG?WY^w# z*32~}EcwvxI8MaV3d!Inz^Fx1N^>oCu(f6ox*`Er3(hB6{@4}k`(DSiQMJoz2UT^= zc~bHFAjR9)efwDZKNem(NrJW#b`l<@2U(9)Lu=}hnlcLh;HJf8OB_Nm@H=p~(4$F1 z#!ilk$_G^9&;8vuAMj)R%pb>i+uNOe`{WVp=|h)KhNPU(RAV~JL9QO5F92vCG|Z6_ zM&#RV@F>dMC+-?5i6yfvl$KSRuD>e!EG1!GXC=;Gqvl^~-sO#&a#mgzN|f|I64Seq z7804DZsZGmVXjQ__OtyQFLU*OWK;gY6+vRTq;G++jRy@*cxy6gn#SVHfBkR%jSqd~ z!<6`*`>KG@dT_Ry^ra)IgVtO1ZsxniHIc=1{ovXTO40Qqk(5%bd*Alm-O_85Z+-T& zMqm9$nQN6!6IZT#y?N4m|Lgzt7hiqt?DbpS-5sjBGQgcRC|@+2i#9clV8T|EUHZ0o z;C&WRcDjviJQwm@^p7SayXTBVUCIWCKc`cNR$uKjW zM|PN;LpsJ!EPCS_oWidzGKQBiLx+w@HQ5%6)k88}z^bQs#J`TYPa;y=w#@w8bI*P5 z^Pm6lM?Y$7p=FwF1@zc#1yTdt2CSmgi*_nKlcEDt-{TN?-`cW2e#dll zEvd;1V=6WA>`X)C+OaAYD=!dVnHuejcla*V{^V+SE9r!^SrkgIzH$BE{`znH>6gB2 zQTH=v&l$vd^UUd#vl#*AnqRwq-IVnkZ@lpuAvEy3+^AUm!SF;2P9!lXyT z&0;A&l-F*cn&0+_+?@ABu~D9d-}9${1WM(slG(HOAVr3xK}Gz(Zd{yW7(apx7ad6nry0o$7<`-)dyc<&28`lCPk_!Ccp%XJPn|n+Bhwc8NaUPWJ8QS^ocllhU%zl~ z^;D5cit@|CM488CoDo|@hc0GfhhwLdfE*uwrbuk4kDgSBb9SF2Et;iOwQc{_Z~yL{ z+qd8S?93N@#8XU~w z3;LCTmWy|uYM~QT$b+m)oZWEF85F*>xM_)u^B10beVf@!s6-aKJ8QM9mym@PVa z(9@w%4l<(n*v8bACP9q`ATVX7LOe;W6yFYC0@VSGcjxFph8rgcce}*NF0^s|n`$?@ z+s7Y&;){R!r=_o@6fgeLDuuaGq6BIkp_CG^?SA$sG3%^;&;LK}6sjoYgNiU4dp_eJ zAE{+V2YPA<&oNM<*De+*HwQG!+}$7HQ%osh?k=37pBU3PC1jtjV;DqbauHHe^Hj)5h2HXU0KmY92%hy}E%T#m2)t<8B z@~;2w|L%`=cAx8{7q8p$x9XwzsxQY?`cl+cRSR*_QN`q@Z3p(ZoC8z^ZY?ywSou>T zG+UpzFXj66>lSrLxnWM$md!yW*0tq~HEVg-(@$TydiC<9%V*D>GartKy`SiswI(xm z*xa=1CToUgxBjSSt+}~S>Wc1krBbS?xxKyn>KiwGI4L9Byt!Wlc0=tnjRPw|`#0lC97H-w?>Hwk4F18aZY|#2)6@f9t!-!NnDaPE0 z#6wMru869MxFeE9vzF488@C&(4JWBua=N{FX1Coa;E`d`$s|HppE%weGe=P@GjA6i ztS3+}P0k`UI>@0fSqP^z5g$h5vv5ubaKFAUj&0~_DMs~gV%+sc+kW$g$xVAoiSyV~ zE=V;}=;(OgIVD`+5hIs27vMeTi*_vf7GP?@dNVG%(_^Tk2d%yTM1J|r`}c8nyRT`WE@j^L&b zfh{~+2I)}uVI(2^2!LSsUq z`Op5q4=hiezPr0uL`+Rqk(?XV;Ro=SysxGQqfd3ag{=S z5$%P9s3#lV%A!5tA-@J8mM0Dn% zskC)Dw{2p!)!(~=x16#&aLFS2W?o>M;ZCL_;0ObuYYuc2v z*#Y8IqaH8s6Q(Vwi>KuP%E!jEAjX{J#s&8-r7Xx{m7*$OfSsb|!v?BBTzi$$+YV9^ zi=kOd#+!qC9H+$t9x1m?0ySxxHCe{H&jdv?xGLglnN`Y((&^f)-{ZA@t5s!X;k?St zosBhV7b3DsB~!!Ppj0oEOlZ3aQ8M1lVTvgU8c_jRKTjq%O*5)lukI_ghbQB+KC5ah zuWh@gtoH={;>1Uo5VIu|Vdr7Gw0y-}{CRCHJQK03(xrI!6JOZEh zSx#seu=A151Rk=18(In{hIZ*=Wg~Aw1ScH-$Vy#-ZRFbxwX5C%m@{z9lhyCiTl&0vbP5aM; z{-|BwX4+GS!B3DjaWh<460!I86aTv`v&xTj5_h>C-+%WVDLO5l$F*QFxj)Y_6CZ)- z4Ei5Dm>{i4RHmHNCronbyHZssHP1Zv?BD*ofA{K>PYfKUT?Yu2E1PE04P*z!#k0KJ zrerTvl^&3*igF+?Kd9s@acXi>vgdP~mS;A<_+vkOiR;VT!XBva3rUs5pMUAG-}u$9 z5nb%cc9oKt`cf&iGEpK<0Z2{G8syGHoln?WD}dkNW6w!BXB0hQDF%fir35>`U3aRb z-rc@s32&<|d-Cxsiza*2ftGDHcGkYNcWRv-uT4>0F_<{jFzq*Q8fblmW~)WGtI~^V z$_+Q`)?WP7X-Y|%4M|rFb^y}WwpEeP08nYD3yoWPzL-S7OuY1}p`rT*C(epe@P=mO zqf)EptSa%AI!P5_&9KrF!wusmH7O?o!74NdbaCMadR(mA#SM=9#x?r)9Bv1sAR)7$41 zpzra>AY^vfrf!OeG58L%Fy&fmS@kHjfBeeTPks8+R;>8vU-?SuS7W2*I%Ssmg3!KOSZ+r(TaUxV+XbK+VzO;XA} zd#X+WCEGbVBg^~AP#;ulD*Z(fH1xbLll(F3`)CLq)p|~pn<Xo6VrwZ7? zibL0&@T`Z80HpL(mrSK}(BA+{qan`J+L?Nhrb$DC-c?7ucly-Vf95BjZTZ!lNb@2k zS*=v*(jWXT{o7xCxzYupRMp?6;VJ@b9X@1WB^dL5M#7H>C@c)-zG<>qBf*Q>w#$@K zEyXnRXmf}blywnvYB*E3+WpE`zy9j0ueWVubTDm`))tL53}3bjM8adaQjxyYt-C`R z+^(qv(Y;<)s3U6^Nl2Jd+isjXy|H;pnGJbh;oQCyc4@u+%Lt+l>NfnFw+~H}#y>h& z^dlvTy$No|>dflJZi8nzmsM-)UrtKXL&EK5stHQf^5oIn6w9 z18X@e(cU88xpbCqE~WI6l(?SS-Akmp$c<3$(@xd4VH0TK+%)VZjuAnchr8mlgc-j;i1+;UZ>u;LDw9+D3GbIbMtLo{^(~mv&*i%nFdF|S@ zTQ{!H2~n9+)YOd2t&S2frZ}0gY6htvK4jD+@GQle9tkWySGu}?%&XE&A}SY59r(SI zjJJs1H^C=CBocjKg$~LI1Z{sQs`nfBt%;191_a7XP+Fc+f|7&`dx-eWrzT`puowr@ zti4g%k0n!z*c*wcV7F?~QlzYkYzyC{+}GSmdwY5MH?QAXRh8lxby)kPtP|`+Ng{PW zpQ|y0Au^*x#>?@N??BN95PC$x4L%!FBW(uD$oi?x_kZX^zw|4={KS(_?s!*Fg8>^D zcz}pI6*(Z-tCj7q;GGkV5Fw*wtEC`ASwM%98N3K7acY`MJty5*m#3e&{dfQ7)0=Cr zGj*z2R98iWu72^0YrpkdRrEp?=iygowjG9FKCjm>Ig%JpL_zz7=l!F0_Q}1Y%3YHo z$|{ml^6seCB7Gh8T~)XU*-+cpba!WU^Ul3juigB{E3bdy%U}DQKm5XP{{A2T=I{T> zu>HM1{>?x5li&V>FWC0?zwo86z4F?PyF0gccDMVwC#t!ncA+V2&P92*>&@AJ^|jZ& z{FSeK^QD(i^sFLQ=scJRi^W(Agq0mREY}ULuJ>0Z%o3FN`hDNkS~;absdEBU9?vFb z)Efk@JCvW}+xwsq%X#qZ$CywA3Fufsvjz+oRY`7e?W*3~Si8$f8m9#;Wa9o#s$Wb?OdN{%pb;&uYobc<>WO6tI zI1RP;TeqUVyh#ny2?C1=M4|AblwzaDuVwR-@|U8j4`;I>Cq&F%mufN*Ntr+?ADIS@ zonR(l3Q3bh`<7rp#DatF_F8-?Eg)s;s+60W{zMnQyLsugK+6@tfW}48&weR}qmXEJjWmW1PQT0M%8K7lr z?fOPJfA;3j|Mc0-#p}zq%k82{L$wNB_`^TcfBcVc_VwJL5mWNW(t=ZyQcKD+#l|*b zm4I5pvm+~F-^U84uD!hItJ*@pH!RtAOsQM16jU1z&3{d$n_gev$cweqw3-@93uRmH z*Y}DP%9-Id(!WUDLp21QPLRcx!xq9@)HxwjgM^Lo)8 zuX(eRWBU8@V~@T2x#ymE;)(O;&zn6VCLY^>3dgDIy{--!-r^GcErCo$F&nNz=?gI% zHm_-iTYTbx;JzQ~^!nb@!y;h>)KbxV9%c>uPsXYc);u3v%-em^B;x2ImWiuWi%^u( zYi{=1g{j0o=Y{f`B<*+4Y;B$1>yolM!Z6UbuDhd?MD$soGn*$94mp}hVjpEGd!S-q zHz>W^_~EBUQ`BsgjRsz{uVLrMs@5=j`o6a#=9gQW90Na|J$E+cjE^wGai3^{9}y(g zV{5htCkvsJuvVC9wlWA7jfj(DU@bP2#1jk0FN_nr9@1a2>?opJiurUD&N}+RDy2D) zD#{`DfpZRj?YT~YIfR#=n3VpG@#&S`76~XE4E&T_kq^0|wq5w?#tX&_9O9J-#HW

Dk(8CfK3oB-Q{Ak?O{WeFEV@yd-I2&&Xfg0(-vsWYeF|A7zuzz_bwkN)^ieE1_DIe+P5U#oGcSzWlXx0YIQ-H931 zLWrYJJQxb3bmz6?s&Irx|D33(*6c8H<8;r91y#9x{@Uk$`rLYcqhTU$DYuAZ{?VVD z`!~OOhtm1J@~Q~8UI#@BPPUz%4f-qMRw)ep`i$vT`HTC}-QD)M^^{D<^7N$(fo)l&fD@VFwH4*5vf5Q$PRn zKldX)@*|)8#3zj7-7F-lVILA1wI;W=(UO=%z*N&Y<%?7qqbZX%iaa}DB!0t}4(}IyyLl^6 zKZ>p9jPJ^D%DpsWWNkvprPrjf;oHw&IDh8!X(RAA@}YC*&fU6svljE(cjqPk(S$yP zLMBBFHz`b$L$__v0%BP~LQ!CVi z;>E9Fe^X+XDH}%+%!Y|j5t}ilH#LK)tg6GNuhh8L-jUqX`bA#saa%>31oJLP-C%!a zkF9Dj!@%N|sbqx%!%iniSh|0KvNsRwp7R8=$Z64Tn5HI9&0_iDi|_xbpZ=+5pL?$B zdvjQ~?rnz~h?>+ns-uV|Pq3&|feluwk`$LIw1^~Y6)~r9C#Qu;-$|PnT$_#dwV(Mb z?@IMgnAvd<)ppwDsW1Ln|Es@#XSwm5s5Ht;)l#rTucWq87H!L-EwbGaJ)Q_t5|JFp zxu(P-I#=Y71GbdydQ!QWs=S!SFN<=iWt-Gf*J$~zVBkf)Zp~jOXaH zJ$!Vc#iBL)$oOx5?N@*G`i&bF^=IZ%s|DMc$4EQcE$lgEthxeoN4C)fa5s$Fs+m*) z^&&^L6-}vdzi1n&6_sqviA81KvMC1&-XO7V`%Q8j7i2s&YX>N4;yDnu;dk$_Y2G+} z_S|CqLfR2sNv=R%WZ0rZs73)&)F_wIJB$eaYPM|zb@o+e&I&KsC7|#e zzPk@R9Gx(@KgA13>QH248?aXOwTN^{OZH{Xw%jl^L-Ep1UJ@^J%?)RnimlYggjiuA zDscV~cQ_O=o)A#SjK7p4uqi@hvEO!W`Q)?D{+(a=g}?ug{^7fxd+zSe&Z}>{vAw%f zRBcp;TjzFAa?t`;RK}}4LR-gL|Gpa-TWc+tf#3jNb>?L5IrB@?t(b)xzQ^U|55BK& z`0EXKK5dya)zbFm@}K_Mrlu>al6qxLdAWXiZDW18ZqaUIbUnMawvHZRW*Mxz3{~ID zMH<(48(Bnw>qZ~IY34@2>0tkCCn@his!A%g6ic02NWvJ{?faNY-SshKRl72<*;a*v z=WpNgRK-Zzp5y?dvKhI09o)09DP5@U}! z&)_^XW6H_78I&;1I4~aABb9L{=n<+V4W>Kf}Lr5U(V_D=-yxS>cM`n=R|%xensa&RUA-P=c@C8 z+6fFO8Qk8u-y9P+nZVHA^7d$ReYEi%2$G^hZU+Q$Ds)W3(*&a}Za`q-AhZ8xE>4=a z=NSnrL}E2Gv5h@Y^u9nRx9RR-smaf2qs-&%<|I^e^0;T(S(VDs#Dyi1xP}HYrt+kN z?suJot7w919(f^^{sQTDlgDjl^-occMKx7x2K6s zTXIg>n`fscbDoN0Lkp@#C83MdT97P+neI~p)1q`m`d+(^Y>$fR@|RwG?#_okkQ3j^ zi85)Xv}jJ(`q=;Z|NND&ztnVvi}YPBU9DS&zB9)1Qb^mTwKV63{g?^|c4@H~Xj=@$ zX1dTcJ@ghFP){?5H_obKol?*u?IYlv)_A9oUwH$PY6Iq|jlTAKgI%&3O7;26x;Jz7%o&TiZ@9F%AsxewW=Gt$jQ-Z0-u-eW zO$a>b#73YzZ|EGY7(te=&eKpmRqV)t&drpP_e*k#2U9mAbp1J@0ae8L!{e*NV{nZn zO_QC^Wc$Low*u7j=Wi?)L^&&S?U#EyXKN(~Qenm*))#~_I1)ny5EDd##y=XBc=wlh zffBMUz<>FF;m0C>WHZVV)Z5#8>7|#bkEb1Kz%L-rMD2dG0 zTyt>tBu1n&54Anjw^!{^eSjhFR9*hS=9=pKG17!pN-SWa5_K%WFau+b!zp)}pG;z& z@kMvNjUEoz9yl3_Z>An1m54H@HZ_z}VQIwwexFjws@+~LySm#aHt&SXo)Wbti#Fv1WvZ0CmN1t>!yG7gNnZKbN7lakQ#&kg zRN3q54hhx1?(J>MzOB@`cbM4gECCHEzn*V^~B>xxwIo{hsFvtg>; zf~Dt7&YwSf);1Td7|f1~lB-x1c(7A~7W!-Mo}enYN;N=!S5`6l+KCjnCs@RXzN@9T zVS0Vf8^W5J?@NznqoA&jp;B0dwXzn{TKbOMuFafmESlD~Eihmzb{lQqwG_wQTDs)S ziF9xb!huT-Y5{_=-VdXK7QY*D{iUz9w;hDjLgtN@a>^W_nTcDCgGu6`Mwx@^8MhWC zoXD|ZVr2Lwam~D!+v}%K^_MR%QkyBS5uaXlXZo(AnwbEtqM4a8(SfrLn-tI&1Of4+ zZ}@)dobUUHqw6Cg$jHQ-MQGE;N-@t}IQQ}^FIyu3vlF4bwzjrvEf%cFId|Ui7WYmh z@4(11j&VOi+tHHMcSYvqH%F?eoN|zK>oFlmo=h&piByMBN2N)uBYamo%HB2t#x@HCCRlS%`|6Bw<4`^J~TO+V-U)#Lhp zVgb--jLvbHj)tBk-Y0~K7nhrT48jjV9SH2w{NZfyA?^mgltsj#H9 z$jx%mG&$Sjy`6h^?`-W@Be|V>{qS(N^u0=0+l;^J!0*O3j4uTvn}K5<+ZPHkSWCeK zFHj?)7(^JxOde@Nqj`DG8O`R6&X(N(LKlb86`jD3`0F6P1&9vJtSNDusHQBGh9_#T zB8z58!c_WY*-pIbh&EUKm0P!pb|k%UzSnHtI{z3Yg%X5aG3(-Rq9%c>?yQgpdk zD}4`O7c7;pfBma@j9?O&5RqbzjAUq);DW_Lp7l(N9SG4u;@)PiAu#J6rd?948tQ!V zy&gbupg_H4t)RD&VW69>VB$-yU|@t&4+AOZMATLnBATnQlvw8qk>8orZ~6d~UUVcv z@Fc<7@#rF`9i6|MhXT9O4jitSG2y*BuB0-%Ys?xLpCCcNl?sZ6Y9e*~UtsUe3Wk7l z1Y1;GMGxbo#46Ho!YqLuo?MGlfM~;jW&crrE3UOZ!l~A`u*`5?F?^rUOW63>c_;~> zg|}@kwWge<>hjc?zxB8N_RswM&+RaoV`;@_=3xR8gI0dwt|})P53y7Mr6qfFXu+k6 z!hz(F$*Birsnua=EqEZ6ltv>Uq#fLt`Rqrg)qLhx3az0b~Xa2AM_ix;|bE?-y zq;FcieOH(_6qY@!N+G4bua&t;#G!dpLWsLB1qN$4HURgfrd1t^kE83XpuxA)C>EMC zfD=bALP1)1)~z$T`rxWfsFcJ?5IG!B>HB`v?yd=3H!vt4h9j`w>r|xJ^`2<=x$cTc zCqd;}b%NuRmE$AnM2d&-FSFw4O1r+d0P;c?Oi9$^C)^Fm=j9?djeh}@p425N>Q=|r z=ECs#ypK+XN{W6EM{#R&N>nPbGBlbbmg2z3;fcc1R^|TGscVboQb}CuDJhFPHya1h zVAipV5VKUOG`3o)Md#!#a72BIMbl0pn$@MtK@!UekWVf}bblKH&3T-+LwaP@tElBZ zQp#p}0z`ozlNnl=6U;2393Mqy$$#G)U8#8>^x>P3>d~!R9w?2hV-0XRa@9jt4M__O zkqS>ep!|4Y4424&e&>q5Q&3MX5~A)>5JPFsaxvphp1>)Au&pK&<3#7fOJR{c9IouN zB*~PAIoxz0+aNcsMPYi+X<&$Ty2qw?``a&JEf3rIpuZr(;X~nelTwYS^*{Ze{m*{> zum81nZEgFWb$8zG-5qRl<1b5z8(b+LELD&L#?6edXRRg5!+@0osdrR0xUwi!#NREk zYN}h`^`ZWQ?~{gaWo}hVYEs4jaM;aP4_?+fTA~Zhsr#SJj4H5Ob)rWu! z1%Cy1Xp?ecysO$?)8v7rwr!9r5f`La?6`Buv?l20a3D<22PG-|bOupuh9M$0m?bw= zb4u;*#>TbF7iuX&+OnJ~duO}dB~1XvpgNy20gbOhl*S|=bUBI#1Ny*>1I@ezRJ5}? z&>Av5~_WnD$hOt-v97F z`j0>PnNM4e{PxxsFsgxx@^uwjJd+Mb0bie%Bq85JQy;9RqtjaiIz3nigw%LbxRF)a zmAaSe&F}uy`A>hc-(1|{UYEIbHFe<&f7<@rf7|r>zMj`=YB-rLNsF}PY}%%kahXFT zHAT4%(s-^y3DZ_Xsp46Yaa&~ocR;1pD6}3LsBBsV(#EOfq}_9F5;}ILCc6ag>5z{T z5|2Ve4~h`}o78>WgC=;3P&pa_(nB4$CI`pm@E?lzj}GXiKwX(ecQ`~RQsMbAQT8vn zTns?Ml(?7#Y7c$6Tn1QztM$a85mRjEf}lUlAKxY$OqskkK{z+f;!bMrz3Z8hmy!}? z+RS?K?ww5WhOEKo}uIN5pF z-Q6+hh%xV)Qn!6hyjYrAUsQKOY4W0xk;HqRATw1iqVo&q6H#X{%z%t(niIF-4erxu z0-FQqfCpBi@*NsZP6#RS$eLHi%KcQ3eeijZPr9%2a9G9wD`+Bb-7fU z8eG%Rq)G6+*LI}5u9youSF#lj2nz-XoT$n zA*CaZAwoY1$2^aa*sQ#$PR0>D_2dc+py5d$ppHG71BcM4$X(_}L+MSc8x&z@z%F<^ z051!S2=r6X$k>z_qVy(%K5yr`^M2SAr1qh0)hUJ)b=~S+8&j5EiPyH$=Ju7RI&R&- z+}qF{3zp<&k>NLM=<>kDBd|nq+N0$RUTlI>nZt!(e3Hzu1TlG7YM3DhmKDsE>RdFX zFD5A^wE?hL0kfRMCrqJZydVPLB-z`o|$T1rI zLFzaU_IU+QfK!+}cIE2d`}_akx#!+vsNLIl?%cX_=lYGC*09rCA!}cX71vh3rZ}xp zp9p$?c&jw|qtG|F;?1Z78yEuU24H%!6q3G4_2wtOtA6T}dkw2&xSGC*)QvBE@ri%= zZ(r|ZU71SP4QW4!34@p4tE(MIyoVSu11V-#A3|hju9eu zV<_Vx)RnkEk=GiruIZvqt1Qz0eZN8>oXC`Cs0D=WbGtm~meDBIjklqk-ed49d{lt^ zO=H1?u?yg=k%}x@t=09-)Ctq=s({gjtq)KyA@!RR;hdAEl^WdE$wZ$E%a}WdCn8u6)ttc8AIcrS`qohkzuC!^b12Q!>pKsi}s~K zwg}&&mWq{acc2xx=c>03?<{JZ2C#2x6?@9u^r1xl)TzstFBflBfYoX8P4w`p9PDn7^Kz#_Xt^v$)mU zwArf-8)hnXumeOS`?*1xKxp*1xpT^`m;0lko)Ed0$tc`UL=7dsI<2Pm=7r1K?Pk%O zOI_REI?XlJg435=a0!VSCVe|z(1Z{IRCPjHeTu~6vnAhgI|;)0hqD7PuDAyrov5%3 zt~?=O4^_1<#flFd8Pwglano|?R*C-J7hZtL<*$jR(9z+>C3fh9>!>={=m(W`3Vk{E z`stBn7E9*`B7)|5HJxB6X+RO~S5wZTPoBO7k&> z(ry%f{L9}wU+H3{g+()S(`;_EOAGLNynE5urghChi>0Y-4|-#z_5hARalhO)QyP_T z>u@$sqn2YF25cPKf4LaOU@_Pc|LC^6B&B&eGl+$G>gG~KvFOt*O@uMMIKV;rrbHL(X@?4YtEcGvw7;2UCD&L5*|tS$o{CV@ugD6Blfx1fW?T@D2ReV&)@`+j)q<> z6)Zr;zDK0B4E5!1SY(-ct~X6%9|N6xCIXpp=FbDkht=o(Glt=k;~E`S=Ml(@^!ZyW zCnVeIjKNr%)qF0sxAMNfZ(-M_=-0Qi}{UBXG24Z;4*bI)D4bm`XZ+vb}0T`#q2 z9jQ6RJrd_G?F3oX3FHj_73~_TgPsxM1VbDY2`W@lQupv{-xpFEYQVYQY;XS1kLdYx z_HenrW^Q|BXTrI4>HHnH#rqiDW;U0 zJp9Ul0bH}+sg1EuozlTrWrdNPq<%!8=$Qi@zF7t{3o#cN81YraCSjs`4>^a0?hKje0DS+50$!~ z3Gg^g&XyTEy?M&oEGKgBN(I6kUI^S2$jqgN-p&b>4emE(-!v#XnGf18iBg`TWaEUv zYC1y**}(gg2>{h6i92oi;7AxLY{Y}<^S4Fa>YG7J@IzSE4=BL+T)cGYCx7~<3lhk4 z*ea0WRr(^iZ4rWWaL!2XB{cFQDkTEifs*L>6iuKU_UdAHl-mWbZP5gjU1G9M7-V!0Rh zNwZ*r`iL2ym;+p8()aznfy{RgCsw=`3n)3%0`xuXI+E#1i%Ya(n+eP!8iN_?JEFbR zp0xK@q+Rl&(#6>`=h0=Eh~SQ3S?Cd$ z0}rB0%!l|kQ>kczaG-h^9HRSZb7mpgSZ-8IA|+odCI)7p>b{I%tp%Y&f3q4*+agFA zGRMV-%#Cr;irQ$rII4nx6nzkj_WrXA7viYaf1t5cIcfSaw)eS?e7}B!jLj4f3#3xl zm%Lb>Ie+Qj{}2D84}JJU#`NkGvH~Hn)E@-;YEU4DxnaE=G zY^5(u-1T*}I}ohaQkuo0>-&jEg8)azhXN=M#6_SX3`YThpNzRXYy+C0RqDuIE|q-- z1w0L3*;l8rSc7Jw0`Z38QS3d%vyTsA&Q){pXyRT8g$qb0#1~MS`|gg?l1QNzU*v-x z&g-qyR14m4vxdnGH2_@zNC5kBeA#B^_s! z(gPT8ZGEK*0viSzv6s1xB3P>k4sjZ49Iz6;^o^HP^!Dv7SKg9X*EfcW#@AkZ?T`NO z57w58f|9>9DKFAA?<*bANP^A}gh39^Ve(}1Xk=go4Zb-9PG@wq>2N_#!v5UYBx;)0 zt4%P?X4IDvqM1$FX}!c2f{fG5eN>GP9TN!iIaYlnnc_X8WzN2!?BqT@m^wdZoG5(X zfy;5+d+UQcQ=vN^SP~yCSQQR0?njIRg3gP;qiw8PW9u`EcA=y|dsZ1&@W81P5muVe zNtk>6{6zV@-Aq3%rM86TY(((9_(_^-)y8o>p zlpd&gK@elbpcwIGkByN$tmDnh_qEkDXf|+j!iT6;DQ9D1|Jl#|)sKDjW9G=-+gs&k z(RDom95e+e(FQXbTOH{0fUUX&E3>joY7+2B%$gF}U~V#Hz5B5b^J5pTE%Gk1mR()$ zbdUYoZ>Cq@IJ3Rmil7gAVj^ey@2vf~cP|@iEgYX&tj}8kq;6nN??*m#AGQbQv9A@_ zt01x%N3Fi12`VA{C4F(!6LdDRrfu5gjWMo)aXW%E zE#c85V}xL49Wc#WBBeCVaGgle$B+O>-C;f_zbYv=fkKMqei}?ur%`kz_iDpzt!vgz zS1%S)#jZpd&S(#dIVCn_KVbYFxuCVq=)S}Re?~#_=-;*n7#`hVU9%+4-maV*KN*F& zWv-GhtZ(YgH?C~o+_<;BcIsTeT<*49v@&ViE>(zA1`%FgIy84JRS?t*v(mFgL};=; zhu#iDhd-Kg6^Zt1;_ndEB!0y!I#Hq8-sawo8#i8m^>xDxb{?t;iq)Lb?(P7F=c)Tt zl%6wWZeEZ7?`w#zs>1)75NAF4uU zCG>~$=xN%}zmvkp%A0!eToR+Mw6(55w$r(Q+h<%XMW)ak9AcSWK1O?VkFJBV2}at! z<~|2SXJg7Z$&>{QXUHe|Q5sS8Z8@p*7DF`f&Gn#&4}J6wfQO&On=>9ln9$&W9I$3F zc4LhBfgkt*(~%B&5|l95K%&t$sOGl+M?YhKV~*^+*8$l=FEW$1X-xq%_AKSZNx0F} zF!Pej8tb694hw49-MdCv*G=LOprOp;v%YOn(mV^ zME6fy)$lhc$jcJDoai2~&c-oOAKykM3v$RL2M6txBdNtzT5tQqP)Q?$I}=Fcaf&Ly z00ky{N<6OI%6(r{D07l3p32zU+cCL!cWdaYXSUUj8(4mBO#n|oygu-E<1O7ZjmP1K zY{&>f=d|8h@z*-%#>3%7sB+Gd8llC_raASVr%&Iw@!Xfca_%4hKhFNvKfknh%jVSD za-({pqe`DjFVYEB1T}zWi!y0dno*TdRL|lGB>p^!zRb;nIjhflyalON7x4{PE$#ag zkr(pq7TAFPee6^iRh)=eYSNte2@3a6_}qX6ghvt=U#4aDJ4;JpwTS4!k@3su6~r$8 zPHJ;HdK}i}{u6^|`$y{Xob#e>*@4QCzU#rjtI_U*c+^ic`dx`#ohL>y5K`q+7wJLf zFboaZpGBS*(gfZ698}^*F{Dnjz4`Tyd7 z>BArWsFj#kuWK^QBg(y6N1wx!acG&Xxoe(xTTHQ4Xzj?OBm%D%jDjgULb4)V^-5J) zB~vAqy{i}cANl^e-h5L_Va};t>*>O8{T|=A^*&v;X|X|UrsO8ks1|FjgNF4VI4+s2ux_xAs zw?IkW-45K@HJ z*hY%D=8QCFS}p^f`0bXd)GuWIu@8Iaz70k7@1pSi#*rF5#@rH^OUyhhXGkSZ3tb7$ ziWD&so#J~@+&M}PzJ}!DQ}bxwTtyE)Rt-<6#^Gt5!b^M{E^a3W0UfQOAN-_pdKm^+i`w_mb8{zVq>qe{(&(A*-FljilvHfBDybZT*#3 z&uSK-+O`8;$M{uK)2{mN&ek1cj7Md&uf$ae3RP0hZg^Npx-~c7Tv}pwusJqt$Ku1r zy$;$F$Vf0A(lk?rG0(@(NYFOjOXg9d91CMdWo4 z%xz~2_O->+A7GMEm4yQ=nX_NoBGNb7o!;Jl&pOT-72Ho>QAACfEJUp%Ep(6-4SKP9}7Y@w?eva^rQ8auyw?@t(`>ps*KKnbpM|(_wl#JfG^E9Cb={-K$eSG)CDevc;KkSgF6FYq0&rQLi$ti_R z8$(56%AF*kk}-~i#B1!Ql!A{hGLX~XjL;Ue2%`}%y;B9cClqQ}+5ry7SC4wiI0$Ds z#vvh|NvKj6=+S-hAQAS6h~%7Y@lGiXB`Xf%9oID`6&ds2LD}kpLSAq%@dUI%*ejMx ztS{IcX4MEwv$zE@Q|yXW3m6>6;77&&H8S za}7BOc+V*ngj1#VrCzvn`LF-Yzx8*1;TP66Pu;$Iw{d_^glh2T5LyKH7IMvHV)+gw zh2KD)5_coK3REHB%H+IcTISlgv2d64Pe1U&orYfS`@+2FOTN2%_Sb)_y>|1g(kWGK z8p)X*y_IRu9|I5F5D52HDVPog?R-SwPJ40rKs9OtE)kx30?g@zo19y`!bw|gi^}+@ zV&GY53vbf*#ROjs$`6a-5rpW6p#&~i$09z3%XV-awICx^4*)>d_d%^Vg7;JdmZLGb z=joyF(GO6;tGYj4NGjQmZG+|=vC&x`qZaBAxg_8 z)5vGeimoox`Ax*FTOLpom;*#KYa}sJ^CRMd&rkwEC0}f#lo=I$m;4Sei9fPtQO`$6Z`Qtdfy{YF(W(K3ypCiKMuOlzKpL(Glsx zVu8sWWwJ~Zr8u)0HJ(wZ-vCJ#nYE40K~HwwuJc>k(fUrg{OiB7di~m^Rlk;e9<}~^waUFgwyk-U zL5ticEch6)qUrwVjE-&H19>#@gC`q|I|)XrF(@=m!-<34o$-|?-cTs-!85G|X<&`N zH#4@5kQttR20e8-uza6LIS`8@B-YgXWL83lQ=pFLyv?&<0!h`1p57(;A>dU+in|_v z+IB3eY^F~gUM!{w5r>C@G(pnEj(PvY4h02~VGz;2FPJk^3uXf0E3ou7qOXe7E-RM- zqtgi~Nny_0dHK@0$G-N-@BZ==@BXtV-}{XhKlZi99@n(2UDs%(L2=ef%83|EN2LxOC+wijQ55pwT3Fm- z&hq(i8dp_g!Sp=^ay^O?zYV$b2jnX~#7#X%y^T5#%IDB8e&=;m!_7UaWnUJj6pvuP z8MuWPXmT7{KL$#;V}Jl729lRCaOy%*PV+H87{o4f2|({WFQcSmQat4dtq=C>`ns)> zBU&n@!z2v0i9DnIM5q!YWR8TJADvMQ9js)CMe=IOJT zluQezrq(({>MawwyWMwt-XX=BAFJ9e%hM#RwW#>zg z?R&$I#gq9sX5G{!QC8D0TS z1ynVn%Xmmcuuy~AHc%De=6K`(eE!0PL8&hmDCz1<+_g6tTq))8#~**@*=J0tZ)|Sl zrm3PTyb^ z_JrSZVQUNOA^;?5n>KNZ0G&OwSI)&($(h)J`M?V>eE)u~Jmf%hJs=44AR!0#wG_0w zPL5Z{j|noD4x4IV$@&1VOa$j_jH(<*!4-NaLK6~wnx{Z|bl!`q#S=p62Oh=ahtbLr zJE2FD_^t=XaZT0}Qgjfhz%F4_6`dPx$9zI(Tu+9%y>Rj3FZ|*!+T`0EGAKRe#KXv< zSnQ)*Um}Jfwc-O*6Q2gScF{BKG|HFh5P5Pqg039EQl4Q;5bwqdss6(gHaQ(J(oP=G6K4w&H0Lg(wNc z%l8CYT!hrej4u`*A&Dkt81p$Nt57rV(}E<{7u0mFDe}_wQVXfJIW2N(5+^85H?C+( z&4givlZWQD(eaZ_2nB*7dzDtIJ@0m_%BfHi&brnLcO+esRO$3r&OUi_^Xk27FblfZ zq!mlwa>=|h&dt@-^Ndv` zTCoIRC>_8AsY_swAm0ky)`4nVC035?LEJlm#)ckCDc_e*D^l|BRP=f1VQ6UkF%`J6 zzF~nZGwz;z^2w`LuG)mKC$MNn6o`or`^+(rl8a#vXUZKdB8HJu>%;bQ3{JMi5x15g zJdRm=J#r1=6&j_l-fsh_V((DZA~Y8Xq{#Rp$vR5!qg4BuYjwGwC^i}jJy;Y>=Bcr)0@)hJaznyW%1E_sJywTK;k?VeYFd;mmb15HayjbpOf)=Dd#Gx zDSiI0{BdY`*KJr8yL+D4F1`6!78o~# zuWDtKEH<@SP-<>}_=DXGFVsbQcUXie6J7cz|02D5EHBH?O zdkT7%31Mfl!Z3wymFV}jceb~8%y)FK@$hj5CLEu2DjLSHszwrYOqzNI0gFuQl5)mE zG$FKYC_ME2k!`G5`vc~0X;VaKf;kNTp;-ZyCS`$CF#+kEV&Wy6uOOB zK}1?gM^c%nY4XCH(YD!GTRwL2;uBY|UO0Eod|0j36dsKwa)I9Bi9D6DO7K*!0Mnt^ zbg@xNSEh0>Fr?;;+^QxnNu(jlN=Yl#^->q5HYsb)Raq!0HN*{5vJv%8Q0PtDfT17A ztCShh(CkSfOef!t;dgOCK!TX9^Xb*cAGZ)i+cx+(q5{@7>!oIE_|xxt*LQvFW2Vu~y(ba>#JSGVA}c2INOwGNWx;mxX2d)12Ut56cINv}Wm#MYCKy}Z%fOxmaB^r~F__1{U? z?>r@RMu|ph0-t^&f>?KFvbXAc+t{|^^MK-O@}ltf!|ba*!3r4RRciFM01lv*itIa< zo#8>(qvsWF6FbeS>^WudgN;jHKr9n8<`b(#@Ca#As7qM0qYj=?e!)Dpy&04NqG23x z;(aR;o(fhusdG`_`?}cg!>e+XIYoUx~P#ip()) z;UFDg!oX$#ne0omh3biy!~y>ooY*rTWhB1gQ2w-!qdSx9e5MfAQIY##TmXDTj3DgB zeHk<|(B-l6A_6!PdHRuP-xA7nKH@bldeY#Nz*Bk*pmq{m(4`6C@h#x4Ld9FqP^ym`KWbV;wM})WhR;5r99DUpJY+ zYXNYOX~M$vnh3M_e$CLB<4#NM1g~Oda4;cc$Dsm4mrsn@JijjUh69R4RbvmYWS7vs z6Kp%-#Nu<#)+Rby<^c9-U_FIAm`6TF39$1dM-;xMc7SgI(q!tyRwF{HNTpp^7?(G^c zZ0!p)BYMOEGc{Pxp0?lFT?q=>bEBG68No07Ir22qWWYj^*O8w`@q)^%tTQ4QP6vCa zOfw`PYZzF^c)x>z9UB%W)wG11jB2E^RL=ZqWN2e)TrUu&lj@E$VGgihP#GL%sU$7 zMhuzuX;vPF)MkQrzUK2akMPkkO+C@>D^XRYoTQ{`$8B1lKeu-A;-$o?)S;-6iAyOv zy93?j=EkXhkQJ6Zx1%}WWt?)0_9VUpH%+EVU^@ntJsgi&E<2&{&F<&6-6>_IBJte- z5dwF_k%Xd&r;tUI^XzZg3ly|Zzk{>UCDgxiazUFy5yVLk;Cp$WWxzi4O`|s^vV2A) zmFLRUKTFcw(8)!aSUp4Z5n`{SJ0iUdOQ404i73=<(;!GQ`im(u<{Uc8jI`tw9A&6`_dV?Zf+V=)=3L-*FM}S*U zkyENFncGtONJF4t4C#`gNWyBv`VFvnw-qnwW|O^bs{kRQ%;I9GEO@j5!oqTj!h{k(P`JDlk4 z7iAJY8HaCU?(U}8cbT{JiR`P_Hpx3#n}>h|plRFa#1|x#w&j#ZLg}i^sWrdKh|y1< zvgSNjEQNmc%7qITH#awPlRf$}(dNqV(`0M;ylH5rr{49{3-5j510VRnyWjoX^Upv3 zp7*@RQt;=`pF4GG(_*kDX5qrU#s?ZY`faRp&M^X)2U9u%??|S`Lx9~TE`w1~mRdWc zFl{>O4ngAp8>npQv69I4#&b%vG}C zs3Ipn=~hPDRZ8Esd2Ma@aye(f=WI56_{v06!bxxjS(DsEtE!Wy5JV2*=6D1gK=59S z!x*uTabz3G5F$RZ!{lrkO7mxFzv#5OB9g&6BIB6Uo!hDtcbZDnnfJCoWIhIN(*c_R zZk6lTuHC$TrMdE@ohb57oG&7~F<1?teb2NFJZ?^0_;_f@otgDTEbY>-{BI87m8 zR?%S%r8I`7d{>BNS{C3m+YgqH@$1mM;GU+k83_gyL=`*ll829E2Vf?OQs)qprfr=g zfsIS&si&Sgf9^bxKik{G4QP7(=FOXSquHvfs`e%xRz%7}LucQ&ZZ))cI5C1*Efn(Y zMYf;dyc}FPbp$C4f^M}G_hcOO3;I6!Uga z=Iz3bQAk3da{SX!PQgf#t3PVo@y)gGw06?pdh+U5KmCa_DtEfR?dhrC|Klrn_MYfy zJuQ|gE&85PO6>wQ%wqyPiXzn0=aHyTtjn_=B>o^`$PwZm^Z8+9cB>)O-ghg~x@fa` zRA)|a+SXn&SUq+^ssL@Ua#dCOf-W3V?kabQeMnzc(z- zC`;M@)ExUQGhb3}HqV}Ujw7%nN2{EgiyRFbID!l_m>0?yv#qjj0VHk&X!|y*285mhFU4BNqfg$HGXRK|4f8 z{=wN_#FTuvX3zYH3;OYBRjg~_!8Iroo0^EV?U3Zg7-S9Zv!P5j4byb~`~}mw=gytC z1I+*xsqS^z&9l228bS&z>{&{MeN%mo8m8d*+;FOI2vk=F?C$are%hJN6r; zR8GmXySeX=Kk>w~&pr42d*5s0JcQhA}9|YP%*(>D+gtNcbo*LDb)2`1S1~Jhe$NzL4EL?Qu`5%Ei4)_9!L~2dz&}a zBxS$iJh_!0^L+W9r#}ccKXl9inwLnN1SX)GxazjTt#>{B^ml*uv!)$$)6DMhBN!i| zswcb5>lnoa*F1t2ph-(wa}rJBb?8k_oax@#%^RQoNZ;zKs=U%Ct>@`WuU+c&v?lKR zPD+;?(PcU`WlE08L&ejanIGAMNkh)+{0{c?*BJ29yia*=y4==hl?oM)(ku%a-@I}C z`n5N1-Mndc7<3@YHKInSjM-D2v}2w-zmed~DaCb}x&Ti4L25MEJq%Zx9B97ZP~!b< z01r}1%!wjrWsS)9-sJSdgv~dSv)9DM2vkT<(X#Z;0-h_ z5m{X5<(FTUT2ZiyXi7BWNjZtg)Zfk|iVMd5fVIL-I6(MK6O3!bw2CI;>izHVt+9|m z$0M>3^tI71PN(%`% z4?sJP&X<{a|IoPb#B^*KI?v^J{)gkA6_@*)Oo1hgKJuAI!Q;l^OT*UGq!VSePW#f} zDbt{vrrIswzIn=aOxK&rcb9qLjQ`s8V=P-$?FARDIOOripLp_#$FDwav+A5X->Qlt z+}nn&ymi~mMigLxL(L-j&%XP)@A~-1Kk&g1nwqy^90=zwTrkJoYA_5eO~j>CFX(7N zd~IqSaro-aj)>s2g8lhLRp1EcUZ(Pghh`v{ zyGSATX{suE+Q51T>QB4rbm zh5OaH?pNm~p^;p8))s+|my=5`YS_&VQv(%D!I)aGbfxbGD)O$ETCJpZ)6SRmCpG`! z&K)~7B7%8tL5^FuZrm6q5@Z3imO3gBQNrhT0fQk_*BG^uiU<&}y7+`dj7vE@oUqnV?!6~#ti&8_Gq#Ue z0G;>8Oe{pd$6@b2_Pt*V-jZU&8#cB>8-8=sS19&E*+1MAJWAM_3(s3|yxQCyO% zYK6V|b_$b*3YVy$z+;^+xT=9W`3?|I_PFGrqQcfB?0T2Lt{m<)Oli>dGa6P*F(LwH zvlH_zI;1o4PPxhJYv$;mN@+|Z*?e-ggI-kz+-bM1q~^iHR5X8lC~(hN&!3kfwrnBS zWn`Mnyy}LZl(V-q9-g7xSU|y;IcgPD`ug z{K4v?5Z1AVo|QQPS3K{~7cwZ3sgw z*SPYRzw(|x`ZBNR@!kF|HEk`FH7^=XO=Vs4+(}oZdNFXKNyKGtm(Te$jsghjFgVZ{ zF%qM$Oh{SSbGVJ`=4QF3Ug*ISO9MraHgs?;tQEi=DMdWfO3`8Skf;iUNaBo@d7Ms1 za|Dq-XuTuxTRxFgr=|$3J{JG1d@FrZCeudR`1M6Y-I;XBE}$6t%T&c=bp=) z%($twS`5QVjm>etcI^#={d+VEfu$3!TlDrBU&@DHfUJVf`U#-U`<*9xC<+lhPx1eE zilj*b!GUe^ZJ>_!k(p?kmN1Sj&x-dFGZNlIklx^OHeXJiMn9`6wRe#!wjKKAJLjUk z&YX1%%A1@u*ZchWQ)dRZUx@~|N7voCJK&~n-x(SetJ3hEr!60J_UWgedFGkto_*%s zmUq80aN3-)7F8CH2cyEoIHq2FIT9`e90~FO)+gOBGoGMDKoB!~azx?-p z=?{P4Gk>b}#x8&A_x`-@>e*FKN~NrJd&A}3F&EBaEz2r^-?ggH4*T_@Qp#!Gk&hmx z$&vnCV|bOQ0WS`bGP+E3ldpc;+0okF{O3S@Ri%B!W!4= zDiwv}B4YF@Hf*s1&nr%~EjF;iok(Ei$E9}(n<=><1mboD`4Y)Z%FWbqoL!>rP4Q@W zsWp;8fM+`TxWOFf3EP2ZNhvef7!V&0f*bc^BU%9P{FGPfOeTVN-|bewVr<_tu~4dk zk)M3(Nmuh!`s$^>DG%Er?kb`W*fb9#C<&AfG$fPpGGWKD!->A_!Y3B(M2a)w>E9WG zFxcUNXdgj~Gh=7}y~-Ha2O=oK*qHMk1FOzkR8auj+HmBtPtl>AJ*C`Nxq0jM?K{JQ zX)m^y5VOV7FB+!qvBwMyZ(9EBIiojf5iGrV%Rs5u&HT2dYHI*P-?idgBg}I)KE!u@*C)DuAZ~*{J@r6?rW_euOnAoI1c6>Z2*)3z~{pP zom`Gt4H!dx%#UkWFVUaOVVtWytDp8b6UyyI87Sp;2g=yHF5aG|o7&IRdA21nr(=Wd z2Z5e?qP|UUQjzQZ$7G+SDb=3#4aLQSm4nk#0WuxEU!=AX7jry8mzXUJXlY?mMcJsb zYZVncMGn!}$vG{WreCd8oanR^VCaE`LVyhdEgsAz8F@#)<)imp0wx-Gj69O;fDsUD zBa$!3Wnz-deDGAOc0ceI*ih?HoYyXRz++a z59W0_C)gTuBQsE$=lU^Jg?t3XkHmIgUQ&+0#A(1q{gWk3ciKN7u@gxC`%`H$w)fS> z2N~iNBd~=rBFA%p%_Cvsawt-N^f-Bzzcq5;kH*s3FoC_qx6W=!loPki4W~RWMkl7Z zF@^{86xwu0vJWa{%21E@0F29#z%YAf$fjAOrold?WG;o(lH7CpYRjWvzjo80a#A&? zeDT61!^|6C-oW$EzxVm8k6+=$MT#wNmj1CG3kK}8O3GE=Rjp0injLWN{5cB=aAH&Q zKIMtsNSWe@q8fx153J9R&35C?Qq?l0?PH3Z2m_AgY<8Rvyz=c+&mwX}U+M>yx$~q` z7%=Xd2h!+R!xMQZNZBA6&ph{@l-nXI_&6#1vX;7hG`9`KbE3q#A%8&k?t~^s@DDolYZch_sa4hzy;^Ln zmqYind3Q2O!_X;^g(VZ077HhjcX)~vsfAS%i`L$j1UoGT>B(&~S_9zd)QUG*dD9U?`7&wg zyCx??-@x%j>K(e=ncWm8EN)d!BO4OJF!(+Z_D7x=aB&dqj|p}7*yGI>uNU%XW1+># zjd_DyZ*+2ks>2rtig0bYFc5p&WB@WIcAWwR>sl>#^RpM;Lktw%=n3HXVnx>t&Vpw%wC-`}9=-?vTZ(X#70*4vG%+Wv~c;A?O zpVPz2)Gra=@qU1hX#hr=v+c zz1ZK5C`vMif6>MOa8RB2chl4wQmT@;iJ-jeI+}$0uGmi7uBAjaeGPtRH>x4<(DM}a z?uG<1y>8mwd=<3kv-(~0TG}D!xI_aGrsxYGN(yca#dKlpaKISDpF2j?@mL7Z<|tj7 zqMD51f)g@Z3S*C<%2WjxEAry8md>c?@X6`;PX7nsZ%lmuhW&)M!)_2ngoG)#|A@}8 zog;PjGI!s+8N*HsC3=O?)_1E@dXE zm141()|)CL;@1QkLLoEAf9Z(i^cTMPZ$A0G*Rv?6&B`zSH~)LTzrFpuYGoCZSazjq z=?dm*#MM~^Rm*7A=E#reW2UusDgxRvV$kI9M4?Q{bFMsn>=`PKro{O~6^9%o=|tj2 zARTLHM7H~#qIGKGmvS=^A|d@w5PwY-(YWs>8|)wl2dOYCXdJL=@I+uR^{OEZT)XIA zs5VIBO*zHnfu)unsQg_cNWs{_V4ib{OG>kD`YK+Y$bK%Q&0I^_TwB}RG+myBbQh=^ zk=!&WB0#&uTE(1Hqrkvoq*`-Mo`hcHlsb=mlu|6IG5NzaC61`uqTiWaBHdH!t)M-RBLJ4h7(QI(FAs3zuMZi zjYx$?PiZuUP=X8h7&UcPqSWLCDS4IeKp$c@-#5PbO>3!ERLiQ@#Gq2ntbx5npKFvs z1mzXaWDc8!(%ZKa+@p^WK@3{-lOz;xFkzs>3Vclp;hDRo7{`E+-?6PuBdCyEIJQtP zA+Bel%7ieK#Aoe+g1uG({2k51I*GWgn__cSNL9>K`5ItTCR;+9}Ewsl0hwE zp`th5xOV-)YM7k@mnsgsQMGIKWrk=!Ibp;bxwV29}DjL*v_nTl*awI_sGP4{Y zqs@UaDR0Ftwr`e!i1@+Ua$sPeHO7J5c}mHyqm@GRUEky!m<}F8j2sLA@Pp* zR=~Xr)qY4$O6gTfBFfBD=7w@kBfDE;gBOFh++aF~jq7qK_^~gjaKr_ji+hZnS0;77 z1CCf>N{RAhAZAXDkKn*hwnLniPrkx)#d;Joj2_^5#dexd7zg8yim2=TM+A6c{Y>e= zATS98A-(v5LQ>(Zx*1(i+HEJlN{U)`EMX{5)ryEBk}@zmeQB#T@qZm;Hw#1Q)JFewu32-1&FJ_|EvCY zF}reZXusrWz2l3|{>)PCCz;hj=xV4F9?~;+wzdr0PsAVm;D>(f$A0{ygM9dzcR!1w zp_H@J(JH4*%9HyOAvFYY=4ELIeT)On4_4GfZ?}Y&hUUVE^&FuG`ime8NsK)>NwZak z56FEYy{tZ_j+7(KFfO@mr#J*m&Y5T6GSEB>X(XKr#1nIBn;}>Ta7|7P1j{%xgAxIO zR?OYq-62_i=k}dz*RQ|+`s=T~_WG-@zGmrn=42>MLwR`Fx|LZzZ=esWpc^K-Qg&3p zn9kuTDuo!Ddn&<<`hW$2Ad7&?QF4qatl*GPdk~tB*o#1xZS`$6<0t_3-$r3Q#u^6y zwp~Fcwsi-fOy(4%U=aa@^ii;YCr3J(A|`%Kv9`tx+#7PwJrNQ>JtdWV<^S_9^8es} zwfGE~VdB-F=JMH^Y}{UVcXqc8Va`kM2=5B@+1cd$_9ZlFSfzH2mX62)=x|u>r0E|nSx&*WQl%j0c1l`d>&J^ z#Ymh1GvIG3l4zs|X7ZL!ivr@)|^ZNEvL2A&Z!tn59t7ovr0B|j|}r~m`Vdz_N9CA#TWj)fA3d*`ImnA z@BjV3_lv*q3kF1O+Sa(gM8wSuv<8i;%9-1CC|DT#@0fn)(E}AU*dFhCs2+deyu2fX zXNBe*sERyq96rc{`-&>0A#uabLCBbvvw_FsZPE{~Vr7-Fw-W|FD7;>i2qa)T@Nnja zDWRh|b1J18_mkDF+w3&r#+P4u<;IO0hWH>Nqq{Mnd|Z>1GHMQSS=1zQgp=MqUY*a6 za2kat^u}CS!cf8{;vxG+01;;ErtQsKO+5A1H0J+~ket(Ev3TmqrvQ2oRh%Fode9Nl zo0jbbdN(v3*jv$IbfS=pMN-kuZYqh!^>M5aZS2)6TdPmsxcA{5ePX3j>u%o_sl0NM zZ!{XhmBd=>RzznT+n>}qE^mUMCU`d7Tc3gcj;j6&nW5)md5=(KbRBv(Cq(q`{%*7!QuYeW(ES}2fn}I`ox*kwh2vtS1ZGP zY}xd+ww#HREq)G-jvP;fZOMm*Z*-z}jwKgKV@Bl8MGn4lAEM9_g+> zgsJKxy`Pa<3-aIVYfI7!%pm&g8@?TMSEjb{*&WE%lu`{K1~djKfnvo;sD?s6C#AVJ zG&kQ{*+DcUB~@RS5>2ZoK7XwFG38)`NMG%B#kX_m!`Fc>o^m?q0fh@pGU5{L@cA pZ9F^=w^D$@J^Z?$%l!WX$rN;3tJIp^00000NkvXXu0mjf0{~h7-R1xQ literal 0 HcmV?d00001 diff --git a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md new file mode 100644 index 00000000000..8a1d6a55a94 --- /dev/null +++ b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md @@ -0,0 +1,44 @@ +# human-pose-estimation-0004 + +## Use Case and High-Level Description + +This is a multi-person 2D pose estimation network based on the EfficientHRNet approach. +For every person in an image, the network detects a human pose: a body skeleton consisting of keypoints and connections between them. +The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wrists, hips, knees, and ankles. + +## Example + +![](./human-pose-estimation-0004.png) + +## Specification + +| Metric | Value | +|---------------------------------|-------------------------------------------| +| Average Precision (AP) | 52.9% | +| GFlops | 14.3707 | +| MParams | 8.1504 | +| Source framework | PyTorch* | + +Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). + +## Performance + +## Inputs + +Name: `input`, shape: [1x3x448x448]. An input image in the [BxCxHxW] format , +where: + - B - batch size + - C - number of channels + - H - image height + - W - image width +Expected color order is BGR. + +## Outputs + +The net outputs three blobs: + * "heatmaps" of shape [N, 17, 224, 224] containing location heatmaps for keypoints of all types. + * "nms_heatmaps" of shape [N, 17, 224, 224] containing heatmaps after non-maximum suppression. + * "embeddings" of shape [N, 17, 224, 224, 1] containing associative embedding values, which are used for grouping individual keypoints into poses. + +## Legal Information +[*] Other names and brands may be claimed as the property of others. diff --git a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.png b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.png new file mode 100644 index 0000000000000000000000000000000000000000..d3cfc55c673c69d79850a524183485ffe9a459d9 GIT binary patch literal 297280 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

a8_x^k7=NY?`oJXvkbR_oIco!3sOnjBXAghMdC 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 literal 0 HcmV?d00001 diff --git a/models/intel/index.md b/models/intel/index.md index eb9c45230e2..76376ab0a8d 100644 --- a/models/intel/index.md +++ b/models/intel/index.md @@ -157,7 +157,10 @@ instances, thus faster than previous, because network runs once. | Model Name | Complexity (GFLOPs) | Size (Mp) | |----------------------------------------------------------------------------------------------------------------------------|--------------------- |---------------- | -| [human-pose-estimation-0001](./human-pose-estimation-0001/description/human-pose-estimation-0001.md) | 15.435 | 4.099 | +| [human-pose-estimation-0001](./human-pose-estimation-0001/description/human-pose-estimation-0001.md) | 15.435 | 4.099 | +| [human-pose-estimation-0002](./human-pose-estimation-0002/description/human-pose-estimation-0002.md) | 5.9393 | 8.1504 | +| [human-pose-estimation-0003](./human-pose-estimation-0003/description/human-pose-estimation-0003.md) | 8.8720 | 8.1504 | +| [human-pose-estimation-0004](./human-pose-estimation-0004/description/human-pose-estimation-0004.md) | 14.3707 | 8.1504 | ## Image Processing From 3bd5a5effbcfb9e7119ae93644b3aa2345b576b2 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 30 Oct 2020 19:19:09 +0300 Subject: [PATCH 03/58] fix --- .../human_pose_estimation_demo/model.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 64d119754ed..9c3bac8116f 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -114,8 +114,6 @@ def __init__(self, *args, labels_map=None, keep_aspect_ratio_resize=False, **kwa adjust=True, refine=True, delta=0.0, - unbiased=False, - blur=False, max_num_people=30, nms_kernel=5, tag_per_joint=True, From 1ea05321ab5e9112766d28515b5e3da9ab181c6c Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 13:41:10 +0300 Subject: [PATCH 04/58] fix post-processing --- .../human_pose_estimation_demo/decoder.py | 22 +++---------------- 1 file changed, 3 insertions(+), 19 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py index 377bb270980..ebf6a152329 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py @@ -8,7 +8,6 @@ class AssociativeEmbeddingDecoder: def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, ignore_too_much, tag_threshold, tag_per_joint, nms_kernel, adjust=True, refine=True, delta=0.0): - self.num_joints = num_joints self.max_num_people = max_num_people self.detection_threshold = detection_threshold @@ -122,6 +121,9 @@ def top_k(self, heatmaps, tags): heatmaps = heatmaps.reshape(N, K, -1) ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] val_k = np.take_along_axis(heatmaps, ind, axis=2) + subind = np.argsort(-val_k, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + val_k = np.take_along_axis(val_k, subind, axis=2) tags = tags.reshape(N, K, W * H, -1) if not self.tag_per_joint: @@ -153,24 +155,6 @@ def adjust(self, ans, heatmaps): joint[:2] += np.sign(diff) * .25 return ans - def get_peaks(self, tag, prev_tag, heatmap, mask): - ids = np.where(mask)[0] - if len(ids) == 0: - return [], [], [] - tag = tag[mask] - heatmap = heatmap[mask] - - diff = tag[..., 0].copy() - diff -= prev_tag - np.abs(diff, out=diff) - np.floor(diff + 0.5, out=diff) - K, H, W = heatmap.shape - diff -= heatmap - diff = diff.reshape(K, -1) - idx = diff.argmin(axis=1) - y, x = np.divmod(idx, W) - return ids, y, x - def refine(self, heatmap, tag, keypoints, pose_tag=None): K, H, W = heatmap.shape if len(tag.shape) == 3: From d2553bf810a175daecd125b63dd5837802d504cd Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 13:42:26 +0300 Subject: [PATCH 05/58] fix net reshape --- .../human_pose_estimation_demo/model.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 9c3bac8116f..30d2054402e 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -77,14 +77,14 @@ def inference_completion_callback(self, status, callback_args): self.event.set() def __call__(self, inputs, id, meta): - request = self.empty_requests.popleft() inputs = self.unify_inputs(inputs) inputs, preprocessing_meta = self.preprocess(inputs) + self.reshape_net(inputs) meta.update(preprocessing_meta) + request = self.empty_requests.popleft() request.set_completion_callback(py_callback=self.inference_completion_callback, py_data=(request, id, meta)) self.event.clear() - self.reshape_net(inputs) request.async_infer(inputs=inputs) def await_all(self): @@ -140,14 +140,12 @@ def _resize_image(frame, size, keep_aspect_ratio=False): resized_frame = cv2.resize(frame, size) else: h, w = frame.shape[:2] - # FIXME. scale = max(size[1] / h, size[0] / w) resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) return resized_frame def preprocess(self, inputs): img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size), self.keep_aspect_ratio_resize) - img = img[:self.target_size, :self.target_size, :] meta = {'original_shape': inputs[self.image_blob_name].shape, 'resized_shape': img.shape} img = img.transpose((2, 0, 1)) # Change data layout from HWC to CHW From aa76d7cc116a8e0a2a9aac89d492b338d3823eaf Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 13:48:27 +0300 Subject: [PATCH 06/58] add initial AC support and config --- .../accuracy_checker/adapters/__init__.py | 9 +- .../adapters/pose_estimation.py | 303 +++++++++++++++++- .../configs/human-pose-estimation-0002.yml | 36 +++ 3 files changed, 346 insertions(+), 2 deletions(-) create mode 100644 tools/accuracy_checker/configs/human-pose-estimation-0002.yml diff --git a/tools/accuracy_checker/accuracy_checker/adapters/__init__.py b/tools/accuracy_checker/accuracy_checker/adapters/__init__.py index 69e6c2d06fb..5806ebcc7e0 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/__init__.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/__init__.py @@ -63,7 +63,13 @@ from .yolo import TinyYOLOv1Adapter, YoloV2Adapter, YoloV3Adapter, YoloV3ONNX from .classification import ClassificationAdapter from .segmentation import SegmentationAdapter, BrainTumorSegmentationAdapter, DUCSegmentationAdapter -from .pose_estimation import HumanPoseAdapter, SingleHumanPoseAdapter, StackedHourGlassNetworkAdapter +from .pose_estimation import ( + AssociativeEmbeddingAdapter, + HumanPoseAdapter, + SingleHumanPoseAdapter, + StackedHourGlassNetworkAdapter +) + from .pose_estimation_3d import HumanPose3dAdapter from .hit_ratio import HitRatioAdapter @@ -159,6 +165,7 @@ 'LPRAdapter', 'CTCGreedySearchDecoder', + 'AssociativeEmbeddingAdapter', 'HumanPoseAdapter', 'HumanPose3dAdapter', 'SingleHumanPoseAdapter', diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index aa40c884a4b..fda2493f711 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -19,12 +19,13 @@ import cv2 import numpy as np +from scipy.optimize import linear_sum_assignment from ..adapters import Adapter from ..config import ConfigValidator, StringField, ConfigError from ..preprocessor import ObjectCropWithScale from ..representation import PoseEstimationPrediction -from ..utils import contains_any +from ..utils import contains_all, contains_any class HumanPoseAdapter(Adapter): @@ -370,6 +371,306 @@ def get_poses(subset, candidate): return persons_keypoints_x, persons_keypoints_y, persons_keypoints_v, scores +class AssociativeEmbeddingDecoder: + + def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, + ignore_too_much, tag_threshold, tag_per_joint, + adjust=True, refine=True, delta=0.0): + self.num_joints = num_joints + self.max_num_people = max_num_people + self.detection_threshold = detection_threshold + self.tag_threshold = tag_threshold + self.tag_per_joint = tag_per_joint + self.use_detection_val = use_detection_val + self.ignore_too_much = ignore_too_much + + if self.num_joints == 17: + self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) + else: + self.joint_order = list(np.arange(self.num_joints)) + + self.do_adjust = adjust + self.do_refine = refine + self.delta = delta + + def match(self, tag_k, loc_k, val_k): + return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) + + def _max_match(self, scores): + r, c = linear_sum_assignment(scores) + tmp = np.stack((r, c), axis=1) + return tmp + + def _match_by_tag(self, inp): + tag_k, loc_k, val_k = inp + + embd_size = tag_k.shape[2] + + class Pose: + def __init__(self, num_joints, tag_size=1): + self.num_joints = num_joints + self.tag_size = tag_size + self.pose = np.zeros((num_joints, 2 + 1 + tag_size), dtype=np.float32) + self.pose_tag = np.zeros(tag_size, dtype=np.float32) + self.valid_points_num = 0 + + def add(self, idx, joint, tag): + self.pose[idx] = joint + self.pose_tag = (self.pose_tag * self.valid_points_num) + tag + self.valid_points_num += 1 + self.pose_tag /= self.valid_points_num + + @property + def tag(self): + if self.valid_points_num > 0: + return self.pose_tag + else: + return None + + all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) + + poses = [] + for idx in self.joint_order: + tags = tag_k[idx] + joints = all_joints[idx] + mask = joints[:, 2] > self.detection_threshold + tags = tags[mask] + joints = joints[mask] + + if joints.shape[0] == 0: + continue + + if len(poses) == 0: + for tag, joint in zip(tags, joints): + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joint, tag) + poses.append(pose) + else: + if self.ignore_too_much and len(poses) == self.max_num_people: + continue + poses_tags = np.stack([p.tag for p in poses], axis=0) + + diff = tags[:, None] - poses_tags[None, :] + diff_normed = np.linalg.norm(diff, ord=2, axis=2) + diff_saved = np.copy(diff_normed) + + if self.use_detection_val: + diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] + + num_added = diff.shape[0] + num_grouped = diff.shape[1] + + if num_added > num_grouped: + diff_normed = np.concatenate( + (diff_normed, + np.zeros((num_added, num_added - num_grouped), + dtype=np.float32) + 1e10), + axis=1) + + pairs = self._max_match(diff_normed) + for row, col in pairs: + if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: + poses[col].add(idx, joints[row], tags[row]) + else: + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joints[row], tags[row]) + poses.append(pose) + + if len(poses): + ans = np.stack([p.pose for p in poses]).astype(np.float32) + tags = np.stack([p.tag for p in poses]).astype(np.float32) + else: + ans = np.empty((0, self.num_joints, 2 + 1 + embd_size), dtype=np.float32) + tags = np.empty((0, embd_size), dtype=np.float32) + return ans, tags + + def top_k(self, heatmaps, tags): + N, K, H, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] + val_k = np.take_along_axis(heatmaps, ind, axis=2) + subind = np.argsort(-val_k, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + val_k = np.take_along_axis(val_k, subind, axis=2) + + tags = tags.reshape(N, K, W * H, -1) + if not self.tag_per_joint: + # FIXME. + tags = tags.expand(-1, self.num_joints, -1, -1) + tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] + tag_k = np.stack(tag_k, axis=3) + + x = ind % W + y = ind // W + ind_k = np.stack((x, y), axis=3) + + ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} + return ans + + def adjust(self, ans, heatmaps): + H, W = heatmaps.shape[-2:] + for n, people in enumerate(ans): + for person in people: + for k, joint in enumerate(person): + heatmap = heatmaps[n, k] + px = int(joint[0]) + py = int(joint[1]) + if 1 < px < W - 1 and 1 < py < H - 1: + diff = np.array([ + heatmap[py, px + 1] - heatmap[py, px - 1], + heatmap[py + 1, px] - heatmap[py - 1, px] + ]) + joint[:2] += np.sign(diff) * .25 + return ans + + def refine(self, heatmap, tag, keypoints, pose_tag=None): + K, H, W = heatmap.shape + if len(tag.shape) == 3: + tag = tag[..., None] + + if pose_tag is not None: + prev_tag = pose_tag + else: + tags = [] + for i in range(K): + if keypoints[i, 2] > 0: + # save tag value of detected keypoint + x, y = keypoints[i][:2].astype(int) + try: + tags.append(tag[i, y, x]) + except IndexError as ex: + print(x, y, heatmap.shape, tag.shape) + raise ex + # mean tag of current detected person + prev_tag = np.mean(tags, axis=0) + + # Allocate the buffer for tags similarity matrix. + tag_copy = np.empty_like(tag[0, ..., 0]) + for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): + if keypoints[i, 2] > 0: + continue + tag_copy[...] = _tag[..., 0] + diff = tag_copy + diff -= prev_tag + np.abs(diff, out=diff) + np.floor(diff + 0.5, out=diff) + diff -= _heatmap + idx = diff.argmin() + y, x = np.divmod(idx, _heatmap.shape[-1]) + + # detection score at maximum position + val = _heatmap[y, x] + + if val > 0: + keypoints[i, :3] = x, y, val + if 1 < x < W - 1 and 1 < y < H - 1: + diff = np.array([ + _heatmap[y, x + 1] - _heatmap[y, x - 1], + _heatmap[y + 1, x] - _heatmap[y - 1, x] + ]) + keypoints[i, :2] += np.sign(diff) * .25 + + return keypoints + + def __call__(self, heatmaps, tags, nms_heatmaps=None): + ans = self.match(**self.top_k(nms_heatmaps, tags)) + ans, ans_tags = map(list, zip(*ans)) + + if self.do_adjust: + ans = self.adjust(ans, heatmaps) + + if self.delta != 0.0: + for people in ans: + for person in people: + for joint in person: + joint[:2] += self.delta + + scores = [i[:, 2].mean() for i in ans[0]] + + if self.do_refine: + ans = ans[0] + heatmap_numpy = heatmaps[0] + tag_numpy = tags[0] + if not self.tag_per_joint: + tag_numpy = np.tile(tag_numpy, (self.num_joints, 1, 1, 1)) + + for i in range(len(ans)): + ans[i] = self.refine(heatmap_numpy, tag_numpy, ans[i], ans_tags[0][i]) + ans = [ans] + + return ans, scores + + +class AssociativeEmbeddingAdapter(Adapter): + __provider__ = 'human_pose_estimation_ae' + prediction_types = (PoseEstimationPrediction, ) + + @classmethod + def parameters(cls): + parameters = super().parameters() + parameters.update({ + 'heatmaps_out': StringField( + description="Name of output layer with keypoints heatmaps.", + optional=True + ), + 'nms_heatmaps_out': StringField( + description="Name of output layer with keypoints heatmaps after NMS.", + optional=True + ), + 'embeddings_out': StringField( + description="Name of output layer with associative embeddings.", + optional=True + ), + }) + return parameters + + def validate_config(self): + super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) + + def configure(self): + self.heatmaps = self.get_value_from_config('heatmaps_out') + self.nms_heatmaps = self.get_value_from_config('nms_heatmaps_out') + self.embeddings = self.get_value_from_config('embeddings_out') + self.decoder = AssociativeEmbeddingDecoder( + num_joints=17, + adjust=True, + refine=True, + delta=0.0, + max_num_people=30, + tag_per_joint=True, + detection_threshold=0.1, + tag_threshold=1, + use_detection_val=True, + ignore_too_much=False) + + def process(self, raw, identifiers, frame_meta): + result = [] + raw_outputs = self._extract_predictions(raw, frame_meta) + if not contains_all(raw_outputs, (self.heatmaps, self.nms_heatmaps, self.embeddings)): + raise ConfigError('Some of the outputs are not found') + raw_output = zip(identifiers, raw_outputs[self.heatmaps][None], raw_outputs[self.nms_heatmaps][None], + raw_outputs[self.embeddings][None], frame_meta) + + for identifier, heatmap, nms_heatmap, embedding, meta in raw_output: + poses, scores = self.decoder(heatmap, embedding, nms_heatmaps=nms_heatmap) + if len(scores) == 0: + result.append(PoseEstimationPrediction(identifier, + np.empty((0, 17), dtype=np.float32), + np.empty((0, 17), dtype=np.float32), + np.empty((0, 17), dtype=np.float32), + np.empty((0, ), dtype=np.float32))) + continue + poses = poses[0] + scores = np.asarray(scores) + scale_x = meta['scale_x'] + scale_y = meta['scale_y'] + poses[:, :, 0] /= scale_x / 2 + poses[:, :, 1] /= scale_y / 2 + point_scores = poses[:, :, 2] + result.append(PoseEstimationPrediction(identifier, poses[:, :, 0], poses[:, :, 1], point_scores, scores)) + return result + + class SingleHumanPoseAdapter(Adapter): __provider__ = 'single_human_pose_estimation' prediction_types = (PoseEstimationPrediction, ) diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml new file mode 100644 index 00000000000..0f987ba5f7d --- /dev/null +++ b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml @@ -0,0 +1,36 @@ +models: + - name: human-pose-estimation-0002 + + launchers: + - framework: dlsdk + allow_reshape_input: True + adapter: + type: human_pose_estimation_ae + heatmaps_out: heatmaps + nms_heatmaps_out: nms_heatmaps + embeddings_out: embeddings + + datasets: + - name: ms_coco_keypoints + + preprocessing: + - type: resize + size: 288 + interpolation: LINEAR + aspect_ratio_scale: greater + - type: padding + stride: 32 + pad_type: right_bottom + + postprocessing: + - type: filter + apply_to: annotation + area_range: 1, 10000000000 + - type: filter + apply_to: prediction + area_range: 1, 10000000000 + + metrics: + - name: AP + type: coco_precision + max_detections: 20 From cd0563ef0e2ebda6dee2890916b420518f38d012 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 16:10:50 +0300 Subject: [PATCH 07/58] fix typo --- .../human_pose_estimation_demo/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 30d2054402e..341c3521e4b 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -109,7 +109,7 @@ def __init__(self, *args, labels_map=None, keep_aspect_ratio_resize=False, **kwa self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) self.embeddings_blob_name = find_layer_by_name('embeddings', self.net.outputs) - self.decorer = AssociativeEmbeddingDecoder( + self.decoder = AssociativeEmbeddingDecoder( num_joints=17, adjust=True, refine=True, @@ -156,7 +156,7 @@ def postprocess(self, outputs, meta): heatmaps = outputs[self.heatmaps_blob_name] nms_heatmaps = outputs[self.nms_heatmaps_blob_name] aembds = outputs[self.embeddings_blob_name] - poses, scores = self.decorer(heatmaps, aembds, nms_heatmaps=nms_heatmaps) + poses, scores = self.decoder(heatmaps, aembds, nms_heatmaps=nms_heatmaps) poses = poses[0] scores = scores[0] # Rescale poses to the original image. From e62ef4b44de9c498163176b6bd46ccaa6770e154 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 16:42:34 +0300 Subject: [PATCH 08/58] update configs --- .../description/human-pose-estimation-0002.md | 2 +- .../description/human-pose-estimation-0003.md | 2 +- .../adapters/pose_estimation.py | 12 ++++----- .../configs/human-pose-estimation-0002.yml | 11 +------- .../configs/human-pose-estimation-0003.yml | 27 +++++++++++++++++++ .../configs/human-pose-estimation-0004.yml | 27 +++++++++++++++++++ 6 files changed, 63 insertions(+), 18 deletions(-) create mode 100644 tools/accuracy_checker/configs/human-pose-estimation-0003.yml create mode 100644 tools/accuracy_checker/configs/human-pose-estimation-0004.yml diff --git a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md index 52186ba6e78..084d6c988df 100644 --- a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md +++ b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md @@ -14,7 +14,7 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr | Metric | Value | |---------------------------------|-------------------------------------------| -| Average Precision (AP) | 44.6% | +| Average Precision (AP) | 44.4% | | GFlops | 5.9393 | | MParams | 8.1504 | | Source framework | PyTorch* | diff --git a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md index 117e577d0cb..d35a0063754 100644 --- a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md +++ b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md @@ -14,7 +14,7 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr | Metric | Value | |---------------------------------|-------------------------------------------| -| Average Precision (AP) | 50.3% | +| Average Precision (AP) | 50.2% | | GFlops | 8.8720 | | MParams | 8.1504 | | Source framework | PyTorch* | diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index fda2493f711..2cdb0902b7a 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -655,13 +655,13 @@ def process(self, raw, identifiers, frame_meta): poses, scores = self.decoder(heatmap, embedding, nms_heatmaps=nms_heatmap) if len(scores) == 0: result.append(PoseEstimationPrediction(identifier, - np.empty((0, 17), dtype=np.float32), - np.empty((0, 17), dtype=np.float32), - np.empty((0, 17), dtype=np.float32), - np.empty((0, ), dtype=np.float32))) + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, ), dtype=float))) continue - poses = poses[0] - scores = np.asarray(scores) + poses = poses[0].astype(float) + scores = np.asarray(scores).astype(float) scale_x = meta['scale_x'] scale_y = meta['scale_y'] poses[:, :, 0] /= scale_x / 2 diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml index 0f987ba5f7d..a7d23b51b64 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml @@ -22,15 +22,6 @@ models: stride: 32 pad_type: right_bottom - postprocessing: - - type: filter - apply_to: annotation - area_range: 1, 10000000000 - - type: filter - apply_to: prediction - area_range: 1, 10000000000 - metrics: - name: AP - type: coco_precision - max_detections: 20 + type: coco_orig_keypoints_precision diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml new file mode 100644 index 00000000000..7b044a54356 --- /dev/null +++ b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml @@ -0,0 +1,27 @@ +models: + - name: human-pose-estimation-0003 + + launchers: + - framework: dlsdk + allow_reshape_input: True + adapter: + type: human_pose_estimation_ae + heatmaps_out: heatmaps + nms_heatmaps_out: nms_heatmaps + embeddings_out: embeddings + + datasets: + - name: ms_coco_keypoints + + preprocessing: + - type: resize + size: 352 + interpolation: LINEAR + aspect_ratio_scale: greater + - type: padding + stride: 32 + pad_type: right_bottom + + metrics: + - name: AP + type: coco_orig_keypoints_precision diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml new file mode 100644 index 00000000000..db49b1cc0da --- /dev/null +++ b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml @@ -0,0 +1,27 @@ +models: + - name: human-pose-estimation-0004 + + launchers: + - framework: dlsdk + allow_reshape_input: True + adapter: + type: human_pose_estimation_ae + heatmaps_out: heatmaps + nms_heatmaps_out: nms_heatmaps + embeddings_out: embeddings + + datasets: + - name: ms_coco_keypoints + + preprocessing: + - type: resize + size: 448 + interpolation: LINEAR + aspect_ratio_scale: greater + - type: padding + stride: 32 + pad_type: right_bottom + + metrics: + - name: AP + type: coco_orig_keypoints_precision From 8a43ca87db451e58207038ccbc2bbde62da17b99 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 18:59:12 +0300 Subject: [PATCH 09/58] clean up --- .../human_pose_estimation_demo/README.md | 157 ++---------------- .../human_pose_estimation.py | 22 ++- .../human_pose_estimation_demo/decoder.py | 25 +-- .../human_pose_estimation_demo/model.py | 28 ++-- .../visualization.py | 19 ++- .../adapters/pose_estimation.py | 29 +--- 6 files changed, 73 insertions(+), 207 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md index cef4c799e8d..a8b6dfda7ac 100644 --- a/demos/python_demos/human_pose_estimation_demo/README.md +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -1,30 +1,12 @@ -# Object Detection SSD Python* Demo, Async API performance showcase +# Human Pose Estimation Python* Demo -This demo showcases Object Detection with SSD and Async API. +This demo showcases the work of multi-person 2D pose estimation algorithms. The task is to predict a pose: body skeleton, which consists of a predefined set of keypoints and connections between them, for every person in an input image/video. -Async API usage can improve overall frame-rate of the application, because rather than wait for inference to complete, -the app can continue doing things on the host, while accelerator is busy. -Specifically, this demo keeps the number of Infer Requests that you have set using `-nireq` flag. -While some of the Infer Requests are processed by IE, the other ones can be filled with new frame data -and asynchronously started or the next output can be taken from the Infer Request and displayed. - -The technique can be generalized to any available parallel slack, for example, doing inference and simultaneously -encoding the resulting (previous) frames or running further inference, like some emotion detection on top of -the face detection results. -There are important performance caveats though, for example the tasks that run in parallel should try to avoid -oversubscribing the shared compute resources. -For example, if the inference is performed on the FPGA, and the CPU is essentially idle, -than it makes sense to do things on the CPU in parallel. But if the inference is performed say on the GPU, -than it can take little gain to do the (resulting video) encoding on the same GPU in parallel, -because the device is already busy. - -This and other performance implications and tips for the Async API are covered in the -[Optimization Guide](https://docs.openvinotoolkit.org/latest/_docs_optimization_guide_dldt_optimization_guide.html). +Demo application supports inference in both sync and async modes. Please refer to [Optimization Guide](https://docs.openvinotoolkit.org/latest/_docs_optimization_guide_dldt_optimization_guide.html) and [Object Detection SSD, Async API performance showcase](../../object_detection_demo_ssd_async/README.md) demo for more information about Async API and its use. Other demo objectives are: * Video as input support via OpenCV\* -* Visualization of the resulting bounding boxes and text labels (from the `.labels` file) - or class number (if no file is provided) +* Visualization of the resulting poses * Demonstration of the Async API in action. For this, the demo features two modes toggled by the **Tab** key: - "User specified" mode, where you can set the number of Infer Requests, throughput streams and threads. Inference, starting new requests and displaying the results of completed requests are all performed asynchronously. @@ -36,91 +18,26 @@ Other demo objectives are: On the start-up, the application reads command-line parameters and loads a network to the Inference Engine. Upon getting a frame from the OpenCV VideoCapture, it performs inference and displays the results. -Async API operates with a notion of the "Infer Request" that encapsulates the inputs/outputs and separates -*scheduling and waiting for result*. - -The pipeline is the same for both modes. The difference is in the number of Infer Requests used. -``` -while True: - if (Infer Request containing the next video frame has completed): - get inference results - process inference results - display the frame - elif (one of the Infer Requests is idle and it is not the end of the input video): - capture frame - populate empty Infer Request - start Infer Request -``` - > **NOTE**: By default, Open Model Zoo demos expect input with BGR channels order. If you trained your model to work with RGB order, you need to manually rearrange the default channels order in the demo application or reconvert your model using the Model Optimizer tool with `--reverse_input_channels` argument specified. For more information about the argument, refer to **When to Reverse Input Channels** section of [Converting a Model Using General Conversion Parameters](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_Converting_Model_General.html). -### Async API - -The Inference Engine offers Async API based on the notion of Infer Requests. You can execute a Infer Requests -asynchronously (in the background) and wait until ready, when the result is actually needed. -In a mean time your app can continue : - -```python -# load network as usual -ie = IECore() -net = ie.read_network(model='Model.xml', weights='Model.bin') -# load network to the plugin, setting the maximal number of concurrent Infer Requests to be used -exec_net = ie.load_network(network=net, device_name='GPU', num_requests=2) -# start concurrent Infer Requests (put requests to the queue and immediately return) -for i, request in enumerate(exec_net.requests): - request.async_infer(inputs={'data': imgs[i]}) -# here you can continue execution on the host until results of requests are really needed -# ... -outputs = [request.wait(-1) for request in exec_net.requests] -``` - -Another option is to set a callback on Infer Request completion: - -```python -# load network as usual -ie = IECore() -net = ie.read_network(model='Model.xml', weights='Model.bin') -# load network to the plugin, setting the maximal number of concurrent Infer Requests to be used -exec_net = ie.load_network(network=net, device_name='GPU', num_requests=2) -# define a callback function -def callback(status, py_data): - request, id = py_data - print(id, {key: blob.buffer for key, blob in request.output_blobs.items()}) - -# start concurrent Infer Requests and set their completion callbacks -for i, request in enumerate(exec_net.requests): - request.set_completion_callback(py_callback=callback, py_data=(request, i)) - request.async_infer(inputs={'data': imgs[i]}) - -# here you can continue execution on the host until results of requests are really needed -# ... -``` - -For more details on the requests-based Inference Engine API, including the Async execution, refer to -[Integrate the Inference Engine New Request API with Your Application](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Integrate_with_customer_application_new_API.html). - - ## Running Running the application with the `-h` option yields the following usage message: ``` -python3 object_detection_demo_ssd_async.py -h +python3 human_pose_estimation.py -h ``` The command yields the following usage message: ``` -usage: object_detection_demo_ssd_async.py [-h] -m MODEL -i INPUT [-d DEVICE] - [--labels LABELS] - [-t PROB_THRESHOLD] [-r] - [-nireq NUM_INFER_REQUESTS] - [-nstreams NUM_STREAMS] - [-nthreads NUM_THREADS] - [-loop LOOP] [-no_show] - [-u UTILIZATION_MONITORS] - [--keep_aspect_ratio] +usage: human_pose_estimation.py [-h] -m MODEL -i INPUT [-d DEVICE] + [-t PROB_THRESHOLD] [-r] + [-nireq NUM_INFER_REQUESTS] + [-nstreams NUM_STREAMS] + [-nthreads NUM_THREADS] [-loop LOOP] + [-no_show] [-u UTILIZATION_MONITORS] Options: -h, --help Show this help message and exit. @@ -134,34 +51,10 @@ Options: GPU, FPGA, HDDL or MYRIAD is acceptable. The sample will look for a suitable plugin for device specified. Default value is CPU. -Options: - -h, --help Show this help message and exit. - -m MODEL, --model MODEL - Required. Path to an .xml file with a trained model. - -i INPUT, --input INPUT - Required. Path to an image, video file or a numeric - camera ID. - -d DEVICE, --device DEVICE - Optional. Specify the target device to infer on; CPU, - GPU, FPGA, HDDL or MYRIAD is acceptable. The sample - will look for a suitable plugin for device specified. - Default value is CPU. - --labels LABELS Optional. Labels mapping file. -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD - Optional. Probability threshold for detections - filtering. + Optional. Probability threshold for poses filtering. -r, --raw_output_message Optional. Output inference results raw values showing. - -nireq NUM_INFER_REQUESTS, --num_infer_requests NUM_INFER_REQUESTS - Optional. Number of infer requests - -nstreams NUM_STREAMS, --num_streams NUM_STREAMS - Optional. Number of streams to use for inference on - the CPU or/and GPU in throughput mode (for HETERO and - MULTI device cases use format - :,: or just - ) - -nthreads NUM_THREADS, --num_threads NUM_THREADS - -m MODEL, --model MODEL Required. Path to an .xml file with a trained model. -i INPUT, --input INPUT Required. Path to an image, video file or a numeric @@ -171,10 +64,8 @@ Options: GPU, FPGA, HDDL or MYRIAD is acceptable. The sample will look for a suitable plugin for device specified. Default value is CPU. - --labels LABELS Optional. Labels mapping file. -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD - Optional. Probability threshold for detections - filtering. + Optional. Probability threshold for poses filtering. -r, --raw_output_message Optional. Output inference results raw values showing. -nireq NUM_INFER_REQUESTS, --num_infer_requests NUM_INFER_REQUESTS @@ -193,26 +84,12 @@ Options: -no_show, --no_show Optional. Don't show output -u UTILIZATION_MONITORS, --utilization_monitors UTILIZATION_MONITORS Optional. List of monitors to show initially. - --keep_aspect_ratio Optional. Keeps aspect ratio on resize. ``` -The number of Infer Requests is specified by `-nireq` flag. An increase of this number usually leads to an increase -of performance (throughput), since in this case several Infer Requests can be processed simultaneously if the device -supports parallelization. However, a large number of Infer Requests increases the latency because each frame still -has to wait before being sent for inference. - -For higher FPS, it is recommended that you set `-nireq` to slightly exceed the `-nstreams` value, -summed across all devices used. - -> **NOTE**: This demo is based on the callback functionality from the Inference Engine Python API. - The selected approach makes the execution in multi-device mode optimal by preventing wait delays caused by - the differences in device performance. However, the internal organization of the callback mechanism in Python API - leads to FPS decrease. Please, keep it in mind and use the C++ version of this demo for performance-critical cases. - -Running the application with the empty list of options yields the usage message given above and an error message. -You can use the following command to do inference on GPU with a pre-trained object detection model: +Running the application with the empty list of options yields the short usage message and an error message. +You can use the following command to do inference on GPU with a pre-trained human pose estimation model: ``` -python3 object_detection_demo_ssd_async.py -i /inputVideo.mp4 -m /ssd.xml -d GPU +python3 human_pose_estimation.py -i /inputVideo.mp4 -m /hpe.xml -d CPU ``` To run the demo, you can use public or pre-trained models. You can download the pre-trained models with the OpenVINO @@ -228,7 +105,7 @@ and the asynchronous mode configured with provided command-line parameters ("Use ## Demo Output -The demo uses OpenCV to display the resulting frame with detections (rendered as bounding boxes and labels, if provided). +The demo uses OpenCV to display the resulting frame with estimated poses. The demo reports * **FPS**: average rate of video frame processing (frames per second) * **Latency**: average time required to process one frame (from reading the frame to displaying the results) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index f318e9786df..02bc8a584d2 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -50,7 +50,7 @@ def build_argparser(): help='Optional. Specify the target device to infer on; CPU, GPU, FPGA, HDDL or MYRIAD is ' 'acceptable. The sample will look for a suitable plugin for device specified. ' 'Default value is CPU.', default='CPU', type=str) - args.add_argument('-t', '--prob_threshold', help='Optional. Probability threshold for detections filtering.', + args.add_argument('-t', '--prob_threshold', help='Optional. Probability threshold for poses filtering.', default=0.5, type=float) args.add_argument('-r', '--raw_output_message', help='Optional. Output inference results raw values showing.', default=False, action='store_true') @@ -68,8 +68,6 @@ def build_argparser(): args.add_argument('-no_show', '--no_show', help="Optional. Don't show output", action='store_true') args.add_argument('-u', '--utilization_monitors', default='', type=str, help='Optional. List of monitors to show initially.') - args.add_argument('--keep_aspect_ratio', action='store_true', default=False, - help='Optional. Keeps aspect ratio on resize.') return parser @@ -137,12 +135,10 @@ def main(): Modes.USER_SPECIFIED: HPE(ie, args.model, device=args.device, plugin_config=config_user_specified, results=completed_request_results, max_num_requests=args.num_infer_requests, - keep_aspect_ratio_resize=args.keep_aspect_ratio, caught_exceptions=exceptions), Modes.MIN_LATENCY: HPE(ie, args.model, device=args.device.split(':')[-1].split(',')[0], plugin_config=config_min_latency, results=completed_request_results, max_num_requests=1, - keep_aspect_ratio_resize=args.keep_aspect_ratio, caught_exceptions=exceptions) } @@ -171,13 +167,25 @@ def main(): if next_frame_id_to_show in completed_request_results: frame_meta, raw_outputs = completed_request_results.pop(next_frame_id_to_show) poses, scores = hpes[mode].postprocess(raw_outputs, frame_meta) + valid_poses = scores > args.prob_threshold + poses = poses[valid_poses] + scores = scores[valid_poses] frame = frame_meta['frame'] start_time = frame_meta['start_time'] + if len(poses) and args.raw_output_message: + log.info('Poses:') + origin_im_size = frame.shape[:-1] presenter.drawGraphs(frame) - show_poses(frame, poses, scores, threshold=args.prob_threshold) + show_poses(frame, poses, scores, pose_score_threshold=args.prob_threshold, + point_score_threshold=args.prob_threshold) + + if args.raw_output_message: + for pose, pose_score in zip(poses, scores): + pose_str = ' '.join('({:.2f}, {:.2f}, {:.2f})'.format(p[0], p[1], p[2]) for p in pose) + log.info('{} | {:.2f}'.format(pose_str, pose_score)) mode_message = '{} mode'.format(mode.name) put_highlighted_text(frame, mode_message, (10, int(origin_im_size[0] - 20)), @@ -202,7 +210,7 @@ def main(): put_highlighted_text(frame, latency_message, (15, 50), cv2.FONT_HERSHEY_COMPLEX, 0.75, (200, 10, 10), 2) if not args.no_show: - cv2.imshow('Detection Results', frame) + cv2.imshow('Pose estimation results', frame) key = cv2.waitKey(wait_key_time) ESC_KEY = 27 diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py index ebf6a152329..9d70adc7ae0 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py @@ -6,17 +6,15 @@ class AssociativeEmbeddingDecoder: def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, - ignore_too_much, tag_threshold, tag_per_joint, nms_kernel, - adjust=True, refine=True, delta=0.0): + ignore_too_much, tag_threshold, adjust=True, refine=True, delta=0.0, joints_order=None): self.num_joints = num_joints self.max_num_people = max_num_people self.detection_threshold = detection_threshold self.tag_threshold = tag_threshold - self.tag_per_joint = tag_per_joint self.use_detection_val = use_detection_val self.ignore_too_much = ignore_too_much - if self.num_joints == 17: + if self.num_joints == 17 and joints_order is None: self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) else: self.joint_order = list(np.arange(self.num_joints)) @@ -126,9 +124,6 @@ def top_k(self, heatmaps, tags): val_k = np.take_along_axis(val_k, subind, axis=2) tags = tags.reshape(N, K, W * H, -1) - if not self.tag_per_joint: - # FIXME. - tags = tags.expand(-1, self.num_joints, -1, -1) tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] tag_k = np.stack(tag_k, axis=3) @@ -166,14 +161,8 @@ def refine(self, heatmap, tag, keypoints, pose_tag=None): tags = [] for i in range(K): if keypoints[i, 2] > 0: - # save tag value of detected keypoint x, y = keypoints[i][:2].astype(int) - try: - tags.append(tag[i, y, x]) - except IndexError as ex: - print(x, y, heatmap.shape, tag.shape) - raise ex - # mean tag of current detected person + tags.append(tag[i, y, x]) prev_tag = np.mean(tags, axis=0) # Allocate the buffer for tags similarity matrix. @@ -217,17 +206,13 @@ def __call__(self, heatmaps, tags, nms_heatmaps=None): for joint in person: joint[:2] += self.delta - scores = [i[:, 2].mean() for i in ans[0]] + ans = ans[0] + scores = np.asarray([i[:, 2].mean() for i in ans]) if self.do_refine: - ans = ans[0] heatmap_numpy = heatmaps[0] tag_numpy = tags[0] - if not self.tag_per_joint: - tag_numpy = np.tile(tag_numpy, (self.num_joints, 1, 1, 1)) - for i in range(len(ans)): ans[i] = self.refine(heatmap_numpy, tag_numpy, ans[i], ans_tags[0][i]) - ans = [ans] return ans, scores diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 341c3521e4b..6d80a9f57d8 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -97,10 +97,10 @@ def await_any(self): class HPE(Model): - def __init__(self, *args, labels_map=None, keep_aspect_ratio_resize=False, **kwargs): + def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=32, **kwargs): super().__init__(*args, **kwargs) self.keep_aspect_ratio_resize = keep_aspect_ratio_resize - self.labels_map = labels_map + self.size_divisor = size_divisor self.image_blob_name = self._get_inputs(self.net) self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] @@ -109,14 +109,15 @@ def __init__(self, *args, labels_map=None, keep_aspect_ratio_resize=False, **kwa self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) self.embeddings_blob_name = find_layer_by_name('embeddings', self.net.outputs) + self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] + self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] + self.decoder = AssociativeEmbeddingDecoder( - num_joints=17, + num_joints=self.num_joints, adjust=True, refine=True, delta=0.0, max_num_people=30, - nms_kernel=5, - tag_per_joint=True, detection_threshold=0.1, tag_threshold=1, use_detection_val=True, @@ -148,8 +149,15 @@ def preprocess(self, inputs): img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size), self.keep_aspect_ratio_resize) meta = {'original_shape': inputs[self.image_blob_name].shape, 'resized_shape': img.shape} - img = img.transpose((2, 0, 1)) # Change data layout from HWC to CHW - inputs[self.image_blob_name] = img[None, ...] + h, w = img.shape[:2] + divisor = self.size_divisor + if w % divisor != 0 or h % divisor != 0: + img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor), + (0, (w + divisor - 1) // divisor * divisor), + (0, 0))) + # Change data layout from HWC to CHW + img = img.transpose((2, 0, 1)) + inputs[self.image_blob_name] = img[None] return inputs, meta def postprocess(self, outputs, meta): @@ -157,15 +165,13 @@ def postprocess(self, outputs, meta): nms_heatmaps = outputs[self.nms_heatmaps_blob_name] aembds = outputs[self.embeddings_blob_name] poses, scores = self.decoder(heatmaps, aembds, nms_heatmaps=nms_heatmaps) - poses = poses[0] - scores = scores[0] # Rescale poses to the original image. original_image_shape = meta['original_shape'] resized_image_shape = meta['resized_shape'] scale_x = original_image_shape[1] / resized_image_shape[1] scale_y = original_image_shape[0] / resized_image_shape[0] - poses[:, :, 0] *= scale_x * 2 - poses[:, :, 1] *= scale_y * 2 + poses[:, :, 0] *= scale_x * self.output_scale + poses[:, :, 1] *= scale_y * self.output_scale return poses, scores diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py index 02ed8893bec..99d369ff2ad 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py @@ -9,10 +9,13 @@ (6, 8), (7, 9), (8, 10), (9, 11), (2, 3), (1, 2), (1, 3), (2, 4), (3, 5), (4, 6), (5, 7)) -def show_poses(img, poses, scores, threshold=0.5, skeleton=default_skeleton): +def show_poses(img, poses, scores, pose_score_threshold=0.5, point_score_threshold=0.5, skeleton=None): if poses.size == 0: return img + if skeleton is None: + skeleton = default_skeleton + colors = [[0, 113, 188], [216, 82, 24], [236, 176, 31], @@ -29,16 +32,18 @@ def show_poses(img, poses, scores, threshold=0.5, skeleton=default_skeleton): [0, 0, 255], [170, 0, 255]] - for idx, kp in enumerate(poses): - points = [(int(p[0]), int(p[1])) for p in kp] - is_visible = [p[2] for p in kp] + for idx, (pose, pose_score) in enumerate(zip(poses, scores)): + if pose_score <= pose_score_threshold: + continue + points = [(int(p[0]), int(p[1])) for p in pose] + points_scores = [p[2] for p in pose] if skeleton is not None: for bone in skeleton: i = bone[0] - 1 j = bone[1] - 1 - if is_visible[i] > threshold and is_visible[j] > threshold: + if points_scores[i] > point_score_threshold and points_scores[j] > point_score_threshold: cv2.line(img, points[i], points[j], thickness=2, color=colors[idx % len(colors)]) - for p, v in zip(points, is_visible): - if v: + for p, v in zip(points, points_scores): + if v > point_score_threshold: cv2.circle(img, p, 1, (0, 0, 255), 2) return img diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 2cdb0902b7a..0e56d561991 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -374,17 +374,16 @@ def get_poses(subset, candidate): class AssociativeEmbeddingDecoder: def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, - ignore_too_much, tag_threshold, tag_per_joint, - adjust=True, refine=True, delta=0.0): + ignore_too_much, tag_threshold, + adjust=True, refine=True, delta=0.0, joints_order=None): self.num_joints = num_joints self.max_num_people = max_num_people self.detection_threshold = detection_threshold self.tag_threshold = tag_threshold - self.tag_per_joint = tag_per_joint self.use_detection_val = use_detection_val self.ignore_too_much = ignore_too_much - if self.num_joints == 17: + if self.num_joints == 17 and joints_order is None: self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) else: self.joint_order = list(np.arange(self.num_joints)) @@ -494,9 +493,6 @@ def top_k(self, heatmaps, tags): val_k = np.take_along_axis(val_k, subind, axis=2) tags = tags.reshape(N, K, W * H, -1) - if not self.tag_per_joint: - # FIXME. - tags = tags.expand(-1, self.num_joints, -1, -1) tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] tag_k = np.stack(tag_k, axis=3) @@ -534,14 +530,8 @@ def refine(self, heatmap, tag, keypoints, pose_tag=None): tags = [] for i in range(K): if keypoints[i, 2] > 0: - # save tag value of detected keypoint x, y = keypoints[i][:2].astype(int) - try: - tags.append(tag[i, y, x]) - except IndexError as ex: - print(x, y, heatmap.shape, tag.shape) - raise ex - # mean tag of current detected person + tags.append(tag[i, y, x]) prev_tag = np.mean(tags, axis=0) # Allocate the buffer for tags similarity matrix. @@ -585,18 +575,14 @@ def __call__(self, heatmaps, tags, nms_heatmaps=None): for joint in person: joint[:2] += self.delta - scores = [i[:, 2].mean() for i in ans[0]] + ans = ans[0] + scores = np.asarray([i[:, 2].mean() for i in ans]) if self.do_refine: - ans = ans[0] heatmap_numpy = heatmaps[0] tag_numpy = tags[0] - if not self.tag_per_joint: - tag_numpy = np.tile(tag_numpy, (self.num_joints, 1, 1, 1)) - for i in range(len(ans)): ans[i] = self.refine(heatmap_numpy, tag_numpy, ans[i], ans_tags[0][i]) - ans = [ans] return ans, scores @@ -637,7 +623,6 @@ def configure(self): refine=True, delta=0.0, max_num_people=30, - tag_per_joint=True, detection_threshold=0.1, tag_threshold=1, use_detection_val=True, @@ -660,7 +645,7 @@ def process(self, raw, identifiers, frame_meta): np.empty((0, 17), dtype=float), np.empty((0, ), dtype=float))) continue - poses = poses[0].astype(float) + poses = poses.astype(float) scores = np.asarray(scores).astype(float) scale_x = meta['scale_x'] scale_y = meta['scale_y'] From af96059d183d7b503f58be50a05917ec31165ca6 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 5 Nov 2020 22:52:25 +0300 Subject: [PATCH 10/58] fix padding --- .../human_pose_estimation_demo/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 6d80a9f57d8..7d0d484ba83 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -152,8 +152,8 @@ def preprocess(self, inputs): h, w = img.shape[:2] divisor = self.size_divisor if w % divisor != 0 or h % divisor != 0: - img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor), - (0, (w + divisor - 1) // divisor * divisor), + img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor - h), + (0, (w + divisor - 1) // divisor * divisor - w), (0, 0))) # Change data layout from HWC to CHW img = img.transpose((2, 0, 1)) From 629ebc5e4c02c347ef3e8141eae23eac26e6f87b Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 6 Nov 2020 14:00:34 +0300 Subject: [PATCH 11/58] rename dataset --- .../configs/human-pose-estimation-0002.yml | 2 +- .../configs/human-pose-estimation-0003.yml | 2 +- .../configs/human-pose-estimation-0004.yml | 2 +- tools/accuracy_checker/dataset_definitions.yml | 13 +++++++++++++ 4 files changed, 16 insertions(+), 3 deletions(-) diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml index a7d23b51b64..3cc19db2792 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml @@ -11,7 +11,7 @@ models: embeddings_out: embeddings datasets: - - name: ms_coco_keypoints + - name: ms_coco_val2017_keypoints preprocessing: - type: resize diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml index 7b044a54356..64905e81d63 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml @@ -11,7 +11,7 @@ models: embeddings_out: embeddings datasets: - - name: ms_coco_keypoints + - name: ms_coco_val2017_keypoints preprocessing: - type: resize diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml index db49b1cc0da..a8869c6903a 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml @@ -11,7 +11,7 @@ models: embeddings_out: embeddings datasets: - - name: ms_coco_keypoints + - name: ms_coco_val2017_keypoints preprocessing: - type: resize diff --git a/tools/accuracy_checker/dataset_definitions.yml b/tools/accuracy_checker/dataset_definitions.yml index 12ff834d3fc..da54e31bf46 100644 --- a/tools/accuracy_checker/dataset_definitions.yml +++ b/tools/accuracy_checker/dataset_definitions.yml @@ -115,6 +115,19 @@ datasets: type: coco_precision max_detections: 20 + - name: ms_coco_val2017_keypoints + data_source: val2017 + annotation_conversion: + converter: mscoco_keypoints + annotation_file: person_keypoints_val2017.json + sort_key: image_size + images_dir: val2017 + annotation: mscoco_val2017_keypoints.pickle + dataset_meta: mscoco_val2017_keypoints.json + metrics: + - name: AP + type: coco_orig_keypoints_precision + - name: imagenet_1000_classes annotation_conversion: converter: imagenet From fcc343c2d23e9ccaf4f35b31c1cc65c36cae320b Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 6 Nov 2020 17:31:59 +0300 Subject: [PATCH 12/58] remove empty sections in readme --- .../description/human-pose-estimation-0002.md | 2 -- .../description/human-pose-estimation-0003.md | 2 -- .../description/human-pose-estimation-0004.md | 2 -- 3 files changed, 6 deletions(-) diff --git a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md index 084d6c988df..ec87d1488ab 100644 --- a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md +++ b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md @@ -21,8 +21,6 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). -## Performance - ## Inputs Name: `input`, shape: [1x3x288x288]. An input image in the [BxCxHxW] format , diff --git a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md index d35a0063754..abf56584ab6 100644 --- a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md +++ b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md @@ -21,8 +21,6 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). -## Performance - ## Inputs Name: `input`, shape: [1x3x352x352]. An input image in the [BxCxHxW] format , diff --git a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md index 8a1d6a55a94..01c0543be05 100644 --- a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md +++ b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md @@ -21,8 +21,6 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). -## Performance - ## Inputs Name: `input`, shape: [1x3x448x448]. An input image in the [BxCxHxW] format , From 3c6112db17baed78a05b3dd9c5276a726035e526 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 6 Nov 2020 19:06:58 +0300 Subject: [PATCH 13/58] change hpe visualization --- .../visualization.py | 61 ++++++++++--------- 1 file changed, 32 insertions(+), 29 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py index 99d369ff2ad..e8f0d207dbf 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py @@ -1,6 +1,3 @@ -import colorsys -import random - import cv2 import numpy as np @@ -16,34 +13,40 @@ def show_poses(img, poses, scores, pose_score_threshold=0.5, point_score_thresho if skeleton is None: skeleton = default_skeleton - colors = [[0, 113, 188], - [216, 82, 24], - [236, 176, 31], - [125, 46, 141], - [118, 171, 47], - [76, 189, 237], - [161, 19, 46], - [76, 76, 76], - [153, 153, 153], - [255, 0, 0], - [255, 127, 0], - [190, 190, 0], - [0, 255, 0], - [0, 0, 255], - [170, 0, 255]] - + colors = ( + (255, 0, 0), (255, 0, 255), (170, 0, 255), (255, 0, 85), + (255, 0, 170), (85, 255, 0), (255, 170, 0), (0, 255, 0), + (255, 255, 0), (0, 255, 85), (170, 255, 0), (0, 85, 255), + (0, 255, 170), (0, 0, 255), (0, 255, 255), (85, 0, 255), + (0, 170, 255)) + + stick_width = 4 + for idx, (pose, pose_score) in enumerate(zip(poses, scores)): if pose_score <= pose_score_threshold: continue - points = [(int(p[0]), int(p[1])) for p in pose] - points_scores = [p[2] for p in pose] - if skeleton is not None: - for bone in skeleton: - i = bone[0] - 1 - j = bone[1] - 1 - if points_scores[i] > point_score_threshold and points_scores[j] > point_score_threshold: - cv2.line(img, points[i], points[j], thickness=2, color=colors[idx % len(colors)]) - for p, v in zip(points, points_scores): + points = pose[:, :2].astype(int) + points_scores = pose[:, 2] + for i, (p, v) in enumerate(zip(points, points_scores)): if v > point_score_threshold: - cv2.circle(img, p, 1, (0, 0, 255), 2) + cv2.circle(img, tuple(p), 1, colors[i], 2) + + img_x = np.copy(img) + for idx, (pose, pose_score) in enumerate(zip(poses, scores)): + if pose_score <= pose_score_threshold: + continue + points = pose[:, :2].astype(int) + points_scores = pose[:, 2] + for bone in skeleton: + i = bone[0] - 1 + j = bone[1] - 1 + if points_scores[i] > point_score_threshold and points_scores[j] > point_score_threshold: + middle = (points[i] + points[j]) // 2 + vec = points[i] - points[j] + length = np.sqrt((vec * vec).sum()) + angle = int(np.arctan2(vec[1], vec[0]) * 180 / np.pi) + polygon = cv2.ellipse2Poly(tuple(middle), (int(length / 2), min(int(length / 50), stick_width)), angle, 0, 360, 1) + cv2.fillConvexPoly(img_x, polygon, colors[j]) + cv2.addWeighted(img, 0.4, img_x, 0.6, 0, dst=img) + return img From 18f4deacb2b6f60948dcce051a76a8976fbbf606 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 9 Nov 2020 12:12:58 +0300 Subject: [PATCH 14/58] style fixes --- .../adapters/pose_estimation.py | 23 ++++++++++++------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 0e56d561991..03a87a70c29 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -387,7 +387,7 @@ def __init__(self, num_joints, max_num_people, detection_threshold, use_detectio self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) else: self.joint_order = list(np.arange(self.num_joints)) - + self.do_adjust = adjust self.do_refine = refine self.delta = delta @@ -462,8 +462,7 @@ def tag(self): if num_added > num_grouped: diff_normed = np.concatenate( (diff_normed, - np.zeros((num_added, num_added - num_grouped), - dtype=np.float32) + 1e10), + np.zeros((num_added, num_added - num_grouped), dtype=np.float32) + 1e10), axis=1) pairs = self._max_match(diff_normed) @@ -633,17 +632,20 @@ def process(self, raw, identifiers, frame_meta): raw_outputs = self._extract_predictions(raw, frame_meta) if not contains_all(raw_outputs, (self.heatmaps, self.nms_heatmaps, self.embeddings)): raise ConfigError('Some of the outputs are not found') - raw_output = zip(identifiers, raw_outputs[self.heatmaps][None], raw_outputs[self.nms_heatmaps][None], - raw_outputs[self.embeddings][None], frame_meta) + raw_output = zip(identifiers, raw_outputs[self.heatmaps][None], + raw_outputs[self.nms_heatmaps][None], + raw_outputs[self.embeddings][None], frame_meta) for identifier, heatmap, nms_heatmap, embedding, meta in raw_output: poses, scores = self.decoder(heatmap, embedding, nms_heatmaps=nms_heatmap) if len(scores) == 0: - result.append(PoseEstimationPrediction(identifier, + result.append(PoseEstimationPrediction( + identifier, np.empty((0, 17), dtype=float), np.empty((0, 17), dtype=float), np.empty((0, 17), dtype=float), - np.empty((0, ), dtype=float))) + np.empty((0, ), dtype=float) + )) continue poses = poses.astype(float) scores = np.asarray(scores).astype(float) @@ -652,7 +654,12 @@ def process(self, raw, identifiers, frame_meta): poses[:, :, 0] /= scale_x / 2 poses[:, :, 1] /= scale_y / 2 point_scores = poses[:, :, 2] - result.append(PoseEstimationPrediction(identifier, poses[:, :, 0], poses[:, :, 1], point_scores, scores)) + result.append(PoseEstimationPrediction( + identifier, + poses[:, :, 0], + poses[:, :, 1], + point_scores, + scores)) return result From 8ad309b22a53df30dd2368292ceaeee8aa3d4ab0 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 9 Nov 2020 17:14:28 +0300 Subject: [PATCH 15/58] initial openpose support --- .../human_pose_estimation.py | 9 +- .../human_pose_estimation_demo/model.py | 85 +++- .../openpose_decoder.py | 396 ++++++++++++++++++ 3 files changed, 487 insertions(+), 3 deletions(-) create mode 100644 demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index 02bc8a584d2..d4cf3d5998b 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -27,7 +27,7 @@ import numpy as np from openvino.inference_engine import IECore -from human_pose_estimation_demo.model import HPE +from human_pose_estimation_demo.model import HPEAssociativeEmbedding, HPEOpenPose from human_pose_estimation_demo.visualization import show_poses sys.path.append(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'common')) @@ -68,6 +68,8 @@ def build_argparser(): args.add_argument('-no_show', '--no_show', help="Optional. Don't show output", action='store_true') args.add_argument('-u', '--utilization_monitors', default='', type=str, help='Optional. List of monitors to show initially.') + + args.add_argument('--type', default='ae', choices=('ae', 'openpose'), type=str, help='Optional.') return parser @@ -131,6 +133,11 @@ def main(): mode_info = {mode: ModeInfo()} exceptions = [] + if args.type == 'ae': + HPE = HPEAssociativeEmbedding + else: + HPE = HPEOpenPose + hpes = { Modes.USER_SPECIFIED: HPE(ie, args.model, device=args.device, plugin_config=config_user_specified, diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 7d0d484ba83..83bfa006018 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -7,6 +7,7 @@ import numpy as np from .decoder import AssociativeEmbeddingDecoder +from .openpose_decoder import OpenPoseDecoder log = logging.getLogger() @@ -95,7 +96,86 @@ def await_any(self): self.event.wait() -class HPE(Model): +class HPEOpenPose(Model): + + def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, **kwargs): + super().__init__(*args, **kwargs) + self.keep_aspect_ratio_resize = keep_aspect_ratio_resize + self.size_divisor = size_divisor + + self.image_blob_name = self._get_inputs(self.net) + self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] + + # self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) + # self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) + # self.pafs_blob_name = find_layer_by_name('pafs', self.net.outputs) + + self.pafs_blob_name = 'Mconv7_stage2_L1' + self.heatmaps_blob_name = 'Mconv7_stage2_L2' + self.nms_heatmaps_blob_name = None + + self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] + self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] + + self.decoder = OpenPoseDecoder(num_joints=self.num_joints) + + def _get_inputs(self, net): + image_blob_name = None + for blob_name, blob in net.input_info.items(): + if len(blob.input_data.shape) == 4: + image_blob_name = blob_name + else: + raise RuntimeError('Unsupported {}D input layer "{}". Only 2D and 4D input layers are supported' + .format(len(blob.shape), blob_name)) + if image_blob_name is None: + raise RuntimeError('Failed to identify the input for the image.') + return image_blob_name + + @staticmethod + def _resize_image(frame, size, keep_aspect_ratio=False): + # FIXME + if not keep_aspect_ratio: + resized_frame = cv2.resize(frame, size) + else: + h, w = frame.shape[:2] + scale = max(size[1] / h, size[0] / w) + resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) + return resized_frame + + def preprocess(self, inputs): + img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size), self.keep_aspect_ratio_resize) + meta = {'original_shape': inputs[self.image_blob_name].shape, + 'resized_shape': img.shape} + h, w = img.shape[:2] + divisor = self.size_divisor + if w % divisor != 0 or h % divisor != 0: + img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor - h), + (0, (w + divisor - 1) // divisor * divisor - w), + (0, 0))) + # Change data layout from HWC to CHW + img = img.transpose((2, 0, 1)) + inputs[self.image_blob_name] = img[None] + return inputs, meta + + def postprocess(self, outputs, meta): + heatmaps = outputs[self.heatmaps_blob_name] + if self.nms_heatmaps_blob_name: + nms_heatmaps = outputs[self.nms_heatmaps_blob_name] + else: + nms_heatmaps = self.decoder.nms(heatmaps) + pafs = outputs[self.pafs_blob_name] + poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) + # Rescale poses to the original image. + original_image_shape = meta['original_shape'] + resized_image_shape = meta['resized_shape'] + scale_x = original_image_shape[1] / resized_image_shape[1] + scale_y = original_image_shape[0] / resized_image_shape[0] + poses[:, :, 0] *= scale_x + poses[:, :, 1] *= scale_y + return poses, scores + + +class HPEAssociativeEmbedding(Model): def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=32, **kwargs): super().__init__(*args, **kwargs) @@ -176,9 +256,10 @@ def postprocess(self, outputs, meta): def find_layer_by_name(name, all_outputs): + all_names = tuple(layer_name for layer_name in all_outputs) suitable_layers = [layer_name for layer_name in all_outputs if layer_name.startswith(name)] if not suitable_layers: - raise ValueError('Suitable layer for "{}" output is not found'.format(name)) + raise ValueError('Suitable layer for "{}" output is not found in {}'.format(name, all_names)) if len(suitable_layers) > 1: raise ValueError('More than 1 layer matched to "{}" output: {}'.format(name, suitable_layers)) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py new file mode 100644 index 00000000000..2ee0bed8522 --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -0,0 +1,396 @@ +import math +from operator import itemgetter + +import numpy as np +import torch + + +# BODY_PARTS_KPT_IDS = tuple((i - 1, j - 1) for i, j in ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), +# (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17))) +# # BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), +# # (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) +# BODY_PARTS_PAF_IDS = ((12, 13), (20, 21), (14, 15), (16, 17), (22, 23), (24, 25), (0, 1), (2, 3), (4, 5), +# (6, 7), (8, 9), (10, 11), (28, 29), (30, 31), (34, 35), (32, 33), (36, 37), (18, 19), (26, 27)) + + +BODY_PARTS_KPT_IDS = tuple((i - 1, j - 1) for i, j in + [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], [10, 11], [2, 12], [12, 13], + [13, 14], [2, 1], [1, 15], [15, 17], [1, 16], [16, 18], [3, 17], [6, 18]] +) +BODY_PARTS_PAF_IDS = tuple(i - 19 for i, _ in [ + [31, 32], [39, 40], [33, 34], [35, 36], [41, 42], [43, 44], [19, 20], [21, 22], [23, 24], [25, 26], + [27, 28], [29, 30], [47, 48], [49, 50], [53, 54], [51, 52], [55, 56], [37, 38], [45, 46] +]) + +class OpenPoseDecoder: + def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0, delta=0.5, out_stride=8): + super().__init__() + self.num_joints = num_joints + self.max_points = max_points + self.score_threshold = score_threshold + self.min_dist = min_dist + self.delta = delta + self.out_stride = out_stride + self.high_res_heatmaps = False + self.high_res_pafs = False + self.arange_cache = {10: np.arange(10)} + nms_kernel = 5 + self.pool = torch.nn.MaxPool2d(nms_kernel, 1, (nms_kernel - 1) // 2) + + def nms(self, heatmaps): + heatmaps = torch.as_tensor(heatmaps) + maxm = self.pool(heatmaps) + maxm = torch.eq(maxm, heatmaps).float() + return (heatmaps * maxm).numpy() + + def scale_kpts(self, kpts, scale, max_v): + for kpt in kpts: + kpt[0] = max(0, min(kpt[0] * scale, max_v[0])) + kpt[1] = max(0, min(kpt[1] * scale, max_v[1])) + return kpts + + def __call__(self, heatmaps, nms_heatmaps, pafs): + pafs = np.transpose(pafs, (0, 2, 3, 1)) + + batch_size, _, h, w = heatmaps.shape + hup = h * self.out_stride + wup = w * self.out_stride + assert batch_size == 1 + + results = [] + + min_dist = self.min_dist + if not self.high_res_heatmaps: + self.min_dist = 6.0 / self.out_stride + + keypoints = self.extract_points(heatmaps, nms_heatmaps) + self.min_dist = min_dist + + if self.high_res_heatmaps: + for kpts in keypoints: + self.scale_kpts(kpts, 1 / self.out_stride, (w - 1, h - 1)) + + if self.delta > 0: + # To adjust coordinates' flooring in heatmaps target generation. + for kpts in keypoints: + for kpt in kpts: + kpt[0] = min(kpt[0] + self.delta, w - 1) + kpt[1] = min(kpt[1] + self.delta, h - 1) + + if self.high_res_pafs: + for kpts in keypoints: + self.scale_kpts(kpts, self.out_stride, (wup - 1, hup - 1)) + + pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) + + grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints, None) + if len(grouped_kpts) > 0: + grouped_kpts = np.asarray(grouped_kpts) + grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) + if not self.high_res_pafs: + grouped_kpts[:, :, :2] *= self.out_stride + grouped_kpts[:, :, 0].clip(0, wup - 1) + grouped_kpts[:, :, 1].clip(0, hup - 1) + else: + grouped_kpts = np.empty((0, 17, 3), dtype=np.float32) + scores = np.zeros(0, dtype=np.float32) + + return grouped_kpts, scores + + + def extract_points(self, heatmaps, nms_heatmaps): + batch_size, channels_num, h, w = heatmaps.shape + assert batch_size == 1, 'Batch size of 1 only supported' + assert channels_num >= self.num_joints + # print(batch_size, channels_num, h, w) + + xs, ys, scores = self.top_k(nms_heatmaps) + # print(xs.shape) + # print(xs) + # print(ys.shape) + # print(ys) + + masks = scores > self.score_threshold + all_keypoints = [] + keypoint_id = 0 + for k in range(self.num_joints): + mask = masks[0, k] + x = xs[0, k][mask].ravel() + y = ys[0, k][mask].ravel() + score = scores[0, k][mask].ravel() + + keypoints = [] + + n = len(x) + if n == 0: + all_keypoints.append(keypoints) + continue + + suppressed = np.zeros(n, np.bool) + for i in range(n): + if suppressed[i]: + continue + xx = x[i] + yy = y[i] + for j in range(i + 1, n): + if math.sqrt((xx - x[j]) ** 2 + (yy - y[j]) ** 2) < self.min_dist: + suppressed[j] = True + xx, yy = self.refine(heatmaps[0, k], (xx, yy)) + p = [xx, yy, score[i], keypoint_id] + p[0] = max(min(p[0], w - 1), 0) + p[1] = max(min(p[1], h - 1), 0) + keypoints.append(p) + keypoint_id += 1 + all_keypoints.append(keypoints) + return all_keypoints + + def top_k(self, heatmaps): + N, K, _, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] + scores = np.take_along_axis(heatmaps, ind, axis=2) + subind = np.argsort(-scores, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + scores = np.take_along_axis(scores, subind, axis=2) + x = ind % W + y = ind // W + return x, y, scores + + def top_k_baseline(self, det, total_keypoint_num): + h = det.shape[-2] + w = det.shape[-1] + nms_det = self.nms(det) + scores, indices = nms_det.view(-1).topk(self.max_points, dim=0) + indices = indices.reshape(-1) + scores = scores.reshape(-1) + x = indices % w + y = (indices / w).long() + + mask = scores > self.score_threshold + x = x[mask] + y = y[mask] + scores = scores[mask] + + keypoints_with_score_and_id = [] + + if len(x) == 0: + return keypoints_with_score_and_id + + x = x.cpu().numpy() + y = y.cpu().numpy() + scores = scores.cpu().numpy() + + n = len(scores) + suppressed = np.zeros(n, np.bool) + keypoints_with_score_and_id = [] + keypoint_num = 0 + for i in range(n): + if suppressed[i]: + continue + for j in range(i + 1, n): + if math.sqrt((x[i] - x[j]) ** 2 + (y[i] - y[j]) ** 2) < self.min_dist: + suppressed[j] = True + xx, yy = self.refine(det, (x[i], y[i])) + # xx, yy = x[i], y[i] + keypoint_with_score_and_id = [xx, yy, scores[i], total_keypoint_num + keypoint_num] + # keypoint_with_score_and_id = [x[i] + 0.5, y[i] + 0.5, scores[i], total_keypoint_num + keypoint_num] + # keypoint_with_score_and_id = [x[i], y[i], scores[i], total_keypoint_num + keypoint_num] + keypoint_with_score_and_id[0] = max(min(keypoint_with_score_and_id[0], w - 1), 0) + keypoint_with_score_and_id[1] = max(min(keypoint_with_score_and_id[1], h - 1), 0) + keypoints_with_score_and_id.append(keypoint_with_score_and_id) + keypoint_num += 1 + + return keypoints_with_score_and_id + + def refine(self, det, max_pos): + + def delta(x, y, epsilon=1e-1): + if -epsilon < x - y < epsilon: + return 0 + elif x > y: + return 0.25 + else: + return -0.25 + + h = det.shape[-2] + w = det.shape[-1] + x, y = max_pos + y_out = y + delta(det[min(y + 1, h - 1), x], det[max(y - 1, 0), x]) + x_out = x + delta(det[y, min(x + 1, w - 1)], det[y, max(x - 1, 0)]) + return x_out, y_out + + def linspace2d(self, start, stop, n=10): + # return np.linspace(start, stop, n, axis=1) + assert n > 0 + if n == 1: + return start[:, None] + points = 1 / (n - 1) * (stop - start) + arange = self.arange_cache.setdefault(n, np.arange(n)) + return points[:, None] * arange + start[:, None] + + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, + skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): + + all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist]) + pose_entries = [] + + for part_id, paf_channel in enumerate(bones_to_channels): + # print(pafs.shape) + # print(paf_channel) + part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] + # print(part_pafs.shape) + + kpt_a_id, kpt_b_id = skeleton[part_id] + kpts_a = all_keypoints_by_type[kpt_a_id] + kpts_b = all_keypoints_by_type[kpt_b_id] + num_kpts_a = len(kpts_a) + num_kpts_b = len(kpts_b) + + if num_kpts_a == 0 or num_kpts_b == 0: + continue + + connections = [] + for i in range(num_kpts_a): + kpt_a = np.asarray(kpts_a[i][0:2], dtype=np.float32) + for j in range(num_kpts_b): + kpt_b = np.asarray(kpts_b[j][0:2], dtype=np.float32) + vec_raw = kpt_b - kpt_a + vec_norm = np.sqrt(np.sum(vec_raw * vec_raw)) + if vec_norm == 0: + continue + vec = vec_raw / vec_norm + + point_num = 10 + x, y = self.linspace2d(kpt_a, kpt_b, n=point_num) + x = x.round().astype(int) + y = y.round().astype(int) + field = part_pafs[y, x].reshape(-1, 2) + dot_prod = np.dot(field, vec) + dot_prod = dot_prod[dot_prod > min_paf_score] + success_ratio = len(dot_prod) / len(x) + score = np.mean(dot_prod) if len(dot_prod) > 0 else 0.0 + + if score > 0 and success_ratio > 0.8: + score_all = score + kpts_a[i][2] + kpts_b[j][2] + connections.append([i, j, score, score_all]) + + if len(connections) > 0: + connections = sorted(connections, key=itemgetter(2), reverse=True) + + num_connections = min(num_kpts_a, num_kpts_b) + has_kpt_a = np.zeros(num_kpts_a, dtype=np.int32) + has_kpt_b = np.zeros(num_kpts_b, dtype=np.int32) + filtered_connections = [] + for row in range(len(connections)): + if len(filtered_connections) == num_connections: + break + i, j, cur_point_score = connections[row][0:3] + if not has_kpt_a[i] and not has_kpt_b[j]: + filtered_connections.append([kpts_a[i][3], kpts_b[j][3], cur_point_score]) + has_kpt_a[i] = 1 + has_kpt_b[j] = 1 + connections = filtered_connections + if len(connections) == 0: + continue + + # for i in range(len(connections)): + # pose_entries.append(init_pose(kpt_a_id, kpt_b_id, connections[i])) + # continue + + if part_id == 0: + pose_entries = [np.full(pose_entry_size, -1) for _ in range(len(connections))] + for i in range(len(connections)): + pose_entries[i][kpt_a_id] = connections[i][0] + pose_entries[i][kpt_b_id] = connections[i][1] + pose_entries[i][-1] = 2 + # pose score = sum of all points' scores + sum of all connections' scores + pose_entries[i][-2] = np.sum(all_keypoints[connections[i][0:2], 2]) + connections[i][2] + else: + for connection in connections: + pose_a_idx = -1 + pose_b_idx = -1 + for j, pose in enumerate(pose_entries): + if pose[kpt_a_id] == connection[0]: + pose_a_idx = j + if pose[kpt_b_id] == connection[1]: + pose_b_idx = j + if pose_a_idx < 0 and pose_b_idx < 0: + # print('CREATE NEW POSE') + # Create new pose entry. + pose_entry = np.full(pose_entry_size, -1) + pose_entry[kpt_a_id] = connection[0] + pose_entry[kpt_b_id] = connection[1] + pose_entry[-1] = 2 + pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + pose_entries.append(pose_entry) + elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: + # Merge two disjoint components into one pose. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + do_merge_poses = True + for j in range(len(pose_b) - 2): + if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: + do_merge_poses = False + break + if not do_merge_poses: + continue + for j in range(len(pose_b) - 2): + if pose_b[j] >= 0: + pose_a[j] = pose_b[j] + # pose_a[kpt_b_id] = connection[1] + pose_a[-1] += pose_b[-1] + pose_a[-2] += pose_b[-2] + connection[2] + del pose_entries[pose_b_idx] + elif pose_a_idx >= 0: + # Add a new bone into pose. + pose = pose_entries[pose_a_idx] + if pose[kpt_b_id] < 0: + pose[-2] += all_keypoints[connection[1], 2] + pose[kpt_b_id] = connection[1] + pose[-2] += connection[2] + pose[-1] += 1 + elif pose_b_idx >= 0: + # Add a new bone into pose. + pose = pose_entries[pose_b_idx] + if pose[kpt_a_id] < 0: + pose[-2] += all_keypoints[connection[0], 2] + pose[kpt_a_id] = connection[0] + pose[-2] += connection[2] + pose[-1] += 1 + + filtered_entries = [] + for i in range(len(pose_entries)): + if pose_entries[i][-1] < 3: # or (pose_entries[i][-2] / pose_entries[i][-1] < 0.2): + continue + filtered_entries.append(pose_entries[i]) + pose_entries = np.asarray(filtered_entries) + # pose_entries = np.asarray(pose_entries) + return pose_entries, all_keypoints + + + def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): + num_joints = 17 + coco_keypoints = [] + scores = [] + for n in range(len(pose_entries)): + if len(pose_entries[n]) == 0: + continue + keypoints = np.zeros(num_joints * 3) + # if reorder_map is None: + # reorder_map = tuple(range(num_joints)) + reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] + person_score = pose_entries[n][-2] + for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): + if target_id < 0: + continue + cx, cy, score, visibility = 0, 0, 0, 0 # keypoint not found + if keypoint_id != -1: + cx, cy, score = all_keypoints[int(keypoint_id), 0:3] + visibility = 2 + keypoints[target_id * 3 + 0] = cx + keypoints[target_id * 3 + 1] = cy + keypoints[target_id * 3 + 2] = score + coco_keypoints.append(keypoints) + scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' + # scores.append(person_score * max(0, pose_entries[n][-1])) + return np.asarray(coco_keypoints), np.asarray(scores) From 396d8d2f1e37b69617504d0e6552d87b34554833 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 9 Nov 2020 18:37:51 +0300 Subject: [PATCH 16/58] optimize grouping --- .../openpose_decoder.py | 62 +++++++++---------- 1 file changed, 29 insertions(+), 33 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index 2ee0bed8522..db39b2a7e8f 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -219,19 +219,11 @@ def delta(x, y, epsilon=1e-1): x_out = x + delta(det[y, min(x + 1, w - 1)], det[y, max(x - 1, 0)]) return x_out, y_out - def linspace2d(self, start, stop, n=10): - # return np.linspace(start, stop, n, axis=1) - assert n > 0 - if n == 1: - return start[:, None] - points = 1 / (n - 1) * (stop - start) - arange = self.arange_cache.setdefault(n, np.arange(n)) - return points[:, None] * arange + start[:, None] def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): - all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist]) + all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist], dtype=np.float32) pose_entries = [] for part_id, paf_channel in enumerate(bones_to_channels): @@ -248,31 +240,35 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if num_kpts_a == 0 or num_kpts_b == 0: continue - + + a = np.asarray([p[0:2] for p in kpts_a], dtype=np.float32) + b = np.asarray([p[0:2] for p in kpts_b], dtype=np.float32) + n, m = len(a), len(b) + a = np.tile(a, (m, 1)) + b = np.repeat(b, n, axis=0) + + point_num = 10 + vec_raw = b - a + vec_norm = np.linalg.norm(vec_raw, ord=2, axis=1, keepdims=True) + vec = np.repeat(vec_raw / (vec_norm + 1e-6), point_num, axis=0) + steps = 1 / (point_num - 1) * vec_raw + points = steps[:, None, :] * np.arange(point_num, dtype=np.float32)[None, :, None] + a[:, None, :] + points = points.round().astype(dtype=np.int32).reshape(-1, 2) + + x = points[:, 0].ravel() + y = points[:, 1].ravel() + field = part_pafs[y, x].reshape(-1, 2) + dot_prod = (field * vec).sum(1).reshape(-1, point_num) + + valid_prod = dot_prod > min_paf_score + success_ratio = valid_prod.sum(axis=1) / point_num + score = (dot_prod * valid_prod).sum(1) / (valid_prod.sum(1) + 1e-6) + + valid_limbs = np.where(np.logical_and(score > 0, success_ratio > 0.8))[0] + b_idx, a_idx = np.divmod(valid_limbs, n) connections = [] - for i in range(num_kpts_a): - kpt_a = np.asarray(kpts_a[i][0:2], dtype=np.float32) - for j in range(num_kpts_b): - kpt_b = np.asarray(kpts_b[j][0:2], dtype=np.float32) - vec_raw = kpt_b - kpt_a - vec_norm = np.sqrt(np.sum(vec_raw * vec_raw)) - if vec_norm == 0: - continue - vec = vec_raw / vec_norm - - point_num = 10 - x, y = self.linspace2d(kpt_a, kpt_b, n=point_num) - x = x.round().astype(int) - y = y.round().astype(int) - field = part_pafs[y, x].reshape(-1, 2) - dot_prod = np.dot(field, vec) - dot_prod = dot_prod[dot_prod > min_paf_score] - success_ratio = len(dot_prod) / len(x) - score = np.mean(dot_prod) if len(dot_prod) > 0 else 0.0 - - if score > 0 and success_ratio > 0.8: - score_all = score + kpts_a[i][2] + kpts_b[j][2] - connections.append([i, j, score, score_all]) + for t, i, j in zip(valid_limbs, a_idx, b_idx): + connections.append([i, j, score[t], score[t] + kpts_a[i][2] + kpts_b[j][2]]) if len(connections) > 0: connections = sorted(connections, key=itemgetter(2), reverse=True) From 6b5db640e675ae61727a3034f240f18cad4028ee Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Tue, 10 Nov 2020 16:06:51 +0300 Subject: [PATCH 17/58] optimize postprocessing --- .../openpose_decoder.py | 186 +++++++----------- 1 file changed, 70 insertions(+), 116 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index db39b2a7e8f..0b2bd6834e8 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -57,8 +57,6 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): wup = w * self.out_stride assert batch_size == 1 - results = [] - min_dist = self.min_dist if not self.high_res_heatmaps: self.min_dist = 6.0 / self.out_stride @@ -96,51 +94,58 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): scores = np.zeros(0, dtype=np.float32) return grouped_kpts, scores - - + def extract_points(self, heatmaps, nms_heatmaps): batch_size, channels_num, h, w = heatmaps.shape assert batch_size == 1, 'Batch size of 1 only supported' assert channels_num >= self.num_joints - # print(batch_size, channels_num, h, w) xs, ys, scores = self.top_k(nms_heatmaps) - # print(xs.shape) - # print(xs) - # print(ys.shape) - # print(ys) masks = scores > self.score_threshold all_keypoints = [] keypoint_id = 0 for k in range(self.num_joints): + # Filter low-score points. mask = masks[0, k] x = xs[0, k][mask].ravel() y = ys[0, k][mask].ravel() score = scores[0, k][mask].ravel() - - keypoints = [] - n = len(x) + if n == 0: - all_keypoints.append(keypoints) + all_keypoints.append([]) continue - - suppressed = np.zeros(n, np.bool) - for i in range(n): - if suppressed[i]: - continue - xx = x[i] - yy = y[i] - for j in range(i + 1, n): - if math.sqrt((xx - x[j]) ** 2 + (yy - y[j]) ** 2) < self.min_dist: - suppressed[j] = True - xx, yy = self.refine(heatmaps[0, k], (xx, yy)) - p = [xx, yy, score[i], keypoint_id] - p[0] = max(min(p[0], w - 1), 0) - p[1] = max(min(p[1], h - 1), 0) - keypoints.append(p) - keypoint_id += 1 + + # Second stage of NMS. + xx = x[:, None] - x[None, :] + yy = y[:, None] - y[None, :] + dists = np.sqrt(xx * xx + yy * yy) + dists += np.tri(n, n, dtype=np.float32) * (2 * self.min_dist) + keep = dists.min(axis=0) >= self.min_dist + x = x[keep] + y = y[keep] + score = score[keep] + + # Apply quarter offset to improve localization accuracy. + x, y = self.refine(heatmaps[0, k], x, y) + np.core.umath.clip(x, 0, w - 1, out=x) + np.core.umath.clip(y, 0, h - 1, out=y) + + # Pack resulting points. + # keypoints = [] + # for a, b, c in zip(x, y, score): + # keypoints.append([a, b, c, keypoint_id]) + # keypoint_id += 1 + n = len(x) + keypoints = np.empty((n, 4), dtype=np.float32) + keypoints[:, 0] = x + keypoints[:, 1] = y + keypoints[:, 2] = score + keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) + # keypoints = np.stack([x, y, score, np.arange(keypoint_id, keypoint_id + n)], axis=1).astype(dtype=np.float32) + keypoint_id += n + all_keypoints.append(keypoints) return all_keypoints @@ -152,85 +157,35 @@ def top_k(self, heatmaps): subind = np.argsort(-scores, axis=2) ind = np.take_along_axis(ind, subind, axis=2) scores = np.take_along_axis(scores, subind, axis=2) - x = ind % W - y = ind // W + y, x = np.divmod(ind, W) return x, y, scores - def top_k_baseline(self, det, total_keypoint_num): - h = det.shape[-2] - w = det.shape[-1] - nms_det = self.nms(det) - scores, indices = nms_det.view(-1).topk(self.max_points, dim=0) - indices = indices.reshape(-1) - scores = scores.reshape(-1) - x = indices % w - y = (indices / w).long() - - mask = scores > self.score_threshold - x = x[mask] - y = y[mask] - scores = scores[mask] - - keypoints_with_score_and_id = [] + def refine(self, heatmap, x, y): + h, w = heatmap.shape[-2:] + valid = np.logical_and(np.logical_and(0 < x, x < w - 1), np.logical_and(0 < y, y < h - 1)) + xx = x[valid] + yy = y[valid] + dx = np.sign(heatmap[yy, xx + 1] - heatmap[yy, xx - 1], dtype=np.float32) * 0.25 + dy = np.sign(heatmap[yy + 1, xx] - heatmap[yy - 1, xx], dtype=np.float32) * 0.25 + x = x.astype(np.float32) + y = y.astype(np.float32) + x[valid] += dx + y[valid] += dy + return x, y + + - if len(x) == 0: - return keypoints_with_score_and_id - - x = x.cpu().numpy() - y = y.cpu().numpy() - scores = scores.cpu().numpy() - - n = len(scores) - suppressed = np.zeros(n, np.bool) - keypoints_with_score_and_id = [] - keypoint_num = 0 - for i in range(n): - if suppressed[i]: - continue - for j in range(i + 1, n): - if math.sqrt((x[i] - x[j]) ** 2 + (y[i] - y[j]) ** 2) < self.min_dist: - suppressed[j] = True - xx, yy = self.refine(det, (x[i], y[i])) - # xx, yy = x[i], y[i] - keypoint_with_score_and_id = [xx, yy, scores[i], total_keypoint_num + keypoint_num] - # keypoint_with_score_and_id = [x[i] + 0.5, y[i] + 0.5, scores[i], total_keypoint_num + keypoint_num] - # keypoint_with_score_and_id = [x[i], y[i], scores[i], total_keypoint_num + keypoint_num] - keypoint_with_score_and_id[0] = max(min(keypoint_with_score_and_id[0], w - 1), 0) - keypoint_with_score_and_id[1] = max(min(keypoint_with_score_and_id[1], h - 1), 0) - keypoints_with_score_and_id.append(keypoint_with_score_and_id) - keypoint_num += 1 - - return keypoints_with_score_and_id - - def refine(self, det, max_pos): - - def delta(x, y, epsilon=1e-1): - if -epsilon < x - y < epsilon: - return 0 - elif x > y: - return 0.25 - else: - return -0.25 - - h = det.shape[-2] - w = det.shape[-1] - x, y = max_pos - y_out = y + delta(det[min(y + 1, h - 1), x], det[max(y - 1, 0), x]) - x_out = x + delta(det[y, min(x + 1, w - 1)], det[y, max(x - 1, 0)]) - return x_out, y_out - - def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist], dtype=np.float32) pose_entries = [] + + point_num = 10 + grid = np.arange(point_num, dtype=np.float32).reshape(1, -1, 1) for part_id, paf_channel in enumerate(bones_to_channels): - # print(pafs.shape) - # print(paf_channel) part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] - # print(part_pafs.shape) kpt_a_id, kpt_b_id = skeleton[part_id] kpts_a = all_keypoints_by_type[kpt_a_id] @@ -244,25 +199,25 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p a = np.asarray([p[0:2] for p in kpts_a], dtype=np.float32) b = np.asarray([p[0:2] for p in kpts_b], dtype=np.float32) n, m = len(a), len(b) - a = np.tile(a, (m, 1)) - b = np.repeat(b, n, axis=0) - - point_num = 10 - vec_raw = b - a - vec_norm = np.linalg.norm(vec_raw, ord=2, axis=1, keepdims=True) - vec = np.repeat(vec_raw / (vec_norm + 1e-6), point_num, axis=0) - steps = 1 / (point_num - 1) * vec_raw - points = steps[:, None, :] * np.arange(point_num, dtype=np.float32)[None, :, None] + a[:, None, :] - points = points.round().astype(dtype=np.int32).reshape(-1, 2) - - x = points[:, 0].ravel() - y = points[:, 1].ravel() - field = part_pafs[y, x].reshape(-1, 2) - dot_prod = (field * vec).sum(1).reshape(-1, point_num) + + a = np.broadcast_to(a[None], (m, n, 2)) + vec_raw = (b[:, None, :] - a).reshape(-1, 1, 2) + + vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) + vec = vec_raw / (vec_norm + 1e-6) + steps = (1 / (point_num - 1) * vec_raw) + points = steps * grid + a.reshape(-1, 1, 2) + points = points.round().astype(dtype=np.int32) + + x = points[..., 0].ravel() + y = points[..., 1].ravel() + field = part_pafs[y, x].reshape(-1, point_num, 2) + dot_prod = (field * vec).sum(-1).reshape(-1, point_num) valid_prod = dot_prod > min_paf_score - success_ratio = valid_prod.sum(axis=1) / point_num - score = (dot_prod * valid_prod).sum(1) / (valid_prod.sum(1) + 1e-6) + valid_num = valid_prod.sum(1) + success_ratio = valid_num / point_num + score = (dot_prod * valid_prod).sum(1) / (valid_num + 1e-6) valid_limbs = np.where(np.logical_and(score > 0, success_ratio > 0.8))[0] b_idx, a_idx = np.divmod(valid_limbs, n) @@ -282,7 +237,7 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p break i, j, cur_point_score = connections[row][0:3] if not has_kpt_a[i] and not has_kpt_b[j]: - filtered_connections.append([kpts_a[i][3], kpts_b[j][3], cur_point_score]) + filtered_connections.append([int(kpts_a[i][3]), int(kpts_b[j][3]), cur_point_score]) has_kpt_a[i] = 1 has_kpt_b[j] = 1 connections = filtered_connections @@ -363,7 +318,6 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p # pose_entries = np.asarray(pose_entries) return pose_entries, all_keypoints - def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): num_joints = 17 coco_keypoints = [] From 6e7cb20da1ddcb765005c128b58a0df07bc23d20 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 11 Nov 2020 13:23:43 +0300 Subject: [PATCH 18/58] add OpenPose AC adapter draft --- .../accuracy_checker/adapters/__init__.py | 2 + .../adapters/pose_estimation.py | 451 ++++++++++++++++++ 2 files changed, 453 insertions(+) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/__init__.py b/tools/accuracy_checker/accuracy_checker/adapters/__init__.py index 5806ebcc7e0..3d0eed631a5 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/__init__.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/__init__.py @@ -64,6 +64,7 @@ from .classification import ClassificationAdapter from .segmentation import SegmentationAdapter, BrainTumorSegmentationAdapter, DUCSegmentationAdapter from .pose_estimation import ( + OpenPoseAdapter, AssociativeEmbeddingAdapter, HumanPoseAdapter, SingleHumanPoseAdapter, @@ -165,6 +166,7 @@ 'LPRAdapter', 'CTCGreedySearchDecoder', + 'OpenPoseAdapter', 'AssociativeEmbeddingAdapter', 'HumanPoseAdapter', 'HumanPose3dAdapter', diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 03a87a70c29..1b826c91527 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -19,6 +19,7 @@ import cv2 import numpy as np +import torch from scipy.optimize import linear_sum_assignment from ..adapters import Adapter @@ -371,6 +372,119 @@ def get_poses(subset, candidate): return persons_keypoints_x, persons_keypoints_y, persons_keypoints_v, scores +class OpenPoseAdapter(Adapter): + __provider__ = 'human_pose_estimation_openpose' + prediction_types = (PoseEstimationPrediction, ) + + @classmethod + def parameters(cls): + parameters = super().parameters() + parameters.update({ + 'part_affinity_fields_out': StringField( + description="Name of output layer with keypoints pairwise relations (part affinity fields).", + optional=True + ), + 'keypoints_heatmap_out': StringField( + description="Name of output layer with keypoints heatmaps.", optional=True + ), + }) + + return parameters + + def validate_config(self): + super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) + + def configure(self): + self.part_affinity_fields = self.get_value_from_config('part_affinity_fields_out') + self.keypoints_heatmap = self.get_value_from_config('keypoints_heatmap_out') + self.concat_out = self.part_affinity_fields is None and self.keypoints_heatmap is None + if not self.concat_out: + contains_both = self.part_affinity_fields is not None and self.keypoints_heatmap is not None + if not contains_both: + raise ConfigError( + 'human_pose_estimation adapter should contains both: keypoints_heatmap_out ' + 'and part_affinity_fields_out or not contain them at all (in single output model case)' + ) + self._keypoints_heatmap_bias = self.keypoints_heatmap + '/add_' + self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' + self.decoder = OpenPoseDecoder(num_joints=18) + + def process(self, raw, identifiers, frame_meta): + result = [] + raw_outputs = self._extract_predictions(raw, frame_meta) + if not self.concat_out: + if not contains_any(raw_outputs, [self.part_affinity_fields, self._part_affinity_fields_bias]): + raise ConfigError('part affinity fields output not found') + if not contains_any(raw_outputs, [self.keypoints_heatmap, self._keypoints_heatmap_bias]): + raise ConfigError('keypoints heatmap output not found') + keypoints_heatmap = raw_outputs[ + self.keypoints_heatmap if self.keypoints_heatmap in raw_outputs else self._keypoints_heatmap_bias + ] + pafs = raw_outputs[ + self.part_affinity_fields if self.part_affinity_fields in raw_outputs + else self._part_affinity_fields_bias + ] + raw_output = zip(identifiers, keypoints_heatmap, pafs, frame_meta) + else: + concat_out = raw_outputs[self.output_blob] + keypoints_num = concat_out.shape[1] // 3 + keypoints_heat_map = concat_out[:, :keypoints_num, :] + pafs = concat_out[:, keypoints_num:, :] + raw_output = zip(identifiers, keypoints_heat_map, pafs, frame_meta) + for identifier, heatmap, paf, meta in raw_output: + s = 1 + if True: + s = 8 + self.decoder.delta = 0 + self.decoder.out_stride = 1 + self.decoder.min_dist = 6.0 + pad = meta.get('padding', [0, 0, 0, 0]) + transpose_order = (1, 2, 0) + heatmap = np.transpose(heatmap, transpose_order) + heatmap = cv2.resize(heatmap, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) + heatmap = heatmap[pad[0]:heatmap.shape[0] - pad[2], pad[1]:heatmap.shape[1] - pad[3]:, :] + heatmap = np.transpose(heatmap, (2, 0, 1)) + paf = np.transpose(np.squeeze(paf), transpose_order) + paf = cv2.resize(paf, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) + paf = paf[pad[0]:paf.shape[0] - pad[2], pad[1]:paf.shape[1] - pad[3], :] + paf = np.transpose(paf, (2, 0, 1)) + else: + self.decoder.min_dist = 6.0 / 8.0 + # print(heatmap.shape, paf.shape) + hmap = heatmap[None] + nms_hmap = self.decoder.nms(hmap) + poses, scores = self.decoder(hmap, nms_hmap, paf[None]) + if len(scores) == 0: + result.append(PoseEstimationPrediction( + identifier, + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, ), dtype=float) + )) + continue + poses = poses.astype(float) + scores = np.asarray(scores).astype(float) + scale_x = meta['scale_x'] + scale_y = meta['scale_y'] + + poses[:, :, 0] /= scale_x / (8 / s) + poses[:, :, 1] /= scale_y / (8 / s) + point_scores = poses[:, :, 2] + + # print(poses[:, :, 0]) + # print(poses[:, :, 1]) + # print(meta) + # exit(0) + result.append(PoseEstimationPrediction( + identifier, + poses[:, :, 0], + poses[:, :, 1], + point_scores, + scores)) + return result + + class AssociativeEmbeddingDecoder: def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, @@ -789,3 +903,340 @@ def get_preds(scores): preds = preds.reshape(1, preds.size) return preds + + +class OpenPoseDecoder: + BODY_PARTS_KPT_IDS = tuple((i - 1, j - 1) for i, j in + [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], [10, 11], [2, 12], [12, 13], + [13, 14], [2, 1], [1, 15], [15, 17], [1, 16], [16, 18], [3, 17], [6, 18]] + ) + BODY_PARTS_PAF_IDS = tuple(i - 19 for i, _ in [ + [31, 32], [39, 40], [33, 34], [35, 36], [41, 42], [43, 44], [19, 20], [21, 22], [23, 24], [25, 26], + [27, 28], [29, 30], [47, 48], [49, 50], [53, 54], [51, 52], [55, 56], [37, 38], [45, 46] + ]) + + def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0, delta=0.5, out_stride=8): + super().__init__() + self.num_joints = num_joints + self.max_points = max_points + self.score_threshold = score_threshold + self.min_dist = min_dist + self.delta = delta + self.out_stride = out_stride + self.high_res_heatmaps = False + self.high_res_pafs = False + nms_kernel = 5 + self.pool = torch.nn.MaxPool2d(nms_kernel, 1, (nms_kernel - 1) // 2) + + def nms(self, heatmaps): + heatmaps = torch.as_tensor(heatmaps) + maxm = self.pool(heatmaps) + maxm = torch.eq(maxm, heatmaps).float() + return (heatmaps * maxm).numpy() + + def scale_kpts(self, kpts, scale, max_v): + for kpt in kpts: + kpt[0] = max(0, min(kpt[0] * scale, max_v[0])) + kpt[1] = max(0, min(kpt[1] * scale, max_v[1])) + return kpts + + def __call__(self, heatmaps, nms_heatmaps, pafs): + pafs = np.transpose(pafs, (0, 2, 3, 1)) + + batch_size, _, h, w = heatmaps.shape + # hup = h * self.out_stride + # wup = w * self.out_stride + assert batch_size == 1 + + # min_dist = self.min_dist + # if not self.high_res_heatmaps: + # self.min_dist = 6.0 / self.out_stride + + keypoints = self.extract_points(heatmaps, nms_heatmaps) + # self.min_dist = min_dist + + # if self.high_res_heatmaps: + # for kpts in keypoints: + # self.scale_kpts(kpts, 1 / self.out_stride, (w - 1, h - 1)) + + if self.delta > 0: + # To adjust coordinates' flooring in heatmaps target generation. + for kpts in keypoints: + for kpt in kpts: + kpt[0] = min(kpt[0] + self.delta, w - 1) + kpt[1] = min(kpt[1] + self.delta, h - 1) + + # if self.high_res_pafs: + # for kpts in keypoints: + # self.scale_kpts(kpts, self.out_stride, (wup - 1, hup - 1)) + + pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) + # exit(0) + + grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints, None) + # print(grouped_kpts) + # print(scores) + # exit(0) + if len(grouped_kpts) > 0: + grouped_kpts = np.asarray(grouped_kpts) + grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) + # if not self.high_res_pafs: + # grouped_kpts[:, :, :2] *= self.out_stride + # grouped_kpts[:, :, 0].clip(0, wup - 1) + # grouped_kpts[:, :, 1].clip(0, hup - 1) + else: + grouped_kpts = np.empty((0, 17, 3), dtype=np.float32) + scores = np.zeros(0, dtype=np.float32) + + return grouped_kpts, scores + + def extract_points(self, heatmaps, nms_heatmaps): + batch_size, channels_num, h, w = heatmaps.shape + assert batch_size == 1, 'Batch size of 1 only supported' + assert channels_num >= self.num_joints + + xs, ys, scores = self.top_k(nms_heatmaps) + + masks = scores > self.score_threshold + all_keypoints = [] + keypoint_id = 0 + for k in range(self.num_joints): + # Filter low-score points. + mask = masks[0, k] + x = xs[0, k][mask].ravel() + y = ys[0, k][mask].ravel() + score = scores[0, k][mask].ravel() + n = len(x) + + if n == 0: + all_keypoints.append([]) + continue + + # Second stage of NMS. + xx = x[:, None] - x[None, :] + yy = y[:, None] - y[None, :] + dists = np.sqrt(xx * xx + yy * yy) + dists += np.tri(n, n, dtype=np.float32) * (2 * self.min_dist) + keep = dists.min(axis=0) >= self.min_dist + x = x[keep] + y = y[keep] + score = score[keep] + + # Apply quarter offset to improve localization accuracy. + x, y = self.refine(heatmaps[0, k], x, y) + np.core.umath.clip(x, 0, w - 1, out=x) + np.core.umath.clip(y, 0, h - 1, out=y) + + # Pack resulting points. + # keypoints = [] + # for a, b, c in zip(x, y, score): + # keypoints.append([a, b, c, keypoint_id]) + # keypoint_id += 1 + n = len(x) + keypoints = np.empty((n, 4), dtype=np.float32) + keypoints[:, 0] = x + keypoints[:, 1] = y + keypoints[:, 2] = score + keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) + # keypoints = np.stack([x, y, score, np.arange(keypoint_id, keypoint_id + n)], axis=1).astype(dtype=np.float32) + keypoint_id += n + + all_keypoints.append(keypoints) + return all_keypoints + + def top_k(self, heatmaps): + N, K, _, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] + scores = np.take_along_axis(heatmaps, ind, axis=2) + subind = np.argsort(-scores, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + scores = np.take_along_axis(scores, subind, axis=2) + y, x = np.divmod(ind, W) + return x, y, scores + + def refine(self, heatmap, x, y): + h, w = heatmap.shape[-2:] + valid = np.logical_and(np.logical_and(0 < x, x < w - 1), np.logical_and(0 < y, y < h - 1)) + xx = x[valid] + yy = y[valid] + dx = np.sign(heatmap[yy, xx + 1] - heatmap[yy, xx - 1], dtype=np.float32) * 0.25 + dy = np.sign(heatmap[yy + 1, xx] - heatmap[yy - 1, xx], dtype=np.float32) * 0.25 + x = x.astype(np.float32) + y = y.astype(np.float32) + x[valid] += dx + y[valid] += dy + return x, y + + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, + skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): + + all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist], dtype=np.float32) + pose_entries = [] + + point_num = 10 + grid = np.arange(point_num, dtype=np.float32).reshape(1, -1, 1) + + for part_id, paf_channel in enumerate(bones_to_channels): + # print(part_id) + part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] + + kpt_a_id, kpt_b_id = skeleton[part_id] + kpts_a = all_keypoints_by_type[kpt_a_id] + kpts_b = all_keypoints_by_type[kpt_b_id] + num_kpts_a = len(kpts_a) + num_kpts_b = len(kpts_b) + + if num_kpts_a == 0 or num_kpts_b == 0: + continue + + a = np.asarray([p[0:2] for p in kpts_a], dtype=np.float32) + b = np.asarray([p[0:2] for p in kpts_b], dtype=np.float32) + n, m = len(a), len(b) + + a = np.broadcast_to(a[None], (m, n, 2)) + vec_raw = (b[:, None, :] - a).reshape(-1, 1, 2) + + vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) + vec = vec_raw / (vec_norm + 1e-6) + steps = (1 / (point_num - 1) * vec_raw) + points = steps * grid + a.reshape(-1, 1, 2) + points = points.round().astype(dtype=np.int32) + + x = points[..., 0].ravel() + y = points[..., 1].ravel() + field = part_pafs[y, x].reshape(-1, point_num, 2) + dot_prod = (field * vec).sum(-1).reshape(-1, point_num) + + valid_prod = dot_prod > min_paf_score + valid_num = valid_prod.sum(1) + success_ratio = valid_num / point_num + score = (dot_prod * valid_prod).sum(1) / (valid_num + 1e-6) + + valid_limbs = np.where(np.logical_and(score > 0, success_ratio > 0.8))[0] + b_idx, a_idx = np.divmod(valid_limbs, n) + connections = [] + for t, i, j in zip(valid_limbs, a_idx, b_idx): + connections.append([i, j, score[t], score[t] + kpts_a[i][2] + kpts_b[j][2]]) + # print(connections) + + if len(connections) > 0: + connections = sorted(connections, key=itemgetter(2), reverse=True) + + num_connections = min(num_kpts_a, num_kpts_b) + has_kpt_a = np.zeros(num_kpts_a, dtype=np.int32) + has_kpt_b = np.zeros(num_kpts_b, dtype=np.int32) + filtered_connections = [] + for row in range(len(connections)): + if len(filtered_connections) == num_connections: + break + i, j, cur_point_score = connections[row][0:3] + if not has_kpt_a[i] and not has_kpt_b[j]: + filtered_connections.append([int(kpts_a[i][3]), int(kpts_b[j][3]), cur_point_score]) + has_kpt_a[i] = 1 + has_kpt_b[j] = 1 + connections = filtered_connections + if len(connections) == 0: + continue + + # for i in range(len(connections)): + # pose_entries.append(init_pose(kpt_a_id, kpt_b_id, connections[i])) + # continue + + if part_id == 0: + pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] + for i in range(len(connections)): + pose_entries[i][kpt_a_id] = connections[i][0] + pose_entries[i][kpt_b_id] = connections[i][1] + pose_entries[i][-1] = 2 + # pose score = sum of all points' scores + sum of all connections' scores + pose_entries[i][-2] = np.sum(all_keypoints[connections[i][0:2], 2]) + connections[i][2] + else: + for connection in connections: + pose_a_idx = -1 + pose_b_idx = -1 + for j, pose in enumerate(pose_entries): + if pose[kpt_a_id] == connection[0]: + pose_a_idx = j + if pose[kpt_b_id] == connection[1]: + pose_b_idx = j + if pose_a_idx < 0 and pose_b_idx < 0: + # print('CREATE NEW POSE') + # Create new pose entry. + pose_entry = np.full(pose_entry_size, -1) + pose_entry[kpt_a_id] = connection[0] + pose_entry[kpt_b_id] = connection[1] + pose_entry[-1] = 2 + pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + pose_entries.append(pose_entry) + elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: + # Merge two disjoint components into one pose. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + do_merge_poses = True + for j in range(len(pose_b) - 2): + if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: + do_merge_poses = False + break + if not do_merge_poses: + continue + for j in range(len(pose_b) - 2): + if pose_b[j] >= 0: + pose_a[j] = pose_b[j] + # pose_a[kpt_b_id] = connection[1] + pose_a[-1] += pose_b[-1] + pose_a[-2] += pose_b[-2] + connection[2] + del pose_entries[pose_b_idx] + elif pose_a_idx >= 0: + # Add a new bone into pose. + pose = pose_entries[pose_a_idx] + if pose[kpt_b_id] < 0: + pose[-2] += all_keypoints[connection[1], 2] + pose[kpt_b_id] = connection[1] + pose[-2] += connection[2] + pose[-1] += 1 + elif pose_b_idx >= 0: + # Add a new bone into pose. + pose = pose_entries[pose_b_idx] + if pose[kpt_a_id] < 0: + pose[-2] += all_keypoints[connection[0], 2] + pose[kpt_a_id] = connection[0] + pose[-2] += connection[2] + pose[-1] += 1 + # print(pose_entries) + + filtered_entries = [] + for i in range(len(pose_entries)): + if pose_entries[i][-1] < 3: # or (pose_entries[i][-2] / pose_entries[i][-1] < 0.2): + continue + filtered_entries.append(pose_entries[i]) + pose_entries = np.asarray(filtered_entries) + # pose_entries = np.asarray(pose_entries) + return pose_entries, all_keypoints + + def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): + num_joints = 17 + coco_keypoints = [] + scores = [] + for n in range(len(pose_entries)): + if len(pose_entries[n]) == 0: + continue + keypoints = np.zeros(num_joints * 3) + # if reorder_map is None: + # reorder_map = tuple(range(num_joints)) + reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] + person_score = pose_entries[n][-2] + for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): + if target_id < 0: + continue + cx, cy, score, visibility = 0, 0, 0, 0 # keypoint not found + if keypoint_id != -1: + cx, cy, score = all_keypoints[int(keypoint_id), 0:3] + visibility = 2 + keypoints[target_id * 3 + 0] = cx + keypoints[target_id * 3 + 1] = cy + keypoints[target_id * 3 + 2] = score + coco_keypoints.append(keypoints) + scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' + # scores.append(person_score * max(0, pose_entries[n][-1])) + return np.asarray(coco_keypoints), np.asarray(scores) From 180ca3c4d5131bb80d73e209108298c7853c19c3 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 12 Nov 2020 16:28:53 +0300 Subject: [PATCH 19/58] up --- .../adapters/pose_estimation.py | 78 +++++++++++++------ 1 file changed, 54 insertions(+), 24 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 1b826c91527..afd52ab2492 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -18,6 +18,7 @@ from operator import itemgetter import cv2 +import ngraph as ng import numpy as np import torch from scipy.optimize import linear_sum_assignment @@ -103,17 +104,21 @@ def process(self, raw, identifiers, frame_meta): pad = meta.get('padding', [0, 0, 0, 0]) transpose_order = (1, 2, 0) if heatmap.shape[0] == 19 else (0, 1, 2) + s = 8 + heatmap = np.transpose(np.squeeze(heatmap), transpose_order) - heatmap = cv2.resize(heatmap, (0, 0), fx=8, fy=8, interpolation=cv2.INTER_CUBIC) + heatmap = cv2.resize(heatmap, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) heatmap = heatmap[pad[0]:heatmap.shape[0] - pad[2], pad[1]:heatmap.shape[1] - pad[3]:, :] - heatmap = cv2.resize(heatmap, (width, height), interpolation=cv2.INTER_CUBIC) - heatmap_avg = heatmap_avg + heatmap + # heatmap = cv2.resize(heatmap, (width, height), interpolation=cv2.INTER_CUBIC) + # heatmap_avg = heatmap_avg + heatmap + heatmap_avg = heatmap paf = np.transpose(np.squeeze(paf), transpose_order) - paf = cv2.resize(paf, (0, 0), fx=8, fy=8, interpolation=cv2.INTER_CUBIC) + paf = cv2.resize(paf, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) paf = paf[pad[0]:paf.shape[0] - pad[2], pad[1]:paf.shape[1] - pad[3], :] - paf = cv2.resize(paf, (width, height), interpolation=cv2.INTER_CUBIC) - paf_avg = paf_avg + paf + # paf = cv2.resize(paf, (width, height), interpolation=cv2.INTER_CUBIC) + # paf_avg = paf_avg + paf + paf_avg = paf peak_counter = 0 all_peaks = [] @@ -121,7 +126,11 @@ def process(self, raw, identifiers, frame_meta): peak_counter += self.find_peaks(heatmap_avg[:, :, part], all_peaks, peak_counter) subset, candidate = self.group_peaks(all_peaks, paf_avg) - result.append(PoseEstimationPrediction(identifier, *self.get_poses(subset, candidate))) + + scale_x = meta['scale_x'] / (8 / s) + scale_y = meta['scale_y'] / (8 / s) + # scale_x = scale_y = 1 + result.append(PoseEstimationPrediction(identifier, *self.get_poses(subset, candidate, (scale_x, scale_y)))) return result @@ -334,7 +343,7 @@ def group_peaks(self, peaks, pafs, kpt_num=20, threshold=0.05): return self._filter_subset(subset), candidates @staticmethod - def get_poses(subset, candidate): + def get_poses(subset, candidate, scales): persons_keypoints_x, persons_keypoints_y, persons_keypoints_v = [], [], [] scores = [] for subset_element in subset: @@ -355,8 +364,8 @@ def get_poses(subset, candidate): cx = cx - 0.5 + 1 # +1 for matlab consistency, coords start from 1 cy = cy - 0.5 + 1 visibility = 1 - keypoints_x[to_coco_map[position_id]] = cx - keypoints_y[to_coco_map[position_id]] = cy + keypoints_x[to_coco_map[position_id]] = cx / scales[0] + keypoints_y[to_coco_map[position_id]] = cy / scales[1] keypoints_v[to_coco_map[position_id]] = visibility scores.append(person_score * max(0, (subset_element[-1] - 1))) # -1 for Neck @@ -433,7 +442,7 @@ def process(self, raw, identifiers, frame_meta): raw_output = zip(identifiers, keypoints_heat_map, pafs, frame_meta) for identifier, heatmap, paf, meta in raw_output: s = 1 - if True: + if False: s = 8 self.decoder.delta = 0 self.decoder.out_stride = 1 @@ -925,14 +934,35 @@ def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0 self.out_stride = out_stride self.high_res_heatmaps = False self.high_res_pafs = False - nms_kernel = 5 + nms_kernel = 3 self.pool = torch.nn.MaxPool2d(nms_kernel, 1, (nms_kernel - 1) // 2) - def nms(self, heatmaps): - heatmaps = torch.as_tensor(heatmaps) + def nms_openvino_net(self, heatmap, nms_kernel=3): + + def compose(input_shape): + heatmaps = ng.parameter(shape=heatmap.shape, dtype=heatmap.dtype, name='heatmaps') + pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(5, 5), pads_begin=(2, 2), pads_end=(2, 2), strides=(1, 1)) + nms_mask = ng.equal(heatmap, pooled_heatmap) + # nms_mask_float = ng.convert_like(nms_mask, heatmap) + nms_mask_float = ng.convert(nms_mask, 'f32') + nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') + f = ng.impl.Function(ng.result(nms_heatmap, name='nms_heatmaps'), heatmaps, 'nms') + net = IENetwork(ng.impl.Function.to_capsule(f)) + return net + + net = compose(heatmap.shape) + self.exec_net = self.ie.load_network(network=net, device_name='CPU', num_requests=1) + outputs = self.exec_net.infer(heatmap) + print(tuple(outputs.keys())) + return outputs + + def nms(self, heatmaps, device='cuda'): + heatmaps = torch.as_tensor(heatmaps, device=device) maxm = self.pool(heatmaps) maxm = torch.eq(maxm, heatmaps).float() - return (heatmaps * maxm).numpy() + return (heatmaps * maxm).cpu().numpy() + # self.nms_openvino_net(heatmaps) + # return heatmaps def scale_kpts(self, kpts, scale, max_v): for kpt in kpts: @@ -1012,15 +1042,15 @@ def extract_points(self, heatmaps, nms_heatmaps): all_keypoints.append([]) continue - # Second stage of NMS. - xx = x[:, None] - x[None, :] - yy = y[:, None] - y[None, :] - dists = np.sqrt(xx * xx + yy * yy) - dists += np.tri(n, n, dtype=np.float32) * (2 * self.min_dist) - keep = dists.min(axis=0) >= self.min_dist - x = x[keep] - y = y[keep] - score = score[keep] + # # Second stage of NMS. + # xx = x[:, None] - x[None, :] + # yy = y[:, None] - y[None, :] + # dists = np.sqrt(xx * xx + yy * yy) + # dists += np.tri(n, n, dtype=np.float32) * (2 * self.min_dist) + # keep = dists.min(axis=0) >= self.min_dist + # x = x[keep] + # y = y[keep] + # score = score[keep] # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) From 312ec71669e2339f9e633c64df6eb47843305e33 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 12 Nov 2020 18:40:16 +0300 Subject: [PATCH 20/58] add various nms impls to ac adapter --- .../openpose_decoder.py | 25 ++---- .../adapters/pose_estimation.py | 90 ++++++++++++------- 2 files changed, 62 insertions(+), 53 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index 0b2bd6834e8..7ff82bcbe1d 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -5,24 +5,12 @@ import torch -# BODY_PARTS_KPT_IDS = tuple((i - 1, j - 1) for i, j in ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), -# (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17))) -# # BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), -# # (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) -# BODY_PARTS_PAF_IDS = ((12, 13), (20, 21), (14, 15), (16, 17), (22, 23), (24, 25), (0, 1), (2, 3), (4, 5), -# (6, 7), (8, 9), (10, 11), (28, 29), (30, 31), (34, 35), (32, 33), (36, 37), (18, 19), (26, 27)) - - -BODY_PARTS_KPT_IDS = tuple((i - 1, j - 1) for i, j in - [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], [10, 11], [2, 12], [12, 13], - [13, 14], [2, 1], [1, 15], [15, 17], [1, 16], [16, 18], [3, 17], [6, 18]] -) -BODY_PARTS_PAF_IDS = tuple(i - 19 for i, _ in [ - [31, 32], [39, 40], [33, 34], [35, 36], [41, 42], [43, 44], [19, 20], [21, 22], [23, 24], [25, 26], - [27, 28], [29, 30], [47, 48], [49, 50], [53, 54], [51, 52], [55, 56], [37, 38], [45, 46] -]) - class OpenPoseDecoder: + BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), + (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) + BODY_PARTS_PAF_IDS = ((12, 13), (20, 21), (14, 15), (16, 17), (22, 23), (24, 25), (0, 1), (2, 3), (4, 5), + (6, 7), (8, 9), (10, 11), (28, 29), (30, 31), (34, 35), (32, 33), (36, 37), (18, 19), (26, 27)) + def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0, delta=0.5, out_stride=8): super().__init__() self.num_joints = num_joints @@ -33,7 +21,6 @@ def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0 self.out_stride = out_stride self.high_res_heatmaps = False self.high_res_pafs = False - self.arange_cache = {10: np.arange(10)} nms_kernel = 5 self.pool = torch.nn.MaxPool2d(nms_kernel, 1, (nms_kernel - 1) // 2) @@ -173,8 +160,6 @@ def refine(self, heatmap, x, y): y[valid] += dy return x, y - - def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index afd52ab2492..e95d1cb6e39 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -21,6 +21,7 @@ import ngraph as ng import numpy as np import torch +from openvino.inference_engine import IENetwork, IECore from scipy.optimize import linear_sum_assignment from ..adapters import Adapter @@ -914,15 +915,38 @@ def get_preds(scores): return preds +class NMS: + def __init__(self, kernel): + self.ie = IECore() + self.net = self.compose(kernel) + self.exec_net = self.ie.load_network(network=self.net, device_name='CPU', num_requests=1) + + def __call__(self, heatmap): + self.net.reshape({'heatmaps': heatmap.shape}) + self.exec_net = self.ie.load_network(network=self.net, device_name='CPU', num_requests=1) + outputs = self.exec_net.infer({'heatmaps': heatmap})['nms_heatmaps'] + # print(tuple(outputs.keys())) + return outputs + + @staticmethod + def compose(kernel): + heatmap = ng.parameter(shape=[1, 19, 32, 32], dtype=np.float32, name='heatmaps') + pad = (kernel - 1) // 2 + pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(kernel, kernel), pads_begin=(pad, pad), pads_end=(pad, pad), strides=(1, 1)) + nms_mask = ng.equal(heatmap, pooled_heatmap) + # nms_mask_float = ng.convert_like(nms_mask, heatmap) + nms_mask_float = ng.convert(nms_mask, 'f32') + nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') + f = ng.impl.Function([ng.result(nms_heatmap, name='nms_heatmaps')], [heatmap], 'nms') + net = IENetwork(ng.impl.Function.to_capsule(f)) + return net + + class OpenPoseDecoder: - BODY_PARTS_KPT_IDS = tuple((i - 1, j - 1) for i, j in - [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], [10, 11], [2, 12], [12, 13], - [13, 14], [2, 1], [1, 15], [15, 17], [1, 16], [16, 18], [3, 17], [6, 18]] - ) - BODY_PARTS_PAF_IDS = tuple(i - 19 for i, _ in [ - [31, 32], [39, 40], [33, 34], [35, 36], [41, 42], [43, 44], [19, 20], [21, 22], [23, 24], [25, 26], - [27, 28], [29, 30], [47, 48], [49, 50], [53, 54], [51, 52], [55, 56], [37, 38], [45, 46] - ]) + BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), + (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) + BODY_PARTS_PAF_IDS = ((12, 13), (20, 21), (14, 15), (16, 17), (22, 23), (24, 25), (0, 1), (2, 3), (4, 5), + (6, 7), (8, 9), (10, 11), (28, 29), (30, 31), (34, 35), (32, 33), (36, 37), (18, 19), (26, 27)) def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0, delta=0.5, out_stride=8): super().__init__() @@ -934,35 +958,35 @@ def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0 self.out_stride = out_stride self.high_res_heatmaps = False self.high_res_pafs = False - nms_kernel = 3 - self.pool = torch.nn.MaxPool2d(nms_kernel, 1, (nms_kernel - 1) // 2) - - def nms_openvino_net(self, heatmap, nms_kernel=3): - - def compose(input_shape): - heatmaps = ng.parameter(shape=heatmap.shape, dtype=heatmap.dtype, name='heatmaps') - pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(5, 5), pads_begin=(2, 2), pads_end=(2, 2), strides=(1, 1)) - nms_mask = ng.equal(heatmap, pooled_heatmap) - # nms_mask_float = ng.convert_like(nms_mask, heatmap) - nms_mask_float = ng.convert(nms_mask, 'f32') - nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') - f = ng.impl.Function(ng.result(nms_heatmap, name='nms_heatmaps'), heatmaps, 'nms') - net = IENetwork(ng.impl.Function.to_capsule(f)) - return net - - net = compose(heatmap.shape) - self.exec_net = self.ie.load_network(network=net, device_name='CPU', num_requests=1) - outputs = self.exec_net.infer(heatmap) - print(tuple(outputs.keys())) - return outputs - def nms(self, heatmaps, device='cuda'): + self.nms_kernel = 3 + self.nms_ov = NMS(self.nms_kernel) + + def nms_skimage(self, heatmaps, kernel): + from skimage.measure import block_reduce + + # Max pooling kernel x kernel with stride 1 x 1. + p = (kernel - 1) // 2 + pooled = np.zeros(heatmaps.shape, dtype=np.float32) + hmap = np.pad(heatmaps, ((0, 0), (0, 0), (p, p), (p, p))) + h, w = heatmaps.shape[-2:] + for i in range(kernel): + si = (h + 2 * p - i) // kernel + for j in range(kernel): + sj = (w + 2 * p - j) // kernel + pooled[..., i::kernel, j::kernel] = block_reduce(hmap[..., i:i + si * kernel, j:j + sj * kernel], (1, 1, kernel, kernel), np.max) + return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) + + def nms_pytorch(self, heatmaps, kernel, device='cpu'): heatmaps = torch.as_tensor(heatmaps, device=device) - maxm = self.pool(heatmaps) + maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=kernel, stride=1, padding=(kernel - 1) // 2) maxm = torch.eq(maxm, heatmaps).float() return (heatmaps * maxm).cpu().numpy() - # self.nms_openvino_net(heatmaps) - # return heatmaps + + def nms(self, heatmaps): + # return self.nms_ov(heatmaps) + return self.nms_skimage(heatmaps, self.nms_kernel) + # return self.nms_pytorch(heatmaps, self.nms_kernel) def scale_kpts(self, kpts, scale, max_v): for kpt in kpts: From 43842091f0dfb5a9a5ea65786b9bcaf8cb11130f Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 12 Nov 2020 18:40:42 +0300 Subject: [PATCH 21/58] add openvino nms to demo model --- .../human_pose_estimation_demo/model.py | 40 ++++++++++++++++--- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 83bfa006018..b8ff59e315d 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -4,7 +4,9 @@ from collections import deque import cv2 +import ngraph as ng import numpy as np +from openvino.inference_engine import IENetwork from .decoder import AssociativeEmbeddingDecoder from .openpose_decoder import OpenPoseDecoder @@ -45,6 +47,7 @@ def reshape_net(self, inputs): reshape_needed = True break if reshape_needed: + print('reshape net to ', input_shapes) self.await_all() self.net.reshape(input_shapes) self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) @@ -98,8 +101,32 @@ def await_any(self): class HPEOpenPose(Model): - def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, **kwargs): + def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, device='CPU', max_num_requests=1, **kwargs): super().__init__(*args, **kwargs) + + function = ng.function_from_cnn(self.net) + paf = function.get_output_op(0) + paf = paf.inputs()[0].get_source_output().get_node() + paf.set_friendly_name('pafs') + heatmap = function.get_output_op(1) + heatmap = heatmap.inputs()[0].get_source_output().get_node() + heatmap.set_friendly_name('heatmaps') + pooled_heatmap = ng.max_pool(heatmap,kernel_shape=(5, 5), pads_begin=(2, 2), pads_end=(2, 2), strides=(1, 1)) + nms_mask = ng.equal(heatmap, pooled_heatmap) + # nms_mask_float = ng.convert_like(nms_mask, heatmap) + nms_mask_float = ng.convert(nms_mask, 'f32') + nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') + f = ng.impl.Function( + [ng.result(heatmap, name='heatmaps'), + ng.result(nms_heatmap, name='nms_heatmaps'), + ng.result(paf, name='pafs')], + function.get_parameters(), 'hpe-0001') + self.net = IENetwork(ng.impl.Function.to_capsule(f)) + print(tuple(layer_name for layer_name in self.net.outputs)) + self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) + self.requests = self.exec_net.requests + self.empty_requests = deque(self.requests) + self.keep_aspect_ratio_resize = keep_aspect_ratio_resize self.size_divisor = size_divisor @@ -110,12 +137,15 @@ def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, **kwarg # self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) # self.pafs_blob_name = find_layer_by_name('pafs', self.net.outputs) - self.pafs_blob_name = 'Mconv7_stage2_L1' - self.heatmaps_blob_name = 'Mconv7_stage2_L2' - self.nms_heatmaps_blob_name = None + # self.pafs_blob_name = 'Mconv7_stage2_L1' + # self.heatmaps_blob_name = 'Mconv7_stage2_L2' + self.pafs_blob_name = 'pafs' + self.heatmaps_blob_name = 'heatmaps' + self.nms_heatmaps_blob_name = 'nms_heatmaps' - self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] + self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - 1 self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] + self.target_size = 256 self.decoder = OpenPoseDecoder(num_joints=self.num_joints) From 7d21e4fb1313f602a3c211b2c52b7a1bd69dadb7 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 10:42:28 +0300 Subject: [PATCH 22/58] clean up --- .../adapters/pose_estimation.py | 137 +++++------------- 1 file changed, 34 insertions(+), 103 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index e95d1cb6e39..a70d04cecf5 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -25,7 +25,7 @@ from scipy.optimize import linear_sum_assignment from ..adapters import Adapter -from ..config import ConfigValidator, StringField, ConfigError +from ..config import ConfigValidator, StringField, ConfigError, NumberField from ..preprocessor import ObjectCropWithScale from ..representation import PoseEstimationPrediction from ..utils import contains_all, contains_any @@ -397,14 +397,18 @@ def parameters(cls): 'keypoints_heatmap_out': StringField( description="Name of output layer with keypoints heatmaps.", optional=True ), + 'upscale_factor': NumberField( + description="Upscaling factor for output feature maps before postprocessing.", + value_type=float, min_value=1, default=1, optional=True + ), }) - return parameters def validate_config(self): super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) def configure(self): + self.upscale_factor = self.get_value_from_config('upscale_factor') self.part_affinity_fields = self.get_value_from_config('part_affinity_fields_out') self.keypoints_heatmap = self.get_value_from_config('keypoints_heatmap_out') self.concat_out = self.part_affinity_fields is None and self.keypoints_heatmap is None @@ -417,7 +421,7 @@ def configure(self): ) self._keypoints_heatmap_bias = self.keypoints_heatmap + '/add_' self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' - self.decoder = OpenPoseDecoder(num_joints=18) + self.decoder = OpenPoseDecoder(num_joints=18, out_stride=1) def process(self, raw, identifiers, frame_meta): result = [] @@ -442,25 +446,15 @@ def process(self, raw, identifiers, frame_meta): pafs = concat_out[:, keypoints_num:, :] raw_output = zip(identifiers, keypoints_heat_map, pafs, frame_meta) for identifier, heatmap, paf, meta in raw_output: - s = 1 - if False: - s = 8 + output_h, output_w = heatmap.shape[-2:] + if self.upscale_factor > 1: self.decoder.delta = 0 - self.decoder.out_stride = 1 - self.decoder.min_dist = 6.0 - pad = meta.get('padding', [0, 0, 0, 0]) - transpose_order = (1, 2, 0) - heatmap = np.transpose(heatmap, transpose_order) - heatmap = cv2.resize(heatmap, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) - heatmap = heatmap[pad[0]:heatmap.shape[0] - pad[2], pad[1]:heatmap.shape[1] - pad[3]:, :] + heatmap = np.transpose(heatmap, (1, 2, 0)) + heatmap = cv2.resize(heatmap, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, interpolation=cv2.INTER_CUBIC) heatmap = np.transpose(heatmap, (2, 0, 1)) - paf = np.transpose(np.squeeze(paf), transpose_order) - paf = cv2.resize(paf, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) - paf = paf[pad[0]:paf.shape[0] - pad[2], pad[1]:paf.shape[1] - pad[3], :] + paf = np.transpose(np.squeeze(paf), (1, 2, 0)) + paf = cv2.resize(paf, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, interpolation=cv2.INTER_CUBIC) paf = np.transpose(paf, (2, 0, 1)) - else: - self.decoder.min_dist = 6.0 / 8.0 - # print(heatmap.shape, paf.shape) hmap = heatmap[None] nms_hmap = self.decoder.nms(hmap) poses, scores = self.decoder(hmap, nms_hmap, paf[None]) @@ -477,15 +471,13 @@ def process(self, raw, identifiers, frame_meta): scores = np.asarray(scores).astype(float) scale_x = meta['scale_x'] scale_y = meta['scale_y'] - - poses[:, :, 0] /= scale_x / (8 / s) - poses[:, :, 1] /= scale_y / (8 / s) + input_h, input_w = next(iter(meta['input_shape'].values()))[-2:] + output_scale_x = input_w / output_w + output_scale_y = input_h / output_h + poses[:, :, 0] /= scale_x / (output_scale_x / self.upscale_factor) + poses[:, :, 1] /= scale_y / (output_scale_y / self.upscale_factor) point_scores = poses[:, :, 2] - # print(poses[:, :, 0]) - # print(poses[:, :, 1]) - # print(meta) - # exit(0) result.append(PoseEstimationPrediction( identifier, poses[:, :, 0], @@ -925,7 +917,6 @@ def __call__(self, heatmap): self.net.reshape({'heatmaps': heatmap.shape}) self.exec_net = self.ie.load_network(network=self.net, device_name='CPU', num_requests=1) outputs = self.exec_net.infer({'heatmaps': heatmap})['nms_heatmaps'] - # print(tuple(outputs.keys())) return outputs @staticmethod @@ -943,17 +934,16 @@ def compose(kernel): class OpenPoseDecoder: + BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) - BODY_PARTS_PAF_IDS = ((12, 13), (20, 21), (14, 15), (16, 17), (22, 23), (24, 25), (0, 1), (2, 3), (4, 5), - (6, 7), (8, 9), (10, 11), (28, 29), (30, 31), (34, 35), (32, 33), (36, 37), (18, 19), (26, 27)) + BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) - def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0, delta=0.5, out_stride=8): + def __init__(self, num_joints, max_points=100, score_threshold=0.1, delta=0.5, out_stride=8): super().__init__() self.num_joints = num_joints self.max_points = max_points self.score_threshold = score_threshold - self.min_dist = min_dist self.delta = delta self.out_stride = out_stride self.high_res_heatmaps = False @@ -988,56 +978,25 @@ def nms(self, heatmaps): return self.nms_skimage(heatmaps, self.nms_kernel) # return self.nms_pytorch(heatmaps, self.nms_kernel) - def scale_kpts(self, kpts, scale, max_v): - for kpt in kpts: - kpt[0] = max(0, min(kpt[0] * scale, max_v[0])) - kpt[1] = max(0, min(kpt[1] * scale, max_v[1])) - return kpts - def __call__(self, heatmaps, nms_heatmaps, pafs): - pafs = np.transpose(pafs, (0, 2, 3, 1)) - batch_size, _, h, w = heatmaps.shape - # hup = h * self.out_stride - # wup = w * self.out_stride - assert batch_size == 1 - - # min_dist = self.min_dist - # if not self.high_res_heatmaps: - # self.min_dist = 6.0 / self.out_stride + assert batch_size == 1, 'Batch size of 1 only supported' + pafs = np.transpose(pafs, (0, 2, 3, 1)) keypoints = self.extract_points(heatmaps, nms_heatmaps) - # self.min_dist = min_dist - - # if self.high_res_heatmaps: - # for kpts in keypoints: - # self.scale_kpts(kpts, 1 / self.out_stride, (w - 1, h - 1)) if self.delta > 0: # To adjust coordinates' flooring in heatmaps target generation. for kpts in keypoints: - for kpt in kpts: - kpt[0] = min(kpt[0] + self.delta, w - 1) - kpt[1] = min(kpt[1] + self.delta, h - 1) - - # if self.high_res_pafs: - # for kpts in keypoints: - # self.scale_kpts(kpts, self.out_stride, (wup - 1, hup - 1)) + kpts[:, :2] += self.delta + np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) + np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) - # exit(0) - grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints, None) - # print(grouped_kpts) - # print(scores) - # exit(0) if len(grouped_kpts) > 0: - grouped_kpts = np.asarray(grouped_kpts) + grouped_kpts = np.asarray(grouped_kpts, dtype=np.float32) grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) - # if not self.high_res_pafs: - # grouped_kpts[:, :, :2] *= self.out_stride - # grouped_kpts[:, :, 0].clip(0, wup - 1) - # grouped_kpts[:, :, 1].clip(0, hup - 1) else: grouped_kpts = np.empty((0, 17, 3), dtype=np.float32) scores = np.zeros(0, dtype=np.float32) @@ -1063,36 +1022,20 @@ def extract_points(self, heatmaps, nms_heatmaps): n = len(x) if n == 0: - all_keypoints.append([]) + all_keypoints.append(np.empty((0, 4), dtype=np.float32)) continue - # # Second stage of NMS. - # xx = x[:, None] - x[None, :] - # yy = y[:, None] - y[None, :] - # dists = np.sqrt(xx * xx + yy * yy) - # dists += np.tri(n, n, dtype=np.float32) * (2 * self.min_dist) - # keep = dists.min(axis=0) >= self.min_dist - # x = x[keep] - # y = y[keep] - # score = score[keep] - # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) np.core.umath.clip(x, 0, w - 1, out=x) np.core.umath.clip(y, 0, h - 1, out=y) # Pack resulting points. - # keypoints = [] - # for a, b, c in zip(x, y, score): - # keypoints.append([a, b, c, keypoint_id]) - # keypoint_id += 1 - n = len(x) keypoints = np.empty((n, 4), dtype=np.float32) keypoints[:, 0] = x keypoints[:, 1] = y keypoints[:, 2] = score keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) - # keypoints = np.stack([x, y, score, np.arange(keypoint_id, keypoint_id + n)], axis=1).astype(dtype=np.float32) keypoint_id += n all_keypoints.append(keypoints) @@ -1125,14 +1068,13 @@ def refine(self, heatmap, x, y): def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): - all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist], dtype=np.float32) + all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] point_num = 10 grid = np.arange(point_num, dtype=np.float32).reshape(1, -1, 1) for part_id, paf_channel in enumerate(bones_to_channels): - # print(part_id) part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] kpt_a_id, kpt_b_id = skeleton[part_id] @@ -1144,8 +1086,8 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if num_kpts_a == 0 or num_kpts_b == 0: continue - a = np.asarray([p[0:2] for p in kpts_a], dtype=np.float32) - b = np.asarray([p[0:2] for p in kpts_b], dtype=np.float32) + a = kpts_a[:, :2] + b = kpts_b[:, :2] n, m = len(a), len(b) a = np.broadcast_to(a[None], (m, n, 2)) @@ -1172,7 +1114,6 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p connections = [] for t, i, j in zip(valid_limbs, a_idx, b_idx): connections.append([i, j, score[t], score[t] + kpts_a[i][2] + kpts_b[j][2]]) - # print(connections) if len(connections) > 0: connections = sorted(connections, key=itemgetter(2), reverse=True) @@ -1193,10 +1134,6 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if len(connections) == 0: continue - # for i in range(len(connections)): - # pose_entries.append(init_pose(kpt_a_id, kpt_b_id, connections[i])) - # continue - if part_id == 0: pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] for i in range(len(connections)): @@ -1215,7 +1152,6 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if pose[kpt_b_id] == connection[1]: pose_b_idx = j if pose_a_idx < 0 and pose_b_idx < 0: - # print('CREATE NEW POSE') # Create new pose entry. pose_entry = np.full(pose_entry_size, -1) pose_entry[kpt_a_id] = connection[0] @@ -1257,15 +1193,13 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p pose[kpt_a_id] = connection[0] pose[-2] += connection[2] pose[-1] += 1 - # print(pose_entries) filtered_entries = [] for i in range(len(pose_entries)): - if pose_entries[i][-1] < 3: # or (pose_entries[i][-2] / pose_entries[i][-1] < 0.2): + if pose_entries[i][-1] < 3: continue filtered_entries.append(pose_entries[i]) pose_entries = np.asarray(filtered_entries) - # pose_entries = np.asarray(pose_entries) return pose_entries, all_keypoints def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): @@ -1276,8 +1210,6 @@ def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): if len(pose_entries[n]) == 0: continue keypoints = np.zeros(num_joints * 3) - # if reorder_map is None: - # reorder_map = tuple(range(num_joints)) reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] person_score = pose_entries[n][-2] for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): @@ -1287,10 +1219,9 @@ def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): if keypoint_id != -1: cx, cy, score = all_keypoints[int(keypoint_id), 0:3] visibility = 2 - keypoints[target_id * 3 + 0] = cx - keypoints[target_id * 3 + 1] = cy + keypoints[target_id * 3 + 0] = cx * self.out_stride + keypoints[target_id * 3 + 1] = cy * self.out_stride keypoints[target_id * 3 + 2] = score coco_keypoints.append(keypoints) scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' - # scores.append(person_score * max(0, pose_entries[n][-1])) return np.asarray(coco_keypoints), np.asarray(scores) From da298ff9f69c69d166c44b4ac2244bc7203e12d6 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 11:31:56 +0300 Subject: [PATCH 23/58] align decoder in demo and AC --- .../openpose_decoder.py | 120 +++++++----------- 1 file changed, 44 insertions(+), 76 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index 7ff82bcbe1d..a18f0257af1 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -2,80 +2,73 @@ from operator import itemgetter import numpy as np -import torch class OpenPoseDecoder: + BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) - BODY_PARTS_PAF_IDS = ((12, 13), (20, 21), (14, 15), (16, 17), (22, 23), (24, 25), (0, 1), (2, 3), (4, 5), - (6, 7), (8, 9), (10, 11), (28, 29), (30, 31), (34, 35), (32, 33), (36, 37), (18, 19), (26, 27)) + BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) - def __init__(self, num_joints, max_points=100, score_threshold=0.1, min_dist=6.0, delta=0.5, out_stride=8): + def __init__(self, num_joints, max_points=100, score_threshold=0.1, delta=0.5, out_stride=8): super().__init__() self.num_joints = num_joints self.max_points = max_points self.score_threshold = score_threshold - self.min_dist = min_dist self.delta = delta self.out_stride = out_stride self.high_res_heatmaps = False self.high_res_pafs = False - nms_kernel = 5 - self.pool = torch.nn.MaxPool2d(nms_kernel, 1, (nms_kernel - 1) // 2) - def nms(self, heatmaps): - heatmaps = torch.as_tensor(heatmaps) - maxm = self.pool(heatmaps) + self.nms_kernel = 3 + + def nms_skimage(self, heatmaps, kernel): + from skimage.measure import block_reduce + + # Max pooling kernel x kernel with stride 1 x 1. + p = (kernel - 1) // 2 + pooled = np.zeros(heatmaps.shape, dtype=np.float32) + hmap = np.pad(heatmaps, ((0, 0), (0, 0), (p, p), (p, p))) + h, w = heatmaps.shape[-2:] + for i in range(kernel): + si = (h + 2 * p - i) // kernel + for j in range(kernel): + sj = (w + 2 * p - j) // kernel + pooled[..., i::kernel, j::kernel] = block_reduce(hmap[..., i:i + si * kernel, j:j + sj * kernel], (1, 1, kernel, kernel), np.max) + return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) + + def nms_pytorch(self, heatmaps, kernel, device='cpu'): + import torch + + heatmaps = torch.as_tensor(heatmaps, device=device) + maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=kernel, stride=1, padding=(kernel - 1) // 2) maxm = torch.eq(maxm, heatmaps).float() - return (heatmaps * maxm).numpy() + return (heatmaps * maxm).cpu().numpy() - def scale_kpts(self, kpts, scale, max_v): - for kpt in kpts: - kpt[0] = max(0, min(kpt[0] * scale, max_v[0])) - kpt[1] = max(0, min(kpt[1] * scale, max_v[1])) - return kpts + def nms(self, heatmaps): + # return self.nms_ov(heatmaps) + # return self.nms_skimage(heatmaps, self.nms_kernel) + return self.nms_pytorch(heatmaps, self.nms_kernel) def __call__(self, heatmaps, nms_heatmaps, pafs): - pafs = np.transpose(pafs, (0, 2, 3, 1)) - batch_size, _, h, w = heatmaps.shape - hup = h * self.out_stride - wup = w * self.out_stride - assert batch_size == 1 - - min_dist = self.min_dist - if not self.high_res_heatmaps: - self.min_dist = 6.0 / self.out_stride + assert batch_size == 1, 'Batch size of 1 only supported' + pafs = np.transpose(pafs, (0, 2, 3, 1)) keypoints = self.extract_points(heatmaps, nms_heatmaps) - self.min_dist = min_dist - - if self.high_res_heatmaps: - for kpts in keypoints: - self.scale_kpts(kpts, 1 / self.out_stride, (w - 1, h - 1)) if self.delta > 0: # To adjust coordinates' flooring in heatmaps target generation. for kpts in keypoints: - for kpt in kpts: - kpt[0] = min(kpt[0] + self.delta, w - 1) - kpt[1] = min(kpt[1] + self.delta, h - 1) - - if self.high_res_pafs: - for kpts in keypoints: - self.scale_kpts(kpts, self.out_stride, (wup - 1, hup - 1)) + kpts[:, :2] += self.delta + np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) + np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) - grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints, None) if len(grouped_kpts) > 0: - grouped_kpts = np.asarray(grouped_kpts) + grouped_kpts = np.asarray(grouped_kpts, dtype=np.float32) grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) - if not self.high_res_pafs: - grouped_kpts[:, :, :2] *= self.out_stride - grouped_kpts[:, :, 0].clip(0, wup - 1) - grouped_kpts[:, :, 1].clip(0, hup - 1) else: grouped_kpts = np.empty((0, 17, 3), dtype=np.float32) scores = np.zeros(0, dtype=np.float32) @@ -101,36 +94,20 @@ def extract_points(self, heatmaps, nms_heatmaps): n = len(x) if n == 0: - all_keypoints.append([]) + all_keypoints.append(np.empty((0, 4), dtype=np.float32)) continue - # Second stage of NMS. - xx = x[:, None] - x[None, :] - yy = y[:, None] - y[None, :] - dists = np.sqrt(xx * xx + yy * yy) - dists += np.tri(n, n, dtype=np.float32) * (2 * self.min_dist) - keep = dists.min(axis=0) >= self.min_dist - x = x[keep] - y = y[keep] - score = score[keep] - # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) np.core.umath.clip(x, 0, w - 1, out=x) np.core.umath.clip(y, 0, h - 1, out=y) # Pack resulting points. - # keypoints = [] - # for a, b, c in zip(x, y, score): - # keypoints.append([a, b, c, keypoint_id]) - # keypoint_id += 1 - n = len(x) keypoints = np.empty((n, 4), dtype=np.float32) keypoints[:, 0] = x keypoints[:, 1] = y keypoints[:, 2] = score keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) - # keypoints = np.stack([x, y, score, np.arange(keypoint_id, keypoint_id + n)], axis=1).astype(dtype=np.float32) keypoint_id += n all_keypoints.append(keypoints) @@ -163,7 +140,7 @@ def refine(self, heatmap, x, y): def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): - all_keypoints = np.asarray([item for sublist in all_keypoints_by_type for item in sublist], dtype=np.float32) + all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] point_num = 10 @@ -181,8 +158,8 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if num_kpts_a == 0 or num_kpts_b == 0: continue - a = np.asarray([p[0:2] for p in kpts_a], dtype=np.float32) - b = np.asarray([p[0:2] for p in kpts_b], dtype=np.float32) + a = kpts_a[:, :2] + b = kpts_b[:, :2] n, m = len(a), len(b) a = np.broadcast_to(a[None], (m, n, 2)) @@ -229,12 +206,8 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if len(connections) == 0: continue - # for i in range(len(connections)): - # pose_entries.append(init_pose(kpt_a_id, kpt_b_id, connections[i])) - # continue - if part_id == 0: - pose_entries = [np.full(pose_entry_size, -1) for _ in range(len(connections))] + pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] for i in range(len(connections)): pose_entries[i][kpt_a_id] = connections[i][0] pose_entries[i][kpt_b_id] = connections[i][1] @@ -251,7 +224,6 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if pose[kpt_b_id] == connection[1]: pose_b_idx = j if pose_a_idx < 0 and pose_b_idx < 0: - # print('CREATE NEW POSE') # Create new pose entry. pose_entry = np.full(pose_entry_size, -1) pose_entry[kpt_a_id] = connection[0] @@ -296,11 +268,10 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p filtered_entries = [] for i in range(len(pose_entries)): - if pose_entries[i][-1] < 3: # or (pose_entries[i][-2] / pose_entries[i][-1] < 0.2): + if pose_entries[i][-1] < 3: continue filtered_entries.append(pose_entries[i]) pose_entries = np.asarray(filtered_entries) - # pose_entries = np.asarray(pose_entries) return pose_entries, all_keypoints def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): @@ -311,8 +282,6 @@ def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): if len(pose_entries[n]) == 0: continue keypoints = np.zeros(num_joints * 3) - # if reorder_map is None: - # reorder_map = tuple(range(num_joints)) reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] person_score = pose_entries[n][-2] for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): @@ -322,10 +291,9 @@ def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): if keypoint_id != -1: cx, cy, score = all_keypoints[int(keypoint_id), 0:3] visibility = 2 - keypoints[target_id * 3 + 0] = cx - keypoints[target_id * 3 + 1] = cy + keypoints[target_id * 3 + 0] = cx * self.out_stride + keypoints[target_id * 3 + 1] = cy * self.out_stride keypoints[target_id * 3 + 2] = score coco_keypoints.append(keypoints) scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' - # scores.append(person_score * max(0, pose_entries[n][-1])) return np.asarray(coco_keypoints), np.asarray(scores) From 12e6434321fb1988300be04b01013f45b26dcc58 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 11:33:49 +0300 Subject: [PATCH 24/58] refactor visualization --- .../visualization.py | 56 +++++++++---------- 1 file changed, 25 insertions(+), 31 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py index e8f0d207dbf..a80df1f9320 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py @@ -2,51 +2,45 @@ import numpy as np -default_skeleton = ((16, 14), (14, 12), (17, 15), (15, 13), (12, 13), (6, 12), (7, 13), (6, 7), - (6, 8), (7, 9), (8, 10), (9, 11), (2, 3), (1, 2), (1, 3), (2, 4), (3, 5), (4, 6), (5, 7)) +default_skeleton = ((15, 13), (13, 11), (16, 14), (14, 12), (11, 12), (5, 11), (6, 12), (5, 6), + (5, 7), (6, 8), (7, 9), (8, 10), (1, 2), (0, 1), (0, 2), (1, 3), (2, 4), (3, 5), (4, 6)) - -def show_poses(img, poses, scores, pose_score_threshold=0.5, point_score_threshold=0.5, skeleton=None): - if poses.size == 0: - return img - - if skeleton is None: - skeleton = default_skeleton - - colors = ( +colors = ( (255, 0, 0), (255, 0, 255), (170, 0, 255), (255, 0, 85), (255, 0, 170), (85, 255, 0), (255, 170, 0), (0, 255, 0), (255, 255, 0), (0, 255, 85), (170, 255, 0), (0, 85, 255), (0, 255, 170), (0, 0, 255), (0, 255, 255), (85, 0, 255), (0, 170, 255)) + +def show_poses(img, poses, scores, pose_score_threshold=0.5, point_score_threshold=0.5, skeleton=None, draw_ellipses=False): + if poses.size == 0: + return img + if skeleton is None: + skeleton = default_skeleton stick_width = 4 - for idx, (pose, pose_score) in enumerate(zip(poses, scores)): + img_limbs = np.copy(img) + for pose, pose_score in zip(poses, scores): if pose_score <= pose_score_threshold: continue - points = pose[:, :2].astype(int) + points = pose[:, :2].astype(int).tolist() points_scores = pose[:, 2] + # Draw joints. for i, (p, v) in enumerate(zip(points, points_scores)): if v > point_score_threshold: cv2.circle(img, tuple(p), 1, colors[i], 2) - - img_x = np.copy(img) - for idx, (pose, pose_score) in enumerate(zip(poses, scores)): - if pose_score <= pose_score_threshold: - continue - points = pose[:, :2].astype(int) - points_scores = pose[:, 2] - for bone in skeleton: - i = bone[0] - 1 - j = bone[1] - 1 + # Draw limbs. + for i, j in skeleton: if points_scores[i] > point_score_threshold and points_scores[j] > point_score_threshold: - middle = (points[i] + points[j]) // 2 - vec = points[i] - points[j] - length = np.sqrt((vec * vec).sum()) - angle = int(np.arctan2(vec[1], vec[0]) * 180 / np.pi) - polygon = cv2.ellipse2Poly(tuple(middle), (int(length / 2), min(int(length / 50), stick_width)), angle, 0, 360, 1) - cv2.fillConvexPoly(img_x, polygon, colors[j]) - cv2.addWeighted(img, 0.4, img_x, 0.6, 0, dst=img) - + if draw_ellipses: + middle = (points[i] + points[j]) // 2 + vec = points[i] - points[j] + length = np.sqrt((vec * vec).sum()) + angle = int(np.arctan2(vec[1], vec[0]) * 180 / np.pi) + polygon = cv2.ellipse2Poly(tuple(middle), (int(length / 2), min(int(length / 50), stick_width)), angle, 0, 360, 1) + cv2.fillConvexPoly(img_limbs, polygon, colors[j]) + else: + cv2.line(img_limbs, tuple(points[i]), tuple(points[j]), color=colors[j], thickness=stick_width) + cv2.addWeighted(img, 0.4, img_limbs, 0.6, 0, dst=img) return img From 5e1882404a86792585f1ad285ee4e8268ae316cd Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 12:49:10 +0300 Subject: [PATCH 25/58] clean up --- .../human_pose_estimation_demo/openpose_decoder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index a18f0257af1..c36efdae1b3 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -65,7 +65,7 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) - grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints, None) + grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints) if len(grouped_kpts) > 0: grouped_kpts = np.asarray(grouped_kpts, dtype=np.float32) grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) @@ -274,7 +274,7 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p pose_entries = np.asarray(filtered_entries) return pose_entries, all_keypoints - def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): + def convert_to_coco_format(self, pose_entries, all_keypoints): num_joints = 17 coco_keypoints = [] scores = [] From 7af051b9480eb78f17350ea97f2f798a1cf3a741 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 12:57:46 +0300 Subject: [PATCH 26/58] add cpp postprocessing support --- .../human_pose_estimation_demo/model.py | 72 ++++++++++++------- 1 file changed, 46 insertions(+), 26 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index b8ff59e315d..96a1c5c0548 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -101,9 +101,13 @@ def await_any(self): class HPEOpenPose(Model): - def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, device='CPU', max_num_requests=1, **kwargs): + def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, + device='CPU', max_num_requests=1, use_cpp_postprocessing=False, + target_size=256, **kwargs): super().__init__(*args, **kwargs) + self.use_cpp_postprocessing = use_cpp_postprocessing + self.nms_heatmaps_blob_name = None function = ng.function_from_cnn(self.net) paf = function.get_output_op(0) paf = paf.inputs()[0].get_source_output().get_node() @@ -111,18 +115,28 @@ def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, device= heatmap = function.get_output_op(1) heatmap = heatmap.inputs()[0].get_source_output().get_node() heatmap.set_friendly_name('heatmaps') - pooled_heatmap = ng.max_pool(heatmap,kernel_shape=(5, 5), pads_begin=(2, 2), pads_end=(2, 2), strides=(1, 1)) - nms_mask = ng.equal(heatmap, pooled_heatmap) - # nms_mask_float = ng.convert_like(nms_mask, heatmap) - nms_mask_float = ng.convert(nms_mask, 'f32') - nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') - f = ng.impl.Function( - [ng.result(heatmap, name='heatmaps'), - ng.result(nms_heatmap, name='nms_heatmaps'), - ng.result(paf, name='pafs')], - function.get_parameters(), 'hpe-0001') - self.net = IENetwork(ng.impl.Function.to_capsule(f)) - print(tuple(layer_name for layer_name in self.net.outputs)) + if not self.use_cpp_postprocessing: + pooled_heatmap = ng.max_pool(heatmap,kernel_shape=(5, 5), pads_begin=(2, 2), pads_end=(2, 2), strides=(1, 1)) + nms_mask = ng.equal(heatmap, pooled_heatmap) + # nms_mask_float = ng.convert_like(nms_mask, heatmap) + nms_mask_float = ng.convert(nms_mask, 'f32') + nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') + f = ng.impl.Function( + [ng.result(heatmap, name='heatmaps'), + ng.result(nms_heatmap, name='nms_heatmaps'), + ng.result(paf, name='pafs')], + function.get_parameters(), 'hpe-0001') + self.net = IENetwork(ng.impl.Function.to_capsule(f)) + + self.nms_heatmaps_blob_name = 'nms_heatmaps' + else: + self.reorder_map = np.array([0, 15, 14, 17, 16, 5, 2, 6, 3, 7, 4, 11, 8, 12, 9, 13, 10]) + f = ng.impl.Function( + [ng.result(heatmap, name='heatmaps'), + ng.result(paf, name='pafs')], + function.get_parameters(), 'hpe-0001') + self.net = IENetwork(ng.impl.Function.to_capsule(f)) + self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) self.requests = self.exec_net.requests self.empty_requests = deque(self.requests) @@ -133,19 +147,12 @@ def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, device= self.image_blob_name = self._get_inputs(self.net) self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] - # self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) - # self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) - # self.pafs_blob_name = find_layer_by_name('pafs', self.net.outputs) - - # self.pafs_blob_name = 'Mconv7_stage2_L1' - # self.heatmaps_blob_name = 'Mconv7_stage2_L2' self.pafs_blob_name = 'pafs' self.heatmaps_blob_name = 'heatmaps' - self.nms_heatmaps_blob_name = 'nms_heatmaps' self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - 1 self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] - self.target_size = 256 + self.target_size = target_size self.decoder = OpenPoseDecoder(num_joints=self.num_joints) @@ -189,12 +196,25 @@ def preprocess(self, inputs): def postprocess(self, outputs, meta): heatmaps = outputs[self.heatmaps_blob_name] - if self.nms_heatmaps_blob_name: - nms_heatmaps = outputs[self.nms_heatmaps_blob_name] - else: - nms_heatmaps = self.decoder.nms(heatmaps) pafs = outputs[self.pafs_blob_name] - poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) + + if self.use_cpp_postprocessing: + from pose_extractor import extract_poses + + upsample_ratio = 4 + poses = extract_poses(heatmaps[0], pafs[0], upsample_ratio) + # scale coordinates to features space + scores = poses[:, -1] + poses = poses[:, :-1].reshape(-1, 18, 3) + poses = poses[:, self.reorder_map, :] + poses[:, :, :2] /= upsample_ratio / 8 + else: + if self.nms_heatmaps_blob_name: + nms_heatmaps = outputs[self.nms_heatmaps_blob_name] + else: + nms_heatmaps = self.decoder.nms(heatmaps) + poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) + # Rescale poses to the original image. original_image_shape = meta['original_shape'] resized_image_shape = meta['resized_shape'] From 59d9bb40f3620f0b4bf37dfd204480c42afbac9a Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 19:15:26 +0300 Subject: [PATCH 27/58] refactor openpose decoder (wip) --- .../openpose_decoder.py | 272 ++++++++---------- 1 file changed, 125 insertions(+), 147 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index c36efdae1b3..ae6f545c68e 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -10,70 +10,43 @@ class OpenPoseDecoder: (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) - def __init__(self, num_joints, max_points=100, score_threshold=0.1, delta=0.5, out_stride=8): - super().__init__() + def __init__(self, num_joints=18, skeleton=BODY_PARTS_KPT_IDS, paf_indices=BODY_PARTS_PAF_IDS, + max_points=100, score_threshold=0.1, min_paf_alignment_score=0.05, delta=0.5, out_stride=8): self.num_joints = num_joints + self.skeleton = skeleton + self.paf_indices = paf_indices self.max_points = max_points self.score_threshold = score_threshold + self.min_paf_alignment_score = min_paf_alignment_score self.delta = delta self.out_stride = out_stride - self.high_res_heatmaps = False - self.high_res_pafs = False - self.nms_kernel = 3 - - def nms_skimage(self, heatmaps, kernel): - from skimage.measure import block_reduce - - # Max pooling kernel x kernel with stride 1 x 1. - p = (kernel - 1) // 2 - pooled = np.zeros(heatmaps.shape, dtype=np.float32) - hmap = np.pad(heatmaps, ((0, 0), (0, 0), (p, p), (p, p))) - h, w = heatmaps.shape[-2:] - for i in range(kernel): - si = (h + 2 * p - i) // kernel - for j in range(kernel): - sj = (w + 2 * p - j) // kernel - pooled[..., i::kernel, j::kernel] = block_reduce(hmap[..., i:i + si * kernel, j:j + sj * kernel], (1, 1, kernel, kernel), np.max) - return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) - - def nms_pytorch(self, heatmaps, kernel, device='cpu'): - import torch - - heatmaps = torch.as_tensor(heatmaps, device=device) - maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=kernel, stride=1, padding=(kernel - 1) // 2) - maxm = torch.eq(maxm, heatmaps).float() - return (heatmaps * maxm).cpu().numpy() - - def nms(self, heatmaps): - # return self.nms_ov(heatmaps) - # return self.nms_skimage(heatmaps, self.nms_kernel) - return self.nms_pytorch(heatmaps, self.nms_kernel) + self.points_per_limb = 10 + self.grid = np.arange(self.points_per_limb, dtype=np.float32).reshape(1, -1, 1) def __call__(self, heatmaps, nms_heatmaps, pafs): batch_size, _, h, w = heatmaps.shape assert batch_size == 1, 'Batch size of 1 only supported' - pafs = np.transpose(pafs, (0, 2, 3, 1)) keypoints = self.extract_points(heatmaps, nms_heatmaps) + pafs = np.transpose(pafs, (0, 2, 3, 1)) if self.delta > 0: - # To adjust coordinates' flooring in heatmaps target generation. for kpts in keypoints: kpts[:, :2] += self.delta np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) - grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints) - if len(grouped_kpts) > 0: - grouped_kpts = np.asarray(grouped_kpts, dtype=np.float32) - grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) + poses, scores = self.convert_to_coco_format(pose_entries, keypoints) + if len(poses) > 0: + poses = np.asarray(poses, dtype=np.float32) + poses = poses.reshape((poses.shape[0], -1, 3)) else: - grouped_kpts = np.empty((0, 17, 3), dtype=np.float32) - scores = np.zeros(0, dtype=np.float32) + poses = np.empty((0, 17, 3), dtype=np.float32) + scores = np.empty(0, dtype=np.float32) - return grouped_kpts, scores + return poses, scores def extract_points(self, heatmaps, nms_heatmaps): batch_size, channels_num, h, w = heatmaps.shape @@ -81,8 +54,8 @@ def extract_points(self, heatmaps, nms_heatmaps): assert channels_num >= self.num_joints xs, ys, scores = self.top_k(nms_heatmaps) - masks = scores > self.score_threshold + all_keypoints = [] keypoint_id = 0 for k in range(self.num_joints): @@ -118,6 +91,7 @@ def top_k(self, heatmaps): heatmaps = heatmaps.reshape(N, K, -1) ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] scores = np.take_along_axis(heatmaps, ind, axis=2) + # FIXME. Is it needed? subind = np.argsort(-scores, axis=2) ind = np.take_along_axis(ind, subind, axis=2) scores = np.take_along_axis(scores, subind, axis=2) @@ -136,68 +110,128 @@ def refine(self, heatmap, x, y): x[valid] += dx y[valid] += dy return x, y - - def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, - skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): + def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): + # TODO. Remove this highlevel condition. + if part_id == 0: + pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] + for i in range(len(connections)): + pose_entries[i][kpt_a_id] = connections[i][0] + pose_entries[i][kpt_b_id] = connections[i][1] + pose_entries[i][-1] = 2 + # pose score = sum of all points' scores + sum of all connections' scores + pose_entries[i][-2] = np.sum(all_keypoints[connections[i][0:2], 2]) + connections[i][2] + else: + for connection in connections: + pose_a_idx = -1 + pose_b_idx = -1 + for j, pose in enumerate(pose_entries): + if pose[kpt_a_id] == connection[0]: + pose_a_idx = j + if pose[kpt_b_id] == connection[1]: + pose_b_idx = j + if pose_a_idx < 0 and pose_b_idx < 0: + # Create new pose entry. + pose_entry = np.full(pose_entry_size, -1) + pose_entry[kpt_a_id] = connection[0] + pose_entry[kpt_b_id] = connection[1] + pose_entry[-1] = 2 + pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + pose_entries.append(pose_entry) + elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: + # Merge two disjoint components into one pose. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + do_merge_poses = True + for j in range(len(pose_b) - 2): + if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: + do_merge_poses = False + break + if not do_merge_poses: + continue + for j in range(len(pose_b) - 2): + if pose_b[j] >= 0: + pose_a[j] = pose_b[j] + # pose_a[kpt_b_id] = connection[1] + pose_a[-1] += pose_b[-1] + pose_a[-2] += pose_b[-2] + connection[2] + del pose_entries[pose_b_idx] + elif pose_a_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_a_idx] + if pose[kpt_b_id] < 0: + pose[-2] += all_keypoints[connection[1], 2] + pose[kpt_b_id] = connection[1] + pose[-2] += connection[2] + pose[-1] += 1 + elif pose_b_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_b_idx] + if pose[kpt_a_id] < 0: + pose[-2] += all_keypoints[connection[0], 2] + pose[kpt_a_id] = connection[0] + pose[-2] += connection[2] + pose[-1] += 1 + return pose_entries + + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] - - point_num = 10 - grid = np.arange(point_num, dtype=np.float32).reshape(1, -1, 1) - - for part_id, paf_channel in enumerate(bones_to_channels): - part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] - - kpt_a_id, kpt_b_id = skeleton[part_id] + # For every limb. + for part_id, paf_channel in enumerate(self.paf_indices): + kpt_a_id, kpt_b_id = self.skeleton[part_id] kpts_a = all_keypoints_by_type[kpt_a_id] kpts_b = all_keypoints_by_type[kpt_b_id] - num_kpts_a = len(kpts_a) - num_kpts_b = len(kpts_b) - - if num_kpts_a == 0 or num_kpts_b == 0: + n = len(kpts_a) + m = len(kpts_b) + if n == 0 or m == 0: continue + # Get vectors between all pairs of keypoints, i.e. candidate limb vectors. a = kpts_a[:, :2] - b = kpts_b[:, :2] - n, m = len(a), len(b) - a = np.broadcast_to(a[None], (m, n, 2)) + b = kpts_b[:, :2] vec_raw = (b[:, None, :] - a).reshape(-1, 1, 2) - vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) - vec = vec_raw / (vec_norm + 1e-6) - steps = (1 / (point_num - 1) * vec_raw) - points = steps * grid + a.reshape(-1, 1, 2) + # Sample points along every candidate limb vector. + steps = (1 / (self.points_per_limb - 1) * vec_raw) + points = steps * self.grid + a.reshape(-1, 1, 2) points = points.round().astype(dtype=np.int32) - x = points[..., 0].ravel() y = points[..., 1].ravel() - field = part_pafs[y, x].reshape(-1, point_num, 2) - dot_prod = (field * vec).sum(-1).reshape(-1, point_num) - valid_prod = dot_prod > min_paf_score - valid_num = valid_prod.sum(1) - success_ratio = valid_num / point_num - score = (dot_prod * valid_prod).sum(1) / (valid_num + 1e-6) - - valid_limbs = np.where(np.logical_and(score > 0, success_ratio > 0.8))[0] + # Compute coherence score between candidate limb vectors and part affinity field. + part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] + field = part_pafs[y, x].reshape(-1, self.points_per_limb, 2) + vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) + vec = vec_raw / (vec_norm + 1e-6) + coherence_scores = (field * vec).sum(-1).reshape(-1, self.points_per_limb) + valid_coherence_scores = coherence_scores > self.min_paf_alignment_score + valid_num = valid_coherence_scores.sum(1) + coherence_score = (coherence_scores * valid_coherence_scores).sum(1) / (valid_num + 1e-6) + success_ratio = valid_num / self.points_per_limb + + # Get a list of limbs according to the obtained coherence score. + valid_limbs = np.where(np.logical_and(coherence_score > 0, success_ratio > 0.8))[0] b_idx, a_idx = np.divmod(valid_limbs, n) - connections = [] - for t, i, j in zip(valid_limbs, a_idx, b_idx): - connections.append([i, j, score[t], score[t] + kpts_a[i][2] + kpts_b[j][2]]) - - if len(connections) > 0: - connections = sorted(connections, key=itemgetter(2), reverse=True) + connections = np.stack([a_idx, b_idx, coherence_score[valid_limbs]], axis=1) + if len(connections) == 0: + continue - num_connections = min(num_kpts_a, num_kpts_b) - has_kpt_a = np.zeros(num_kpts_a, dtype=np.int32) - has_kpt_b = np.zeros(num_kpts_b, dtype=np.int32) + # From all retrieved connections that share same keypoints leave only the top-scoring one. + # TODO. Refactor this. + connections = connections[connections[:, 2].argsort()[::-1]] + # connections = sorted(connections, key=itemgetter(2), reverse=True) + num_connections = min(n, m) + has_kpt_a = np.zeros(n, dtype=np.bool) + has_kpt_b = np.zeros(m, dtype=np.bool) filtered_connections = [] - for row in range(len(connections)): + for connection in connections: if len(filtered_connections) == num_connections: break - i, j, cur_point_score = connections[row][0:3] + i, j, cur_point_score = connection[0:3] + i = int(i) + j = int(j) if not has_kpt_a[i] and not has_kpt_b[j]: filtered_connections.append([int(kpts_a[i][3]), int(kpts_b[j][3]), cur_point_score]) has_kpt_a[i] = 1 @@ -206,72 +240,17 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_p if len(connections) == 0: continue - if part_id == 0: - pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] - for i in range(len(connections)): - pose_entries[i][kpt_a_id] = connections[i][0] - pose_entries[i][kpt_b_id] = connections[i][1] - pose_entries[i][-1] = 2 - # pose score = sum of all points' scores + sum of all connections' scores - pose_entries[i][-2] = np.sum(all_keypoints[connections[i][0:2], 2]) + connections[i][2] - else: - for connection in connections: - pose_a_idx = -1 - pose_b_idx = -1 - for j, pose in enumerate(pose_entries): - if pose[kpt_a_id] == connection[0]: - pose_a_idx = j - if pose[kpt_b_id] == connection[1]: - pose_b_idx = j - if pose_a_idx < 0 and pose_b_idx < 0: - # Create new pose entry. - pose_entry = np.full(pose_entry_size, -1) - pose_entry[kpt_a_id] = connection[0] - pose_entry[kpt_b_id] = connection[1] - pose_entry[-1] = 2 - pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] - pose_entries.append(pose_entry) - elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: - # Merge two disjoint components into one pose. - pose_a = pose_entries[pose_a_idx] - pose_b = pose_entries[pose_b_idx] - do_merge_poses = True - for j in range(len(pose_b) - 2): - if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: - do_merge_poses = False - break - if not do_merge_poses: - continue - for j in range(len(pose_b) - 2): - if pose_b[j] >= 0: - pose_a[j] = pose_b[j] - # pose_a[kpt_b_id] = connection[1] - pose_a[-1] += pose_b[-1] - pose_a[-2] += pose_b[-2] + connection[2] - del pose_entries[pose_b_idx] - elif pose_a_idx >= 0: - # Add a new bone into pose. - pose = pose_entries[pose_a_idx] - if pose[kpt_b_id] < 0: - pose[-2] += all_keypoints[connection[1], 2] - pose[kpt_b_id] = connection[1] - pose[-2] += connection[2] - pose[-1] += 1 - elif pose_b_idx >= 0: - # Add a new bone into pose. - pose = pose_entries[pose_b_idx] - if pose[kpt_a_id] < 0: - pose[-2] += all_keypoints[connection[0], 2] - pose[kpt_a_id] = connection[0] - pose[-2] += connection[2] - pose[-1] += 1 + # Update poses with new connections. + pose_entries = self.update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, + connections, pose_entries, pose_entry_size) + # Remove poses with not enough points. filtered_entries = [] for i in range(len(pose_entries)): if pose_entries[i][-1] < 3: continue filtered_entries.append(pose_entries[i]) - pose_entries = np.asarray(filtered_entries) + pose_entries = np.asarray(filtered_entries, dtype=np.float32) return pose_entries, all_keypoints def convert_to_coco_format(self, pose_entries, all_keypoints): @@ -287,10 +266,9 @@ def convert_to_coco_format(self, pose_entries, all_keypoints): for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): if target_id < 0: continue - cx, cy, score, visibility = 0, 0, 0, 0 # keypoint not found + cx, cy, score = 0, 0, 0 # keypoint not found if keypoint_id != -1: cx, cy, score = all_keypoints[int(keypoint_id), 0:3] - visibility = 2 keypoints[target_id * 3 + 0] = cx * self.out_stride keypoints[target_id * 3 + 1] = cy * self.out_stride keypoints[target_id * 3 + 2] = score From fafd7b2311865cf671aab4ee204746435769a605 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 13 Nov 2020 19:15:49 +0300 Subject: [PATCH 28/58] moved nms out of decoder --- .../adapters/pose_estimation.py | 71 +++++++++++-------- 1 file changed, 41 insertions(+), 30 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index a70d04cecf5..47e8e1b5e36 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -907,7 +907,7 @@ def get_preds(scores): return preds -class NMS: +class NMSOpenVINO: def __init__(self, kernel): self.ie = IECore() self.net = self.compose(kernel) @@ -931,6 +931,46 @@ def compose(kernel): f = ng.impl.Function([ng.result(nms_heatmap, name='nms_heatmaps')], [heatmap], 'nms') net = IENetwork(ng.impl.Function.to_capsule(f)) return net + + +class NMSSKImage: + def __init__(self, kernel): + self.kernel = kernel + self.pad = (kernel - 1) // 2 + + def max_pool(self, x): + from skimage.measure import block_reduce + + # Max pooling kernel x kernel with stride 1 x 1. + k = self.kernel + p = self.pad + pooled = np.zeros_like(x) + hmap = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p))) + h, w = x.shape[-2:] + for i in range(k): + si = (h + 2 * p - i) // k + for j in range(k): + sj = (w + 2 * p - j) // k + hmap_slice = hmap[..., i:i + si * k, j:j + sj * k] + pooled[..., i::k, j::k] = block_reduce(hmap_slice, (1, 1, k, k), np.max) + return x + + def __call__(self, heatmaps): + pooled = self.max_pool(heatmaps) + return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) + + +class NMSPyTorch: + def __init__(self, kernel, device='cpu'): + self.kernel = kernel + self.pad = (kernel - 1) // 2 + self.device = device + + def __call__(self, heatmaps): + heatmaps = torch.as_tensor(heatmaps, device=self.device) + maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=self.kernel, stride=1, padding=self.pad) + maxm = torch.eq(maxm, heatmaps) + return (heatmaps * maxm).cpu().numpy() class OpenPoseDecoder: @@ -949,35 +989,6 @@ def __init__(self, num_joints, max_points=100, score_threshold=0.1, delta=0.5, o self.high_res_heatmaps = False self.high_res_pafs = False - self.nms_kernel = 3 - self.nms_ov = NMS(self.nms_kernel) - - def nms_skimage(self, heatmaps, kernel): - from skimage.measure import block_reduce - - # Max pooling kernel x kernel with stride 1 x 1. - p = (kernel - 1) // 2 - pooled = np.zeros(heatmaps.shape, dtype=np.float32) - hmap = np.pad(heatmaps, ((0, 0), (0, 0), (p, p), (p, p))) - h, w = heatmaps.shape[-2:] - for i in range(kernel): - si = (h + 2 * p - i) // kernel - for j in range(kernel): - sj = (w + 2 * p - j) // kernel - pooled[..., i::kernel, j::kernel] = block_reduce(hmap[..., i:i + si * kernel, j:j + sj * kernel], (1, 1, kernel, kernel), np.max) - return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) - - def nms_pytorch(self, heatmaps, kernel, device='cpu'): - heatmaps = torch.as_tensor(heatmaps, device=device) - maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=kernel, stride=1, padding=(kernel - 1) // 2) - maxm = torch.eq(maxm, heatmaps).float() - return (heatmaps * maxm).cpu().numpy() - - def nms(self, heatmaps): - # return self.nms_ov(heatmaps) - return self.nms_skimage(heatmaps, self.nms_kernel) - # return self.nms_pytorch(heatmaps, self.nms_kernel) - def __call__(self, heatmaps, nms_heatmaps, pafs): batch_size, _, h, w = heatmaps.shape assert batch_size == 1, 'Batch size of 1 only supported' From 89053cf757d5945d9f85c99bf4898bcf7a5ca310 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 16 Nov 2020 17:57:59 +0300 Subject: [PATCH 29/58] refactor openpose related components --- .../human_pose_estimation_demo/model.py | 63 ++-- .../openpose_decoder.py | 119 ++++---- .../adapters/pose_estimation.py | 289 +++++++++--------- 3 files changed, 227 insertions(+), 244 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 96a1c5c0548..1ab8802c216 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -101,9 +101,9 @@ def await_any(self): class HPEOpenPose(Model): - def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, - device='CPU', max_num_requests=1, use_cpp_postprocessing=False, - target_size=256, **kwargs): + def __init__(self, *args, size_divisor=8, + target_size=None, upsample_ratio=1, use_cpp_postprocessing=False, + device='CPU', max_num_requests=1, **kwargs): super().__init__(*args, **kwargs) self.use_cpp_postprocessing = use_cpp_postprocessing @@ -116,43 +116,44 @@ def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=8, heatmap = heatmap.inputs()[0].get_source_output().get_node() heatmap.set_friendly_name('heatmaps') if not self.use_cpp_postprocessing: - pooled_heatmap = ng.max_pool(heatmap,kernel_shape=(5, 5), pads_begin=(2, 2), pads_end=(2, 2), strides=(1, 1)) + # Add keypoints NMS to the network. + # Heuristic NMS kernel size adjustment depending on the feature maps upsampling ratio. + p = int(np.round(6 / 7 * upsample_ratio)) + k = 2 * p + 1 + pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(k, k), pads_begin=(p, p), pads_end=(p, p), strides=(1, 1)) nms_mask = ng.equal(heatmap, pooled_heatmap) + # TODO. Cast to type of the heatmap. # nms_mask_float = ng.convert_like(nms_mask, heatmap) nms_mask_float = ng.convert(nms_mask, 'f32') nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') f = ng.impl.Function( [ng.result(heatmap, name='heatmaps'), - ng.result(nms_heatmap, name='nms_heatmaps'), - ng.result(paf, name='pafs')], - function.get_parameters(), 'hpe-0001') - self.net = IENetwork(ng.impl.Function.to_capsule(f)) - + ng.result(nms_heatmap, name='nms_heatmaps'), + ng.result(paf, name='pafs')], + function.get_parameters(), 'hpe') self.nms_heatmaps_blob_name = 'nms_heatmaps' else: self.reorder_map = np.array([0, 15, 14, 17, 16, 5, 2, 6, 3, 7, 4, 11, 8, 12, 9, 13, 10]) + # Just rename the outputs for more convenient postprocessing. f = ng.impl.Function( - [ng.result(heatmap, name='heatmaps'), - ng.result(paf, name='pafs')], - function.get_parameters(), 'hpe-0001') - self.net = IENetwork(ng.impl.Function.to_capsule(f)) + [ng.result(heatmap, name='heatmaps'), ng.result(paf, name='pafs')], + function.get_parameters(), 'hpe') + self.net = IENetwork(ng.impl.Function.to_capsule(f)) self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) self.requests = self.exec_net.requests self.empty_requests = deque(self.requests) - self.keep_aspect_ratio_resize = keep_aspect_ratio_resize - self.size_divisor = size_divisor - self.image_blob_name = self._get_inputs(self.net) - self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] - self.pafs_blob_name = 'pafs' self.heatmaps_blob_name = 'heatmaps' - self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - 1 - self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] - self.target_size = target_size + self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - 1 # The last channel is for background. + self.size_divisor = size_divisor + self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-2] + self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-2] + if target_size is not None: + self.target_size = target_size self.decoder = OpenPoseDecoder(num_joints=self.num_joints) @@ -169,18 +170,14 @@ def _get_inputs(self, net): return image_blob_name @staticmethod - def _resize_image(frame, size, keep_aspect_ratio=False): - # FIXME - if not keep_aspect_ratio: - resized_frame = cv2.resize(frame, size) - else: - h, w = frame.shape[:2] - scale = max(size[1] / h, size[0] / w) - resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) + def _resize_image(frame, size): + h, w = frame.shape[:2] + scale = max(size[1] / h, size[0] / w) + resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) return resized_frame def preprocess(self, inputs): - img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size), self.keep_aspect_ratio_resize) + img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size)) meta = {'original_shape': inputs[self.image_blob_name].shape, 'resized_shape': img.shape} h, w = img.shape[:2] @@ -209,10 +206,7 @@ def postprocess(self, outputs, meta): poses = poses[:, self.reorder_map, :] poses[:, :, :2] /= upsample_ratio / 8 else: - if self.nms_heatmaps_blob_name: - nms_heatmaps = outputs[self.nms_heatmaps_blob_name] - else: - nms_heatmaps = self.decoder.nms(heatmaps) + nms_heatmaps = outputs[self.nms_heatmaps_blob_name] poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) # Rescale poses to the original image. @@ -233,6 +227,7 @@ def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=32, **kwar self.size_divisor = size_divisor self.image_blob_name = self._get_inputs(self.net) + # TODO. Make target size configurable. self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index ae6f545c68e..7d112b5a57e 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -1,6 +1,3 @@ -import math -from operator import itemgetter - import numpy as np @@ -11,7 +8,7 @@ class OpenPoseDecoder: BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) def __init__(self, num_joints=18, skeleton=BODY_PARTS_KPT_IDS, paf_indices=BODY_PARTS_PAF_IDS, - max_points=100, score_threshold=0.1, min_paf_alignment_score=0.05, delta=0.5, out_stride=8): + max_points=100, score_threshold=0.1, min_paf_alignment_score=0.05, delta=0.5): self.num_joints = num_joints self.skeleton = skeleton self.paf_indices = paf_indices @@ -19,7 +16,6 @@ def __init__(self, num_joints=18, skeleton=BODY_PARTS_KPT_IDS, paf_indices=BODY_ self.score_threshold = score_threshold self.min_paf_alignment_score = min_paf_alignment_score self.delta = delta - self.out_stride = out_stride self.points_per_limb = 10 self.grid = np.arange(self.points_per_limb, dtype=np.float32).reshape(1, -1, 1) @@ -55,7 +51,6 @@ def extract_points(self, heatmaps, nms_heatmaps): xs, ys, scores = self.top_k(nms_heatmaps) masks = scores > self.score_threshold - all_keypoints = [] keypoint_id = 0 for k in range(self.num_joints): @@ -65,16 +60,13 @@ def extract_points(self, heatmaps, nms_heatmaps): y = ys[0, k][mask].ravel() score = scores[0, k][mask].ravel() n = len(x) - if n == 0: all_keypoints.append(np.empty((0, 4), dtype=np.float32)) continue - # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) np.core.umath.clip(x, 0, w - 1, out=x) np.core.umath.clip(y, 0, h - 1, out=y) - # Pack resulting points. keypoints = np.empty((n, 4), dtype=np.float32) keypoints[:, 0] = x @@ -82,16 +74,16 @@ def extract_points(self, heatmaps, nms_heatmaps): keypoints[:, 2] = score keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) keypoint_id += n - all_keypoints.append(keypoints) return all_keypoints def top_k(self, heatmaps): N, K, _, W = heatmaps.shape heatmaps = heatmaps.reshape(N, K, -1) + # Get positions with top scores. ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] scores = np.take_along_axis(heatmaps, ind, axis=2) - # FIXME. Is it needed? + # Keep top scores sorted. subind = np.argsort(-scores, axis=2) ind = np.take_along_axis(ind, subind, axis=2) scores = np.take_along_axis(scores, subind, axis=2) @@ -112,15 +104,14 @@ def refine(self, heatmap, x, y): return x, y def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): - # TODO. Remove this highlevel condition. if part_id == 0: pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] - for i in range(len(connections)): - pose_entries[i][kpt_a_id] = connections[i][0] - pose_entries[i][kpt_b_id] = connections[i][1] - pose_entries[i][-1] = 2 + for pose, connection in zip(pose_entries, connections): + pose[kpt_a_id] = connection[0] + pose[kpt_b_id] = connection[1] + pose[-1] = 2 # pose score = sum of all points' scores + sum of all connections' scores - pose_entries[i][-2] = np.sum(all_keypoints[connections[i][0:2], 2]) + connections[i][2] + pose[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] else: for connection in connections: pose_a_idx = -1 @@ -138,24 +129,27 @@ def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entry[-1] = 2 pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] pose_entries.append(pose_entry) - elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: - # Merge two disjoint components into one pose. - pose_a = pose_entries[pose_a_idx] - pose_b = pose_entries[pose_b_idx] - do_merge_poses = True - for j in range(len(pose_b) - 2): - if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: - do_merge_poses = False - break - if not do_merge_poses: - continue - for j in range(len(pose_b) - 2): - if pose_b[j] >= 0: - pose_a[j] = pose_b[j] - # pose_a[kpt_b_id] = connection[1] - pose_a[-1] += pose_b[-1] - pose_a[-2] += pose_b[-2] + connection[2] - del pose_entries[pose_b_idx] + elif pose_a_idx >= 0 and pose_b_idx >= 0: + if pose_a_idx != pose_b_idx: + # Merge two disjoint components into one pose. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + do_merge_poses = True + for j in range(len(pose_b) - 2): + if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: + do_merge_poses = False + break + if not do_merge_poses: + continue + for j in range(len(pose_b) - 2): + if pose_b[j] >= 0: + pose_a[j] = pose_b[j] + pose_a[-1] += pose_b[-1] + pose_a[-2] += pose_b[-2] + connection[2] + del pose_entries[pose_b_idx] + else: + # Adjust score of a pose. + pose_entries[pose_a_idx][-2] += connection[2] elif pose_a_idx >= 0: # Add a new limb into pose. pose = pose_entries[pose_a_idx] @@ -173,7 +167,7 @@ def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose[-2] += connection[2] pose[-1] += 1 return pose_entries - + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] @@ -200,43 +194,36 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): x = points[..., 0].ravel() y = points[..., 1].ravel() - # Compute coherence score between candidate limb vectors and part affinity field. + # Compute affinity score between candidate limb vectors and part affinity field. part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] field = part_pafs[y, x].reshape(-1, self.points_per_limb, 2) vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) vec = vec_raw / (vec_norm + 1e-6) - coherence_scores = (field * vec).sum(-1).reshape(-1, self.points_per_limb) - valid_coherence_scores = coherence_scores > self.min_paf_alignment_score - valid_num = valid_coherence_scores.sum(1) - coherence_score = (coherence_scores * valid_coherence_scores).sum(1) / (valid_num + 1e-6) + affinity_scores = (field * vec).sum(-1).reshape(-1, self.points_per_limb) + valid_affinity_scores = affinity_scores > self.min_paf_alignment_score + valid_num = valid_affinity_scores.sum(1) + affinity_scores = (affinity_scores * valid_affinity_scores).sum(1) / (valid_num + 1e-6) success_ratio = valid_num / self.points_per_limb - # Get a list of limbs according to the obtained coherence score. - valid_limbs = np.where(np.logical_and(coherence_score > 0, success_ratio > 0.8))[0] + # Get a list of limbs according to the obtained affinity score. + valid_limbs = np.where(np.logical_and(affinity_scores > 0, success_ratio > 0.8))[0] + affinity_scores = affinity_scores[valid_limbs] b_idx, a_idx = np.divmod(valid_limbs, n) - connections = np.stack([a_idx, b_idx, coherence_score[valid_limbs]], axis=1) - if len(connections) == 0: + if len(affinity_scores) == 0: continue - # From all retrieved connections that share same keypoints leave only the top-scoring one. - # TODO. Refactor this. - connections = connections[connections[:, 2].argsort()[::-1]] - # connections = sorted(connections, key=itemgetter(2), reverse=True) - num_connections = min(n, m) - has_kpt_a = np.zeros(n, dtype=np.bool) - has_kpt_b = np.zeros(m, dtype=np.bool) - filtered_connections = [] - for connection in connections: - if len(filtered_connections) == num_connections: - break - i, j, cur_point_score = connection[0:3] - i = int(i) - j = int(j) - if not has_kpt_a[i] and not has_kpt_b[j]: - filtered_connections.append([int(kpts_a[i][3]), int(kpts_b[j][3]), cur_point_score]) - has_kpt_a[i] = 1 - has_kpt_b[j] = 1 - connections = filtered_connections + # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. + order = affinity_scores.argsort()[::-1] + affinity_scores = affinity_scores[order] + a_idx = a_idx[order] + b_idx = b_idx[order] + a_idx_unique = np.unique(a_idx, return_index=True)[1] + b_idx_unique = np.unique(b_idx, return_index=True)[1] + idx = np.intersect1d(a_idx_unique, b_idx_unique, assume_unique=True) + a = kpts_a[a_idx[idx], 3].astype(np.int32) + b = kpts_b[b_idx[idx], 3].astype(np.int32) + connections = list(zip(a, b, affinity_scores[idx])) + if len(connections) == 0: continue @@ -269,8 +256,8 @@ def convert_to_coco_format(self, pose_entries, all_keypoints): cx, cy, score = 0, 0, 0 # keypoint not found if keypoint_id != -1: cx, cy, score = all_keypoints[int(keypoint_id), 0:3] - keypoints[target_id * 3 + 0] = cx * self.out_stride - keypoints[target_id * 3 + 1] = cy * self.out_stride + keypoints[target_id * 3 + 0] = cx + keypoints[target_id * 3 + 1] = cy keypoints[target_id * 3 + 2] = score coco_keypoints.append(keypoints) scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 47e8e1b5e36..89b35705b0a 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -421,7 +421,9 @@ def configure(self): ) self._keypoints_heatmap_bias = self.keypoints_heatmap + '/add_' self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' - self.decoder = OpenPoseDecoder(num_joints=18, out_stride=1) + + self.decoder = OpenPoseDecoder(num_joints=18, delta=0.5 if self.upscale_factor == 1 else 0.0) + self.nms = NMSSKImage(kernel=2 * int(np.round(6 / 7 * self.upscale_factor)) + 1) def process(self, raw, identifiers, frame_meta): result = [] @@ -456,7 +458,7 @@ def process(self, raw, identifiers, frame_meta): paf = cv2.resize(paf, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, interpolation=cv2.INTER_CUBIC) paf = np.transpose(paf, (2, 0, 1)) hmap = heatmap[None] - nms_hmap = self.decoder.nms(hmap) + nms_hmap = self.nms(hmap) poses, scores = self.decoder(hmap, nms_hmap, paf[None]) if len(scores) == 0: result.append(PoseEstimationPrediction( @@ -474,8 +476,8 @@ def process(self, raw, identifiers, frame_meta): input_h, input_w = next(iter(meta['input_shape'].values()))[-2:] output_scale_x = input_w / output_w output_scale_y = input_h / output_h - poses[:, :, 0] /= scale_x / (output_scale_x / self.upscale_factor) - poses[:, :, 1] /= scale_y / (output_scale_y / self.upscale_factor) + poses[:, :, 0] *= output_scale_x / self.upscale_factor / scale_x + poses[:, :, 1] *= output_scale_y / self.upscale_factor / scale_y point_scores = poses[:, :, 2] result.append(PoseEstimationPrediction( @@ -946,14 +948,14 @@ def max_pool(self, x): p = self.pad pooled = np.zeros_like(x) hmap = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p))) - h, w = x.shape[-2:] + h, w = hmap.shape[-2:] for i in range(k): - si = (h + 2 * p - i) // k + n = (h - i) // k * k for j in range(k): - sj = (w + 2 * p - j) // k - hmap_slice = hmap[..., i:i + si * k, j:j + sj * k] + m = (w - j) // k * k + hmap_slice = hmap[..., i:i + n, j:j + m] pooled[..., i::k, j::k] = block_reduce(hmap_slice, (1, 1, k, k), np.max) - return x + return pooled def __call__(self, heatmaps): pooled = self.max_pool(heatmaps) @@ -973,46 +975,49 @@ def __call__(self, heatmaps): return (heatmaps * maxm).cpu().numpy() + class OpenPoseDecoder: BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) - def __init__(self, num_joints, max_points=100, score_threshold=0.1, delta=0.5, out_stride=8): - super().__init__() + def __init__(self, num_joints=18, skeleton=BODY_PARTS_KPT_IDS, paf_indices=BODY_PARTS_PAF_IDS, + max_points=100, score_threshold=0.1, min_paf_alignment_score=0.05, delta=0.5): self.num_joints = num_joints + self.skeleton = skeleton + self.paf_indices = paf_indices self.max_points = max_points self.score_threshold = score_threshold + self.min_paf_alignment_score = min_paf_alignment_score self.delta = delta - self.out_stride = out_stride - self.high_res_heatmaps = False - self.high_res_pafs = False + + self.points_per_limb = 10 + self.grid = np.arange(self.points_per_limb, dtype=np.float32).reshape(1, -1, 1) def __call__(self, heatmaps, nms_heatmaps, pafs): batch_size, _, h, w = heatmaps.shape assert batch_size == 1, 'Batch size of 1 only supported' - pafs = np.transpose(pafs, (0, 2, 3, 1)) keypoints = self.extract_points(heatmaps, nms_heatmaps) + pafs = np.transpose(pafs, (0, 2, 3, 1)) if self.delta > 0: - # To adjust coordinates' flooring in heatmaps target generation. for kpts in keypoints: kpts[:, :2] += self.delta np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) - grouped_kpts, scores = self.convert_to_coco_format(pose_entries, keypoints, None) - if len(grouped_kpts) > 0: - grouped_kpts = np.asarray(grouped_kpts, dtype=np.float32) - grouped_kpts = grouped_kpts.reshape((grouped_kpts.shape[0], -1, 3)) + poses, scores = self.convert_to_coco_format(pose_entries, keypoints) + if len(poses) > 0: + poses = np.asarray(poses, dtype=np.float32) + poses = poses.reshape((poses.shape[0], -1, 3)) else: - grouped_kpts = np.empty((0, 17, 3), dtype=np.float32) - scores = np.zeros(0, dtype=np.float32) + poses = np.empty((0, 17, 3), dtype=np.float32) + scores = np.empty(0, dtype=np.float32) - return grouped_kpts, scores + return poses, scores def extract_points(self, heatmaps, nms_heatmaps): batch_size, channels_num, h, w = heatmaps.shape @@ -1020,7 +1025,6 @@ def extract_points(self, heatmaps, nms_heatmaps): assert channels_num >= self.num_joints xs, ys, scores = self.top_k(nms_heatmaps) - masks = scores > self.score_threshold all_keypoints = [] keypoint_id = 0 @@ -1031,16 +1035,13 @@ def extract_points(self, heatmaps, nms_heatmaps): y = ys[0, k][mask].ravel() score = scores[0, k][mask].ravel() n = len(x) - if n == 0: all_keypoints.append(np.empty((0, 4), dtype=np.float32)) continue - # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) np.core.umath.clip(x, 0, w - 1, out=x) np.core.umath.clip(y, 0, h - 1, out=y) - # Pack resulting points. keypoints = np.empty((n, 4), dtype=np.float32) keypoints[:, 0] = x @@ -1048,15 +1049,16 @@ def extract_points(self, heatmaps, nms_heatmaps): keypoints[:, 2] = score keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) keypoint_id += n - all_keypoints.append(keypoints) return all_keypoints def top_k(self, heatmaps): N, K, _, W = heatmaps.shape heatmaps = heatmaps.reshape(N, K, -1) + # Get positions with top scores. ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] scores = np.take_along_axis(heatmaps, ind, axis=2) + # Keep top scores sorted. subind = np.argsort(-scores, axis=2) ind = np.take_along_axis(ind, subind, axis=2) scores = np.take_along_axis(scores, subind, axis=2) @@ -1075,145 +1077,145 @@ def refine(self, heatmap, x, y): x[valid] += dx y[valid] += dy return x, y - - def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20, min_paf_score=0.05, - skeleton=BODY_PARTS_KPT_IDS, bones_to_channels=BODY_PARTS_PAF_IDS): + def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): + if part_id == 0: + pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] + for pose, connection in zip(pose_entries, connections): + pose[kpt_a_id] = connection[0] + pose[kpt_b_id] = connection[1] + pose[-1] = 2 + # pose score = sum of all points' scores + sum of all connections' scores + pose[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + else: + for connection in connections: + pose_a_idx = -1 + pose_b_idx = -1 + for j, pose in enumerate(pose_entries): + if pose[kpt_a_id] == connection[0]: + pose_a_idx = j + if pose[kpt_b_id] == connection[1]: + pose_b_idx = j + if pose_a_idx < 0 and pose_b_idx < 0: + # Create new pose entry. + pose_entry = np.full(pose_entry_size, -1) + pose_entry[kpt_a_id] = connection[0] + pose_entry[kpt_b_id] = connection[1] + pose_entry[-1] = 2 + pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + pose_entries.append(pose_entry) + elif pose_a_idx >= 0 and pose_b_idx >= 0: + if pose_a_idx != pose_b_idx: + # Merge two disjoint components into one pose. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + do_merge_poses = True + for j in range(len(pose_b) - 2): + if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: + do_merge_poses = False + break + if not do_merge_poses: + continue + for j in range(len(pose_b) - 2): + if pose_b[j] >= 0: + pose_a[j] = pose_b[j] + pose_a[-1] += pose_b[-1] + pose_a[-2] += pose_b[-2] + connection[2] + del pose_entries[pose_b_idx] + else: + # Adjust score of a pose. + pose_entries[pose_a_idx][-2] += connection[2] + elif pose_a_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_a_idx] + if pose[kpt_b_id] < 0: + pose[-2] += all_keypoints[connection[1], 2] + pose[kpt_b_id] = connection[1] + pose[-2] += connection[2] + pose[-1] += 1 + elif pose_b_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_b_idx] + if pose[kpt_a_id] < 0: + pose[-2] += all_keypoints[connection[0], 2] + pose[kpt_a_id] = connection[0] + pose[-2] += connection[2] + pose[-1] += 1 + return pose_entries + + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] - - point_num = 10 - grid = np.arange(point_num, dtype=np.float32).reshape(1, -1, 1) - - for part_id, paf_channel in enumerate(bones_to_channels): - part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] - - kpt_a_id, kpt_b_id = skeleton[part_id] + # For every limb. + for part_id, paf_channel in enumerate(self.paf_indices): + kpt_a_id, kpt_b_id = self.skeleton[part_id] kpts_a = all_keypoints_by_type[kpt_a_id] kpts_b = all_keypoints_by_type[kpt_b_id] - num_kpts_a = len(kpts_a) - num_kpts_b = len(kpts_b) - - if num_kpts_a == 0 or num_kpts_b == 0: + n = len(kpts_a) + m = len(kpts_b) + if n == 0 or m == 0: continue + # Get vectors between all pairs of keypoints, i.e. candidate limb vectors. a = kpts_a[:, :2] - b = kpts_b[:, :2] - n, m = len(a), len(b) - a = np.broadcast_to(a[None], (m, n, 2)) + b = kpts_b[:, :2] vec_raw = (b[:, None, :] - a).reshape(-1, 1, 2) - vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) - vec = vec_raw / (vec_norm + 1e-6) - steps = (1 / (point_num - 1) * vec_raw) - points = steps * grid + a.reshape(-1, 1, 2) + # Sample points along every candidate limb vector. + steps = (1 / (self.points_per_limb - 1) * vec_raw) + points = steps * self.grid + a.reshape(-1, 1, 2) points = points.round().astype(dtype=np.int32) - x = points[..., 0].ravel() y = points[..., 1].ravel() - field = part_pafs[y, x].reshape(-1, point_num, 2) - dot_prod = (field * vec).sum(-1).reshape(-1, point_num) - - valid_prod = dot_prod > min_paf_score - valid_num = valid_prod.sum(1) - success_ratio = valid_num / point_num - score = (dot_prod * valid_prod).sum(1) / (valid_num + 1e-6) - valid_limbs = np.where(np.logical_and(score > 0, success_ratio > 0.8))[0] + # Compute affinity score between candidate limb vectors and part affinity field. + part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] + field = part_pafs[y, x].reshape(-1, self.points_per_limb, 2) + vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) + vec = vec_raw / (vec_norm + 1e-6) + affinity_scores = (field * vec).sum(-1).reshape(-1, self.points_per_limb) + valid_affinity_scores = affinity_scores > self.min_paf_alignment_score + valid_num = valid_affinity_scores.sum(1) + affinity_scores = (affinity_scores * valid_affinity_scores).sum(1) / (valid_num + 1e-6) + success_ratio = valid_num / self.points_per_limb + + # Get a list of limbs according to the obtained affinity score. + valid_limbs = np.where(np.logical_and(affinity_scores > 0, success_ratio > 0.8))[0] + affinity_scores = affinity_scores[valid_limbs] b_idx, a_idx = np.divmod(valid_limbs, n) - connections = [] - for t, i, j in zip(valid_limbs, a_idx, b_idx): - connections.append([i, j, score[t], score[t] + kpts_a[i][2] + kpts_b[j][2]]) - - if len(connections) > 0: - connections = sorted(connections, key=itemgetter(2), reverse=True) - - num_connections = min(num_kpts_a, num_kpts_b) - has_kpt_a = np.zeros(num_kpts_a, dtype=np.int32) - has_kpt_b = np.zeros(num_kpts_b, dtype=np.int32) - filtered_connections = [] - for row in range(len(connections)): - if len(filtered_connections) == num_connections: - break - i, j, cur_point_score = connections[row][0:3] - if not has_kpt_a[i] and not has_kpt_b[j]: - filtered_connections.append([int(kpts_a[i][3]), int(kpts_b[j][3]), cur_point_score]) - has_kpt_a[i] = 1 - has_kpt_b[j] = 1 - connections = filtered_connections + if len(affinity_scores) == 0: + continue + + # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. + order = affinity_scores.argsort()[::-1] + affinity_scores = affinity_scores[order] + a_idx = a_idx[order] + b_idx = b_idx[order] + a_idx_unique = np.unique(a_idx, return_index=True)[1] + b_idx_unique = np.unique(b_idx, return_index=True)[1] + idx = np.intersect1d(a_idx_unique, b_idx_unique, assume_unique=True) + a = kpts_a[a_idx[idx], 3].astype(np.int32) + b = kpts_b[b_idx[idx], 3].astype(np.int32) + connections = list(zip(a, b, affinity_scores[idx])) + if len(connections) == 0: continue - if part_id == 0: - pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] - for i in range(len(connections)): - pose_entries[i][kpt_a_id] = connections[i][0] - pose_entries[i][kpt_b_id] = connections[i][1] - pose_entries[i][-1] = 2 - # pose score = sum of all points' scores + sum of all connections' scores - pose_entries[i][-2] = np.sum(all_keypoints[connections[i][0:2], 2]) + connections[i][2] - else: - for connection in connections: - pose_a_idx = -1 - pose_b_idx = -1 - for j, pose in enumerate(pose_entries): - if pose[kpt_a_id] == connection[0]: - pose_a_idx = j - if pose[kpt_b_id] == connection[1]: - pose_b_idx = j - if pose_a_idx < 0 and pose_b_idx < 0: - # Create new pose entry. - pose_entry = np.full(pose_entry_size, -1) - pose_entry[kpt_a_id] = connection[0] - pose_entry[kpt_b_id] = connection[1] - pose_entry[-1] = 2 - pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] - pose_entries.append(pose_entry) - elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: - # Merge two disjoint components into one pose. - pose_a = pose_entries[pose_a_idx] - pose_b = pose_entries[pose_b_idx] - do_merge_poses = True - for j in range(len(pose_b) - 2): - if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: - do_merge_poses = False - break - if not do_merge_poses: - continue - for j in range(len(pose_b) - 2): - if pose_b[j] >= 0: - pose_a[j] = pose_b[j] - # pose_a[kpt_b_id] = connection[1] - pose_a[-1] += pose_b[-1] - pose_a[-2] += pose_b[-2] + connection[2] - del pose_entries[pose_b_idx] - elif pose_a_idx >= 0: - # Add a new bone into pose. - pose = pose_entries[pose_a_idx] - if pose[kpt_b_id] < 0: - pose[-2] += all_keypoints[connection[1], 2] - pose[kpt_b_id] = connection[1] - pose[-2] += connection[2] - pose[-1] += 1 - elif pose_b_idx >= 0: - # Add a new bone into pose. - pose = pose_entries[pose_b_idx] - if pose[kpt_a_id] < 0: - pose[-2] += all_keypoints[connection[0], 2] - pose[kpt_a_id] = connection[0] - pose[-2] += connection[2] - pose[-1] += 1 + # Update poses with new connections. + pose_entries = self.update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, + connections, pose_entries, pose_entry_size) + # Remove poses with not enough points. filtered_entries = [] for i in range(len(pose_entries)): if pose_entries[i][-1] < 3: continue filtered_entries.append(pose_entries[i]) - pose_entries = np.asarray(filtered_entries) + pose_entries = np.asarray(filtered_entries, dtype=np.float32) return pose_entries, all_keypoints - def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): + def convert_to_coco_format(self, pose_entries, all_keypoints): num_joints = 17 coco_keypoints = [] scores = [] @@ -1226,12 +1228,11 @@ def convert_to_coco_format(self, pose_entries, all_keypoints, reorder_map=None): for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): if target_id < 0: continue - cx, cy, score, visibility = 0, 0, 0, 0 # keypoint not found + cx, cy, score = 0, 0, 0 # keypoint not found if keypoint_id != -1: cx, cy, score = all_keypoints[int(keypoint_id), 0:3] - visibility = 2 - keypoints[target_id * 3 + 0] = cx * self.out_stride - keypoints[target_id * 3 + 1] = cy * self.out_stride + keypoints[target_id * 3 + 0] = cx + keypoints[target_id * 3 + 1] = cy keypoints[target_id * 3 + 2] = score coco_keypoints.append(keypoints) scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' From 63c56c97620ebf55903485621722e245b4747f3c Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 16 Nov 2020 19:05:05 +0300 Subject: [PATCH 30/58] update readme and model.lst for hpe demo --- .../human_pose_estimation_demo/README.md | 19 ++++++------------- .../human_pose_estimation_demo/models.lst | 4 +--- 2 files changed, 7 insertions(+), 16 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md index a8b6dfda7ac..98d2df5e387 100644 --- a/demos/python_demos/human_pose_estimation_demo/README.md +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -38,6 +38,7 @@ usage: human_pose_estimation.py [-h] -m MODEL -i INPUT [-d DEVICE] [-nstreams NUM_STREAMS] [-nthreads NUM_THREADS] [-loop LOOP] [-no_show] [-u UTILIZATION_MONITORS] + [--type {ae,openpose}] [--tsize TSIZE] Options: -h, --help Show this help message and exit. @@ -53,19 +54,6 @@ Options: Default value is CPU. -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD Optional. Probability threshold for poses filtering. - -r, --raw_output_message - Optional. Output inference results raw values showing. - Required. Path to an .xml file with a trained model. - -i INPUT, --input INPUT - Required. Path to an image, video file or a numeric - camera ID. - -d DEVICE, --device DEVICE - Optional. Specify the target device to infer on; CPU, - GPU, FPGA, HDDL or MYRIAD is acceptable. The sample - will look for a suitable plugin for device specified. - Default value is CPU. - -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD - Optional. Probability threshold for poses filtering. -r, --raw_output_message Optional. Output inference results raw values showing. -nireq NUM_INFER_REQUESTS, --num_infer_requests NUM_INFER_REQUESTS @@ -84,6 +72,11 @@ Options: -no_show, --no_show Optional. Don't show output -u UTILIZATION_MONITORS, --utilization_monitors UTILIZATION_MONITORS Optional. List of monitors to show initially. + --type {ae,openpose} Optional. Type of the network, either "ae" for + associative embeddingor "openpose" for openpose. + --tsize TSIZE Optional. Target input size. By default target size is + derived from image input shapeof a provided network + and depends on the network type. ``` Running the application with the empty list of options yields the short usage message and an error message. diff --git a/demos/python_demos/human_pose_estimation_demo/models.lst b/demos/python_demos/human_pose_estimation_demo/models.lst index 90bf5c80433..26d650bc499 100644 --- a/demos/python_demos/human_pose_estimation_demo/models.lst +++ b/demos/python_demos/human_pose_estimation_demo/models.lst @@ -1,4 +1,2 @@ # This file can be used with the --list option of the model downloader. -human-pose-estimation-0002 -human-pose-estimation-0003 -human-pose-estimation-0004 +human-pose-estimation-???? From 78fea4127229052edc4b246eeb2166afecabae79 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 16 Nov 2020 19:40:20 +0300 Subject: [PATCH 31/58] make target size configurable --- .../human_pose_estimation.py | 15 ++++++---- .../human_pose_estimation_demo/model.py | 30 ++++++++----------- 2 files changed, 23 insertions(+), 22 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index d4cf3d5998b..13b8c652bcc 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -51,7 +51,7 @@ def build_argparser(): 'acceptable. The sample will look for a suitable plugin for device specified. ' 'Default value is CPU.', default='CPU', type=str) args.add_argument('-t', '--prob_threshold', help='Optional. Probability threshold for poses filtering.', - default=0.5, type=float) + default=0.1, type=float) args.add_argument('-r', '--raw_output_message', help='Optional. Output inference results raw values showing.', default=False, action='store_true') args.add_argument('-nireq', '--num_infer_requests', help='Optional. Number of infer requests', @@ -69,7 +69,12 @@ def build_argparser(): args.add_argument('-u', '--utilization_monitors', default='', type=str, help='Optional. List of monitors to show initially.') - args.add_argument('--type', default='ae', choices=('ae', 'openpose'), type=str, help='Optional.') + args.add_argument('--type', default='ae', choices=('ae', 'openpose'), type=str, + help='Optional. Type of the network, either "ae" for associative embedding' + 'or "openpose" for openpose.' ) + args.add_argument('--tsize', default=None, type=int, + help='Optional. Target input size. By default target size is derived from image input shape' + 'of a provided network and depends on the network type.' ) return parser @@ -140,12 +145,12 @@ def main(): hpes = { Modes.USER_SPECIFIED: - HPE(ie, args.model, device=args.device, plugin_config=config_user_specified, + HPE(ie, args.model, target_size=args.tsize, device=args.device, plugin_config=config_user_specified, results=completed_request_results, max_num_requests=args.num_infer_requests, caught_exceptions=exceptions), Modes.MIN_LATENCY: - HPE(ie, args.model, device=args.device.split(':')[-1].split(',')[0], plugin_config=config_min_latency, - results=completed_request_results, max_num_requests=1, + HPE(ie, args.model, target_size=args.tsize, device=args.device.split(':')[-1].split(',')[0], + plugin_config=config_min_latency, results=completed_request_results, max_num_requests=1, caught_exceptions=exceptions) } diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 1ab8802c216..e157b05aa03 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -214,28 +214,27 @@ def postprocess(self, outputs, meta): resized_image_shape = meta['resized_shape'] scale_x = original_image_shape[1] / resized_image_shape[1] scale_y = original_image_shape[0] / resized_image_shape[0] - poses[:, :, 0] *= scale_x - poses[:, :, 1] *= scale_y + poses[:, :, 0] *= scale_x * self.output_scale + poses[:, :, 1] *= scale_y * self.output_scale return poses, scores class HPEAssociativeEmbedding(Model): - def __init__(self, *args, keep_aspect_ratio_resize=True, size_divisor=32, **kwargs): + def __init__(self, *args, target_size=None, size_divisor=32, **kwargs): super().__init__(*args, **kwargs) - self.keep_aspect_ratio_resize = keep_aspect_ratio_resize - self.size_divisor = size_divisor - + self.image_blob_name = self._get_inputs(self.net) - # TODO. Make target size configurable. - self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] - self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) self.embeddings_blob_name = find_layer_by_name('embeddings', self.net.outputs) + self.size_divisor = size_divisor self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] + self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] + if target_size is not None: + self.target_size = target_size self.decoder = AssociativeEmbeddingDecoder( num_joints=self.num_joints, @@ -261,17 +260,14 @@ def _get_inputs(self, net): return image_blob_name @staticmethod - def _resize_image(frame, size, keep_aspect_ratio=False): - if not keep_aspect_ratio: - resized_frame = cv2.resize(frame, size) - else: - h, w = frame.shape[:2] - scale = max(size[1] / h, size[0] / w) - resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) + def _resize_image(frame, size): + h, w = frame.shape[:2] + scale = max(size[1] / h, size[0] / w) + resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) return resized_frame def preprocess(self, inputs): - img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size), self.keep_aspect_ratio_resize) + img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size)) meta = {'original_shape': inputs[self.image_blob_name].shape, 'resized_shape': img.shape} h, w = img.shape[:2] From c182441af928a1a13688df371942cec7d24a13a4 Mon Sep 17 00:00:00 2001 From: Vladimir Dudnik Date: Mon, 16 Nov 2020 23:02:09 +0300 Subject: [PATCH 32/58] fix trailing spaces --- .../human_pose_estimation_demo/decoder.py | 2 +- .../human_pose_estimation_demo/model.py | 2 +- .../human_pose_estimation_demo/openpose_decoder.py | 4 ++-- .../accuracy_checker/adapters/pose_estimation.py | 6 +++--- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py index 9d70adc7ae0..42076109947 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py @@ -18,7 +18,7 @@ def __init__(self, num_joints, max_num_people, detection_threshold, use_detectio self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) else: self.joint_order = list(np.arange(self.num_joints)) - + self.do_adjust = adjust self.do_refine = refine self.delta = delta diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index e157b05aa03..21f833f7ef9 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -223,7 +223,7 @@ class HPEAssociativeEmbedding(Model): def __init__(self, *args, target_size=None, size_divisor=32, **kwargs): super().__init__(*args, **kwargs) - + self.image_blob_name = self._get_inputs(self.net) self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py index 7d112b5a57e..f6de17a7bb0 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py @@ -43,7 +43,7 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): scores = np.empty(0, dtype=np.float32) return poses, scores - + def extract_points(self, heatmaps, nms_heatmaps): batch_size, channels_num, h, w = heatmaps.shape assert batch_size == 1, 'Batch size of 1 only supported' @@ -180,7 +180,7 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): m = len(kpts_b) if n == 0 or m == 0: continue - + # Get vectors between all pairs of keypoints, i.e. candidate limb vectors. a = kpts_a[:, :2] a = np.broadcast_to(a[None], (m, n, 2)) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 89b35705b0a..0af0ce5661c 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -421,7 +421,7 @@ def configure(self): ) self._keypoints_heatmap_bias = self.keypoints_heatmap + '/add_' self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' - + self.decoder = OpenPoseDecoder(num_joints=18, delta=0.5 if self.upscale_factor == 1 else 0.0) self.nms = NMSSKImage(kernel=2 * int(np.round(6 / 7 * self.upscale_factor)) + 1) @@ -1018,7 +1018,7 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): scores = np.empty(0, dtype=np.float32) return poses, scores - + def extract_points(self, heatmaps, nms_heatmaps): batch_size, channels_num, h, w = heatmaps.shape assert batch_size == 1, 'Batch size of 1 only supported' @@ -1155,7 +1155,7 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): m = len(kpts_b) if n == 0 or m == 0: continue - + # Get vectors between all pairs of keypoints, i.e. candidate limb vectors. a = kpts_a[:, :2] a = np.broadcast_to(a[None], (m, n, 2)) From af6452b7032057c64196321caebbad5e7eea062f Mon Sep 17 00:00:00 2001 From: Vladimir Dudnik Date: Mon, 16 Nov 2020 23:08:31 +0300 Subject: [PATCH 33/58] fix trailing spaces --- .../accuracy_checker/adapters/pose_estimation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 0af0ce5661c..3bf266936ef 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -973,7 +973,7 @@ def __call__(self, heatmaps): maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=self.kernel, stride=1, padding=self.pad) maxm = torch.eq(maxm, heatmaps) return (heatmaps * maxm).cpu().numpy() - + class OpenPoseDecoder: From 6f71ddc4953f5591b72a686f1054074ec963b6e6 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Tue, 17 Nov 2020 01:00:04 +0300 Subject: [PATCH 34/58] revert changes in HumanPoseAdapter --- .../adapters/pose_estimation.py | 77 ++++--------------- 1 file changed, 13 insertions(+), 64 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 3bf266936ef..65d12e2c05e 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -18,11 +18,9 @@ from operator import itemgetter import cv2 -import ngraph as ng import numpy as np -import torch -from openvino.inference_engine import IENetwork, IECore from scipy.optimize import linear_sum_assignment +from skimage.measure import block_reduce from ..adapters import Adapter from ..config import ConfigValidator, StringField, ConfigError, NumberField @@ -105,21 +103,17 @@ def process(self, raw, identifiers, frame_meta): pad = meta.get('padding', [0, 0, 0, 0]) transpose_order = (1, 2, 0) if heatmap.shape[0] == 19 else (0, 1, 2) - s = 8 - heatmap = np.transpose(np.squeeze(heatmap), transpose_order) - heatmap = cv2.resize(heatmap, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) + heatmap = cv2.resize(heatmap, (0, 0), fx=8, fy=8, interpolation=cv2.INTER_CUBIC) heatmap = heatmap[pad[0]:heatmap.shape[0] - pad[2], pad[1]:heatmap.shape[1] - pad[3]:, :] - # heatmap = cv2.resize(heatmap, (width, height), interpolation=cv2.INTER_CUBIC) - # heatmap_avg = heatmap_avg + heatmap - heatmap_avg = heatmap + heatmap = cv2.resize(heatmap, (width, height), interpolation=cv2.INTER_CUBIC) + heatmap_avg = heatmap_avg + heatmap paf = np.transpose(np.squeeze(paf), transpose_order) - paf = cv2.resize(paf, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_CUBIC) + paf = cv2.resize(paf, (0, 0), fx=8, fy=8, interpolation=cv2.INTER_CUBIC) paf = paf[pad[0]:paf.shape[0] - pad[2], pad[1]:paf.shape[1] - pad[3], :] - # paf = cv2.resize(paf, (width, height), interpolation=cv2.INTER_CUBIC) - # paf_avg = paf_avg + paf - paf_avg = paf + paf = cv2.resize(paf, (width, height), interpolation=cv2.INTER_CUBIC) + paf_avg = paf_avg + paf peak_counter = 0 all_peaks = [] @@ -127,11 +121,7 @@ def process(self, raw, identifiers, frame_meta): peak_counter += self.find_peaks(heatmap_avg[:, :, part], all_peaks, peak_counter) subset, candidate = self.group_peaks(all_peaks, paf_avg) - - scale_x = meta['scale_x'] / (8 / s) - scale_y = meta['scale_y'] / (8 / s) - # scale_x = scale_y = 1 - result.append(PoseEstimationPrediction(identifier, *self.get_poses(subset, candidate, (scale_x, scale_y)))) + result.append(PoseEstimationPrediction(identifier, *self.get_poses(subset, candidate))) return result @@ -344,7 +334,7 @@ def group_peaks(self, peaks, pafs, kpt_num=20, threshold=0.05): return self._filter_subset(subset), candidates @staticmethod - def get_poses(subset, candidate, scales): + def get_poses(subset, candidate): persons_keypoints_x, persons_keypoints_y, persons_keypoints_v = [], [], [] scores = [] for subset_element in subset: @@ -365,8 +355,8 @@ def get_poses(subset, candidate, scales): cx = cx - 0.5 + 1 # +1 for matlab consistency, coords start from 1 cy = cy - 0.5 + 1 visibility = 1 - keypoints_x[to_coco_map[position_id]] = cx / scales[0] - keypoints_y[to_coco_map[position_id]] = cy / scales[1] + keypoints_x[to_coco_map[position_id]] = cx + keypoints_y[to_coco_map[position_id]] = cy keypoints_v[to_coco_map[position_id]] = visibility scores.append(person_score * max(0, (subset_element[-1] - 1))) # -1 for Neck @@ -423,7 +413,7 @@ def configure(self): self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' self.decoder = OpenPoseDecoder(num_joints=18, delta=0.5 if self.upscale_factor == 1 else 0.0) - self.nms = NMSSKImage(kernel=2 * int(np.round(6 / 7 * self.upscale_factor)) + 1) + self.nms = HeatmapNMS(kernel=2 * int(np.round(6 / 7 * self.upscale_factor)) + 1) def process(self, raw, identifiers, frame_meta): result = [] @@ -909,40 +899,12 @@ def get_preds(scores): return preds -class NMSOpenVINO: - def __init__(self, kernel): - self.ie = IECore() - self.net = self.compose(kernel) - self.exec_net = self.ie.load_network(network=self.net, device_name='CPU', num_requests=1) - - def __call__(self, heatmap): - self.net.reshape({'heatmaps': heatmap.shape}) - self.exec_net = self.ie.load_network(network=self.net, device_name='CPU', num_requests=1) - outputs = self.exec_net.infer({'heatmaps': heatmap})['nms_heatmaps'] - return outputs - - @staticmethod - def compose(kernel): - heatmap = ng.parameter(shape=[1, 19, 32, 32], dtype=np.float32, name='heatmaps') - pad = (kernel - 1) // 2 - pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(kernel, kernel), pads_begin=(pad, pad), pads_end=(pad, pad), strides=(1, 1)) - nms_mask = ng.equal(heatmap, pooled_heatmap) - # nms_mask_float = ng.convert_like(nms_mask, heatmap) - nms_mask_float = ng.convert(nms_mask, 'f32') - nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') - f = ng.impl.Function([ng.result(nms_heatmap, name='nms_heatmaps')], [heatmap], 'nms') - net = IENetwork(ng.impl.Function.to_capsule(f)) - return net - - -class NMSSKImage: +class HeatmapNMS: def __init__(self, kernel): self.kernel = kernel self.pad = (kernel - 1) // 2 def max_pool(self, x): - from skimage.measure import block_reduce - # Max pooling kernel x kernel with stride 1 x 1. k = self.kernel p = self.pad @@ -962,19 +924,6 @@ def __call__(self, heatmaps): return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) -class NMSPyTorch: - def __init__(self, kernel, device='cpu'): - self.kernel = kernel - self.pad = (kernel - 1) // 2 - self.device = device - - def __call__(self, heatmaps): - heatmaps = torch.as_tensor(heatmaps, device=self.device) - maxm = torch.nn.functional.max_pool2d(heatmaps, kernel_size=self.kernel, stride=1, padding=self.pad) - maxm = torch.eq(maxm, heatmaps) - return (heatmaps * maxm).cpu().numpy() - - class OpenPoseDecoder: From e009bc05b6025983d9ecd7ed2c939ca0503a3700 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Tue, 17 Nov 2020 01:50:07 +0300 Subject: [PATCH 35/58] fix linter comments --- .../adapters/pose_estimation.py | 50 +++++++++++-------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index 65d12e2c05e..ad2e37a60e2 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -442,10 +442,12 @@ def process(self, raw, identifiers, frame_meta): if self.upscale_factor > 1: self.decoder.delta = 0 heatmap = np.transpose(heatmap, (1, 2, 0)) - heatmap = cv2.resize(heatmap, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, interpolation=cv2.INTER_CUBIC) + heatmap = cv2.resize(heatmap, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, + interpolation=cv2.INTER_CUBIC) heatmap = np.transpose(heatmap, (2, 0, 1)) paf = np.transpose(np.squeeze(paf), (1, 2, 0)) - paf = cv2.resize(paf, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, interpolation=cv2.INTER_CUBIC) + paf = cv2.resize(paf, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, + interpolation=cv2.INTER_CUBIC) paf = np.transpose(paf, (2, 0, 1)) hmap = heatmap[None] nms_hmap = self.nms(hmap) @@ -503,7 +505,8 @@ def __init__(self, num_joints, max_num_people, detection_threshold, use_detectio def match(self, tag_k, loc_k, val_k): return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) - def _max_match(self, scores): + @staticmethod + def _max_match(scores): r, c = linear_sum_assignment(scores) tmp = np.stack((r, c), axis=1) return tmp @@ -531,8 +534,7 @@ def add(self, idx, joint, tag): def tag(self): if self.valid_points_num > 0: return self.pose_tag - else: - return None + return None all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) @@ -569,8 +571,7 @@ def tag(self): if num_added > num_grouped: diff_normed = np.concatenate( - (diff_normed, - np.zeros((num_added, num_added - num_grouped), dtype=np.float32) + 1e10), + (diff_normed, np.zeros((num_added, num_added - num_grouped), dtype=np.float32) + 1e10), axis=1) pairs = self._max_match(diff_normed) @@ -582,7 +583,7 @@ def tag(self): pose.add(idx, joints[row], tags[row]) poses.append(pose) - if len(poses): + if len(poses) > 0: ans = np.stack([p.pose for p in poses]).astype(np.float32) tags = np.stack([p.tag for p in poses]).astype(np.float32) else: @@ -610,7 +611,8 @@ def top_k(self, heatmaps, tags): ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} return ans - def adjust(self, ans, heatmaps): + @staticmethod + def adjust(ans, heatmaps): H, W = heatmaps.shape[-2:] for n, people in enumerate(ans): for person in people: @@ -626,7 +628,8 @@ def adjust(self, ans, heatmaps): joint[:2] += np.sign(diff) * .25 return ans - def refine(self, heatmap, tag, keypoints, pose_tag=None): + @staticmethod + def refine(heatmap, tag, keypoints, pose_tag=None): K, H, W = heatmap.shape if len(tag.shape) == 3: tag = tag[..., None] @@ -1014,9 +1017,10 @@ def top_k(self, heatmaps): y, x = np.divmod(ind, W) return x, y, scores - def refine(self, heatmap, x, y): + @staticmethod + def refine(heatmap, x, y): h, w = heatmap.shape[-2:] - valid = np.logical_and(np.logical_and(0 < x, x < w - 1), np.logical_and(0 < y, y < h - 1)) + valid = np.logical_and(np.logical_and(x > 0, x < w - 1), np.logical_and(y > 0, y < h - 1)) xx = x[valid] yy = y[valid] dx = np.sign(heatmap[yy, xx + 1] - heatmap[yy, xx - 1], dtype=np.float32) * 0.25 @@ -1027,7 +1031,8 @@ def refine(self, heatmap, x, y): y[valid] += dy return x, y - def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): + @staticmethod + def update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): if part_id == 0: pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] for pose, connection in zip(pose_entries, connections): @@ -1157,24 +1162,25 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): # Remove poses with not enough points. filtered_entries = [] - for i in range(len(pose_entries)): - if pose_entries[i][-1] < 3: + for pose in pose_entries: + if pose[-1] < 3: continue - filtered_entries.append(pose_entries[i]) + filtered_entries.append(pose) pose_entries = np.asarray(filtered_entries, dtype=np.float32) return pose_entries, all_keypoints - def convert_to_coco_format(self, pose_entries, all_keypoints): + @staticmethod + def convert_to_coco_format(pose_entries, all_keypoints): num_joints = 17 coco_keypoints = [] scores = [] - for n in range(len(pose_entries)): - if len(pose_entries[n]) == 0: + for pose in pose_entries: + if len(pose) == 0: continue keypoints = np.zeros(num_joints * 3) reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] - person_score = pose_entries[n][-2] - for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): + person_score = pose[-2] + for keypoint_id, target_id in zip(pose[:-2], reorder_map): if target_id < 0: continue cx, cy, score = 0, 0, 0 # keypoint not found @@ -1184,5 +1190,5 @@ def convert_to_coco_format(self, pose_entries, all_keypoints): keypoints[target_id * 3 + 1] = cy keypoints[target_id * 3 + 2] = score coco_keypoints.append(keypoints) - scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' + scores.append(person_score * max(0, (pose[-1] - 1))) # -1 for 'neck' return np.asarray(coco_keypoints), np.asarray(scores) From 35e3cb20f0b85ba12d99a86f6233f7206924b0df Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Tue, 17 Nov 2020 17:26:05 +0300 Subject: [PATCH 36/58] moved pose estimation adapters to separate modules --- .../accuracy_checker/adapters/__init__.py | 12 +- .../adapters/pose_estimation.py | 700 +----------------- .../pose_estimation_associative_embedding.py | 302 ++++++++ .../adapters/pose_estimation_openpose.py | 414 +++++++++++ 4 files changed, 722 insertions(+), 706 deletions(-) create mode 100644 tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py create mode 100644 tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py diff --git a/tools/accuracy_checker/accuracy_checker/adapters/__init__.py b/tools/accuracy_checker/accuracy_checker/adapters/__init__.py index 3d0eed631a5..870a05f2646 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/__init__.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/__init__.py @@ -63,13 +63,9 @@ from .yolo import TinyYOLOv1Adapter, YoloV2Adapter, YoloV3Adapter, YoloV3ONNX from .classification import ClassificationAdapter from .segmentation import SegmentationAdapter, BrainTumorSegmentationAdapter, DUCSegmentationAdapter -from .pose_estimation import ( - OpenPoseAdapter, - AssociativeEmbeddingAdapter, - HumanPoseAdapter, - SingleHumanPoseAdapter, - StackedHourGlassNetworkAdapter -) +from .pose_estimation import HumanPoseAdapter, SingleHumanPoseAdapter, StackedHourGlassNetworkAdapter +from .pose_estimation_openpose import OpenPoseAdapter +from .pose_estimation_associative_embedding import AssociativeEmbeddingAdapter from .pose_estimation_3d import HumanPose3dAdapter @@ -166,10 +162,10 @@ 'LPRAdapter', 'CTCGreedySearchDecoder', - 'OpenPoseAdapter', 'AssociativeEmbeddingAdapter', 'HumanPoseAdapter', 'HumanPose3dAdapter', + 'OpenPoseAdapter', 'SingleHumanPoseAdapter', 'StackedHourGlassNetworkAdapter', diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py index ad2e37a60e2..aa40c884a4b 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation.py @@ -19,14 +19,12 @@ import cv2 import numpy as np -from scipy.optimize import linear_sum_assignment -from skimage.measure import block_reduce from ..adapters import Adapter -from ..config import ConfigValidator, StringField, ConfigError, NumberField +from ..config import ConfigValidator, StringField, ConfigError from ..preprocessor import ObjectCropWithScale from ..representation import PoseEstimationPrediction -from ..utils import contains_all, contains_any +from ..utils import contains_any class HumanPoseAdapter(Adapter): @@ -372,408 +370,6 @@ def get_poses(subset, candidate): return persons_keypoints_x, persons_keypoints_y, persons_keypoints_v, scores -class OpenPoseAdapter(Adapter): - __provider__ = 'human_pose_estimation_openpose' - prediction_types = (PoseEstimationPrediction, ) - - @classmethod - def parameters(cls): - parameters = super().parameters() - parameters.update({ - 'part_affinity_fields_out': StringField( - description="Name of output layer with keypoints pairwise relations (part affinity fields).", - optional=True - ), - 'keypoints_heatmap_out': StringField( - description="Name of output layer with keypoints heatmaps.", optional=True - ), - 'upscale_factor': NumberField( - description="Upscaling factor for output feature maps before postprocessing.", - value_type=float, min_value=1, default=1, optional=True - ), - }) - return parameters - - def validate_config(self): - super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) - - def configure(self): - self.upscale_factor = self.get_value_from_config('upscale_factor') - self.part_affinity_fields = self.get_value_from_config('part_affinity_fields_out') - self.keypoints_heatmap = self.get_value_from_config('keypoints_heatmap_out') - self.concat_out = self.part_affinity_fields is None and self.keypoints_heatmap is None - if not self.concat_out: - contains_both = self.part_affinity_fields is not None and self.keypoints_heatmap is not None - if not contains_both: - raise ConfigError( - 'human_pose_estimation adapter should contains both: keypoints_heatmap_out ' - 'and part_affinity_fields_out or not contain them at all (in single output model case)' - ) - self._keypoints_heatmap_bias = self.keypoints_heatmap + '/add_' - self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' - - self.decoder = OpenPoseDecoder(num_joints=18, delta=0.5 if self.upscale_factor == 1 else 0.0) - self.nms = HeatmapNMS(kernel=2 * int(np.round(6 / 7 * self.upscale_factor)) + 1) - - def process(self, raw, identifiers, frame_meta): - result = [] - raw_outputs = self._extract_predictions(raw, frame_meta) - if not self.concat_out: - if not contains_any(raw_outputs, [self.part_affinity_fields, self._part_affinity_fields_bias]): - raise ConfigError('part affinity fields output not found') - if not contains_any(raw_outputs, [self.keypoints_heatmap, self._keypoints_heatmap_bias]): - raise ConfigError('keypoints heatmap output not found') - keypoints_heatmap = raw_outputs[ - self.keypoints_heatmap if self.keypoints_heatmap in raw_outputs else self._keypoints_heatmap_bias - ] - pafs = raw_outputs[ - self.part_affinity_fields if self.part_affinity_fields in raw_outputs - else self._part_affinity_fields_bias - ] - raw_output = zip(identifiers, keypoints_heatmap, pafs, frame_meta) - else: - concat_out = raw_outputs[self.output_blob] - keypoints_num = concat_out.shape[1] // 3 - keypoints_heat_map = concat_out[:, :keypoints_num, :] - pafs = concat_out[:, keypoints_num:, :] - raw_output = zip(identifiers, keypoints_heat_map, pafs, frame_meta) - for identifier, heatmap, paf, meta in raw_output: - output_h, output_w = heatmap.shape[-2:] - if self.upscale_factor > 1: - self.decoder.delta = 0 - heatmap = np.transpose(heatmap, (1, 2, 0)) - heatmap = cv2.resize(heatmap, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, - interpolation=cv2.INTER_CUBIC) - heatmap = np.transpose(heatmap, (2, 0, 1)) - paf = np.transpose(np.squeeze(paf), (1, 2, 0)) - paf = cv2.resize(paf, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, - interpolation=cv2.INTER_CUBIC) - paf = np.transpose(paf, (2, 0, 1)) - hmap = heatmap[None] - nms_hmap = self.nms(hmap) - poses, scores = self.decoder(hmap, nms_hmap, paf[None]) - if len(scores) == 0: - result.append(PoseEstimationPrediction( - identifier, - np.empty((0, 17), dtype=float), - np.empty((0, 17), dtype=float), - np.empty((0, 17), dtype=float), - np.empty((0, ), dtype=float) - )) - continue - poses = poses.astype(float) - scores = np.asarray(scores).astype(float) - scale_x = meta['scale_x'] - scale_y = meta['scale_y'] - input_h, input_w = next(iter(meta['input_shape'].values()))[-2:] - output_scale_x = input_w / output_w - output_scale_y = input_h / output_h - poses[:, :, 0] *= output_scale_x / self.upscale_factor / scale_x - poses[:, :, 1] *= output_scale_y / self.upscale_factor / scale_y - point_scores = poses[:, :, 2] - - result.append(PoseEstimationPrediction( - identifier, - poses[:, :, 0], - poses[:, :, 1], - point_scores, - scores)) - return result - - -class AssociativeEmbeddingDecoder: - - def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, - ignore_too_much, tag_threshold, - adjust=True, refine=True, delta=0.0, joints_order=None): - self.num_joints = num_joints - self.max_num_people = max_num_people - self.detection_threshold = detection_threshold - self.tag_threshold = tag_threshold - self.use_detection_val = use_detection_val - self.ignore_too_much = ignore_too_much - - if self.num_joints == 17 and joints_order is None: - self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) - else: - self.joint_order = list(np.arange(self.num_joints)) - - self.do_adjust = adjust - self.do_refine = refine - self.delta = delta - - def match(self, tag_k, loc_k, val_k): - return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) - - @staticmethod - def _max_match(scores): - r, c = linear_sum_assignment(scores) - tmp = np.stack((r, c), axis=1) - return tmp - - def _match_by_tag(self, inp): - tag_k, loc_k, val_k = inp - - embd_size = tag_k.shape[2] - - class Pose: - def __init__(self, num_joints, tag_size=1): - self.num_joints = num_joints - self.tag_size = tag_size - self.pose = np.zeros((num_joints, 2 + 1 + tag_size), dtype=np.float32) - self.pose_tag = np.zeros(tag_size, dtype=np.float32) - self.valid_points_num = 0 - - def add(self, idx, joint, tag): - self.pose[idx] = joint - self.pose_tag = (self.pose_tag * self.valid_points_num) + tag - self.valid_points_num += 1 - self.pose_tag /= self.valid_points_num - - @property - def tag(self): - if self.valid_points_num > 0: - return self.pose_tag - return None - - all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) - - poses = [] - for idx in self.joint_order: - tags = tag_k[idx] - joints = all_joints[idx] - mask = joints[:, 2] > self.detection_threshold - tags = tags[mask] - joints = joints[mask] - - if joints.shape[0] == 0: - continue - - if len(poses) == 0: - for tag, joint in zip(tags, joints): - pose = Pose(self.num_joints, embd_size) - pose.add(idx, joint, tag) - poses.append(pose) - else: - if self.ignore_too_much and len(poses) == self.max_num_people: - continue - poses_tags = np.stack([p.tag for p in poses], axis=0) - - diff = tags[:, None] - poses_tags[None, :] - diff_normed = np.linalg.norm(diff, ord=2, axis=2) - diff_saved = np.copy(diff_normed) - - if self.use_detection_val: - diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] - - num_added = diff.shape[0] - num_grouped = diff.shape[1] - - if num_added > num_grouped: - diff_normed = np.concatenate( - (diff_normed, np.zeros((num_added, num_added - num_grouped), dtype=np.float32) + 1e10), - axis=1) - - pairs = self._max_match(diff_normed) - for row, col in pairs: - if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: - poses[col].add(idx, joints[row], tags[row]) - else: - pose = Pose(self.num_joints, embd_size) - pose.add(idx, joints[row], tags[row]) - poses.append(pose) - - if len(poses) > 0: - ans = np.stack([p.pose for p in poses]).astype(np.float32) - tags = np.stack([p.tag for p in poses]).astype(np.float32) - else: - ans = np.empty((0, self.num_joints, 2 + 1 + embd_size), dtype=np.float32) - tags = np.empty((0, embd_size), dtype=np.float32) - return ans, tags - - def top_k(self, heatmaps, tags): - N, K, H, W = heatmaps.shape - heatmaps = heatmaps.reshape(N, K, -1) - ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] - val_k = np.take_along_axis(heatmaps, ind, axis=2) - subind = np.argsort(-val_k, axis=2) - ind = np.take_along_axis(ind, subind, axis=2) - val_k = np.take_along_axis(val_k, subind, axis=2) - - tags = tags.reshape(N, K, W * H, -1) - tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] - tag_k = np.stack(tag_k, axis=3) - - x = ind % W - y = ind // W - ind_k = np.stack((x, y), axis=3) - - ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} - return ans - - @staticmethod - def adjust(ans, heatmaps): - H, W = heatmaps.shape[-2:] - for n, people in enumerate(ans): - for person in people: - for k, joint in enumerate(person): - heatmap = heatmaps[n, k] - px = int(joint[0]) - py = int(joint[1]) - if 1 < px < W - 1 and 1 < py < H - 1: - diff = np.array([ - heatmap[py, px + 1] - heatmap[py, px - 1], - heatmap[py + 1, px] - heatmap[py - 1, px] - ]) - joint[:2] += np.sign(diff) * .25 - return ans - - @staticmethod - def refine(heatmap, tag, keypoints, pose_tag=None): - K, H, W = heatmap.shape - if len(tag.shape) == 3: - tag = tag[..., None] - - if pose_tag is not None: - prev_tag = pose_tag - else: - tags = [] - for i in range(K): - if keypoints[i, 2] > 0: - x, y = keypoints[i][:2].astype(int) - tags.append(tag[i, y, x]) - prev_tag = np.mean(tags, axis=0) - - # Allocate the buffer for tags similarity matrix. - tag_copy = np.empty_like(tag[0, ..., 0]) - for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): - if keypoints[i, 2] > 0: - continue - tag_copy[...] = _tag[..., 0] - diff = tag_copy - diff -= prev_tag - np.abs(diff, out=diff) - np.floor(diff + 0.5, out=diff) - diff -= _heatmap - idx = diff.argmin() - y, x = np.divmod(idx, _heatmap.shape[-1]) - - # detection score at maximum position - val = _heatmap[y, x] - - if val > 0: - keypoints[i, :3] = x, y, val - if 1 < x < W - 1 and 1 < y < H - 1: - diff = np.array([ - _heatmap[y, x + 1] - _heatmap[y, x - 1], - _heatmap[y + 1, x] - _heatmap[y - 1, x] - ]) - keypoints[i, :2] += np.sign(diff) * .25 - - return keypoints - - def __call__(self, heatmaps, tags, nms_heatmaps=None): - ans = self.match(**self.top_k(nms_heatmaps, tags)) - ans, ans_tags = map(list, zip(*ans)) - - if self.do_adjust: - ans = self.adjust(ans, heatmaps) - - if self.delta != 0.0: - for people in ans: - for person in people: - for joint in person: - joint[:2] += self.delta - - ans = ans[0] - scores = np.asarray([i[:, 2].mean() for i in ans]) - - if self.do_refine: - heatmap_numpy = heatmaps[0] - tag_numpy = tags[0] - for i in range(len(ans)): - ans[i] = self.refine(heatmap_numpy, tag_numpy, ans[i], ans_tags[0][i]) - - return ans, scores - - -class AssociativeEmbeddingAdapter(Adapter): - __provider__ = 'human_pose_estimation_ae' - prediction_types = (PoseEstimationPrediction, ) - - @classmethod - def parameters(cls): - parameters = super().parameters() - parameters.update({ - 'heatmaps_out': StringField( - description="Name of output layer with keypoints heatmaps.", - optional=True - ), - 'nms_heatmaps_out': StringField( - description="Name of output layer with keypoints heatmaps after NMS.", - optional=True - ), - 'embeddings_out': StringField( - description="Name of output layer with associative embeddings.", - optional=True - ), - }) - return parameters - - def validate_config(self): - super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) - - def configure(self): - self.heatmaps = self.get_value_from_config('heatmaps_out') - self.nms_heatmaps = self.get_value_from_config('nms_heatmaps_out') - self.embeddings = self.get_value_from_config('embeddings_out') - self.decoder = AssociativeEmbeddingDecoder( - num_joints=17, - adjust=True, - refine=True, - delta=0.0, - max_num_people=30, - detection_threshold=0.1, - tag_threshold=1, - use_detection_val=True, - ignore_too_much=False) - - def process(self, raw, identifiers, frame_meta): - result = [] - raw_outputs = self._extract_predictions(raw, frame_meta) - if not contains_all(raw_outputs, (self.heatmaps, self.nms_heatmaps, self.embeddings)): - raise ConfigError('Some of the outputs are not found') - raw_output = zip(identifiers, raw_outputs[self.heatmaps][None], - raw_outputs[self.nms_heatmaps][None], - raw_outputs[self.embeddings][None], frame_meta) - - for identifier, heatmap, nms_heatmap, embedding, meta in raw_output: - poses, scores = self.decoder(heatmap, embedding, nms_heatmaps=nms_heatmap) - if len(scores) == 0: - result.append(PoseEstimationPrediction( - identifier, - np.empty((0, 17), dtype=float), - np.empty((0, 17), dtype=float), - np.empty((0, 17), dtype=float), - np.empty((0, ), dtype=float) - )) - continue - poses = poses.astype(float) - scores = np.asarray(scores).astype(float) - scale_x = meta['scale_x'] - scale_y = meta['scale_y'] - poses[:, :, 0] /= scale_x / 2 - poses[:, :, 1] /= scale_y / 2 - point_scores = poses[:, :, 2] - result.append(PoseEstimationPrediction( - identifier, - poses[:, :, 0], - poses[:, :, 1], - point_scores, - scores)) - return result - - class SingleHumanPoseAdapter(Adapter): __provider__ = 'single_human_pose_estimation' prediction_types = (PoseEstimationPrediction, ) @@ -900,295 +496,3 @@ def get_preds(scores): preds = preds.reshape(1, preds.size) return preds - - -class HeatmapNMS: - def __init__(self, kernel): - self.kernel = kernel - self.pad = (kernel - 1) // 2 - - def max_pool(self, x): - # Max pooling kernel x kernel with stride 1 x 1. - k = self.kernel - p = self.pad - pooled = np.zeros_like(x) - hmap = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p))) - h, w = hmap.shape[-2:] - for i in range(k): - n = (h - i) // k * k - for j in range(k): - m = (w - j) // k * k - hmap_slice = hmap[..., i:i + n, j:j + m] - pooled[..., i::k, j::k] = block_reduce(hmap_slice, (1, 1, k, k), np.max) - return pooled - - def __call__(self, heatmaps): - pooled = self.max_pool(heatmaps) - return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) - - - -class OpenPoseDecoder: - - BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), - (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) - BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) - - def __init__(self, num_joints=18, skeleton=BODY_PARTS_KPT_IDS, paf_indices=BODY_PARTS_PAF_IDS, - max_points=100, score_threshold=0.1, min_paf_alignment_score=0.05, delta=0.5): - self.num_joints = num_joints - self.skeleton = skeleton - self.paf_indices = paf_indices - self.max_points = max_points - self.score_threshold = score_threshold - self.min_paf_alignment_score = min_paf_alignment_score - self.delta = delta - - self.points_per_limb = 10 - self.grid = np.arange(self.points_per_limb, dtype=np.float32).reshape(1, -1, 1) - - def __call__(self, heatmaps, nms_heatmaps, pafs): - batch_size, _, h, w = heatmaps.shape - assert batch_size == 1, 'Batch size of 1 only supported' - - keypoints = self.extract_points(heatmaps, nms_heatmaps) - pafs = np.transpose(pafs, (0, 2, 3, 1)) - - if self.delta > 0: - for kpts in keypoints: - kpts[:, :2] += self.delta - np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) - np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) - - pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) - poses, scores = self.convert_to_coco_format(pose_entries, keypoints) - if len(poses) > 0: - poses = np.asarray(poses, dtype=np.float32) - poses = poses.reshape((poses.shape[0], -1, 3)) - else: - poses = np.empty((0, 17, 3), dtype=np.float32) - scores = np.empty(0, dtype=np.float32) - - return poses, scores - - def extract_points(self, heatmaps, nms_heatmaps): - batch_size, channels_num, h, w = heatmaps.shape - assert batch_size == 1, 'Batch size of 1 only supported' - assert channels_num >= self.num_joints - - xs, ys, scores = self.top_k(nms_heatmaps) - masks = scores > self.score_threshold - all_keypoints = [] - keypoint_id = 0 - for k in range(self.num_joints): - # Filter low-score points. - mask = masks[0, k] - x = xs[0, k][mask].ravel() - y = ys[0, k][mask].ravel() - score = scores[0, k][mask].ravel() - n = len(x) - if n == 0: - all_keypoints.append(np.empty((0, 4), dtype=np.float32)) - continue - # Apply quarter offset to improve localization accuracy. - x, y = self.refine(heatmaps[0, k], x, y) - np.core.umath.clip(x, 0, w - 1, out=x) - np.core.umath.clip(y, 0, h - 1, out=y) - # Pack resulting points. - keypoints = np.empty((n, 4), dtype=np.float32) - keypoints[:, 0] = x - keypoints[:, 1] = y - keypoints[:, 2] = score - keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) - keypoint_id += n - all_keypoints.append(keypoints) - return all_keypoints - - def top_k(self, heatmaps): - N, K, _, W = heatmaps.shape - heatmaps = heatmaps.reshape(N, K, -1) - # Get positions with top scores. - ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] - scores = np.take_along_axis(heatmaps, ind, axis=2) - # Keep top scores sorted. - subind = np.argsort(-scores, axis=2) - ind = np.take_along_axis(ind, subind, axis=2) - scores = np.take_along_axis(scores, subind, axis=2) - y, x = np.divmod(ind, W) - return x, y, scores - - @staticmethod - def refine(heatmap, x, y): - h, w = heatmap.shape[-2:] - valid = np.logical_and(np.logical_and(x > 0, x < w - 1), np.logical_and(y > 0, y < h - 1)) - xx = x[valid] - yy = y[valid] - dx = np.sign(heatmap[yy, xx + 1] - heatmap[yy, xx - 1], dtype=np.float32) * 0.25 - dy = np.sign(heatmap[yy + 1, xx] - heatmap[yy - 1, xx], dtype=np.float32) * 0.25 - x = x.astype(np.float32) - y = y.astype(np.float32) - x[valid] += dx - y[valid] += dy - return x, y - - @staticmethod - def update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): - if part_id == 0: - pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] - for pose, connection in zip(pose_entries, connections): - pose[kpt_a_id] = connection[0] - pose[kpt_b_id] = connection[1] - pose[-1] = 2 - # pose score = sum of all points' scores + sum of all connections' scores - pose[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] - else: - for connection in connections: - pose_a_idx = -1 - pose_b_idx = -1 - for j, pose in enumerate(pose_entries): - if pose[kpt_a_id] == connection[0]: - pose_a_idx = j - if pose[kpt_b_id] == connection[1]: - pose_b_idx = j - if pose_a_idx < 0 and pose_b_idx < 0: - # Create new pose entry. - pose_entry = np.full(pose_entry_size, -1) - pose_entry[kpt_a_id] = connection[0] - pose_entry[kpt_b_id] = connection[1] - pose_entry[-1] = 2 - pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] - pose_entries.append(pose_entry) - elif pose_a_idx >= 0 and pose_b_idx >= 0: - if pose_a_idx != pose_b_idx: - # Merge two disjoint components into one pose. - pose_a = pose_entries[pose_a_idx] - pose_b = pose_entries[pose_b_idx] - do_merge_poses = True - for j in range(len(pose_b) - 2): - if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: - do_merge_poses = False - break - if not do_merge_poses: - continue - for j in range(len(pose_b) - 2): - if pose_b[j] >= 0: - pose_a[j] = pose_b[j] - pose_a[-1] += pose_b[-1] - pose_a[-2] += pose_b[-2] + connection[2] - del pose_entries[pose_b_idx] - else: - # Adjust score of a pose. - pose_entries[pose_a_idx][-2] += connection[2] - elif pose_a_idx >= 0: - # Add a new limb into pose. - pose = pose_entries[pose_a_idx] - if pose[kpt_b_id] < 0: - pose[-2] += all_keypoints[connection[1], 2] - pose[kpt_b_id] = connection[1] - pose[-2] += connection[2] - pose[-1] += 1 - elif pose_b_idx >= 0: - # Add a new limb into pose. - pose = pose_entries[pose_b_idx] - if pose[kpt_a_id] < 0: - pose[-2] += all_keypoints[connection[0], 2] - pose[kpt_a_id] = connection[0] - pose[-2] += connection[2] - pose[-1] += 1 - return pose_entries - - def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): - all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) - pose_entries = [] - # For every limb. - for part_id, paf_channel in enumerate(self.paf_indices): - kpt_a_id, kpt_b_id = self.skeleton[part_id] - kpts_a = all_keypoints_by_type[kpt_a_id] - kpts_b = all_keypoints_by_type[kpt_b_id] - n = len(kpts_a) - m = len(kpts_b) - if n == 0 or m == 0: - continue - - # Get vectors between all pairs of keypoints, i.e. candidate limb vectors. - a = kpts_a[:, :2] - a = np.broadcast_to(a[None], (m, n, 2)) - b = kpts_b[:, :2] - vec_raw = (b[:, None, :] - a).reshape(-1, 1, 2) - - # Sample points along every candidate limb vector. - steps = (1 / (self.points_per_limb - 1) * vec_raw) - points = steps * self.grid + a.reshape(-1, 1, 2) - points = points.round().astype(dtype=np.int32) - x = points[..., 0].ravel() - y = points[..., 1].ravel() - - # Compute affinity score between candidate limb vectors and part affinity field. - part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] - field = part_pafs[y, x].reshape(-1, self.points_per_limb, 2) - vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) - vec = vec_raw / (vec_norm + 1e-6) - affinity_scores = (field * vec).sum(-1).reshape(-1, self.points_per_limb) - valid_affinity_scores = affinity_scores > self.min_paf_alignment_score - valid_num = valid_affinity_scores.sum(1) - affinity_scores = (affinity_scores * valid_affinity_scores).sum(1) / (valid_num + 1e-6) - success_ratio = valid_num / self.points_per_limb - - # Get a list of limbs according to the obtained affinity score. - valid_limbs = np.where(np.logical_and(affinity_scores > 0, success_ratio > 0.8))[0] - affinity_scores = affinity_scores[valid_limbs] - b_idx, a_idx = np.divmod(valid_limbs, n) - if len(affinity_scores) == 0: - continue - - # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. - order = affinity_scores.argsort()[::-1] - affinity_scores = affinity_scores[order] - a_idx = a_idx[order] - b_idx = b_idx[order] - a_idx_unique = np.unique(a_idx, return_index=True)[1] - b_idx_unique = np.unique(b_idx, return_index=True)[1] - idx = np.intersect1d(a_idx_unique, b_idx_unique, assume_unique=True) - a = kpts_a[a_idx[idx], 3].astype(np.int32) - b = kpts_b[b_idx[idx], 3].astype(np.int32) - connections = list(zip(a, b, affinity_scores[idx])) - - if len(connections) == 0: - continue - - # Update poses with new connections. - pose_entries = self.update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, - connections, pose_entries, pose_entry_size) - - # Remove poses with not enough points. - filtered_entries = [] - for pose in pose_entries: - if pose[-1] < 3: - continue - filtered_entries.append(pose) - pose_entries = np.asarray(filtered_entries, dtype=np.float32) - return pose_entries, all_keypoints - - @staticmethod - def convert_to_coco_format(pose_entries, all_keypoints): - num_joints = 17 - coco_keypoints = [] - scores = [] - for pose in pose_entries: - if len(pose) == 0: - continue - keypoints = np.zeros(num_joints * 3) - reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] - person_score = pose[-2] - for keypoint_id, target_id in zip(pose[:-2], reorder_map): - if target_id < 0: - continue - cx, cy, score = 0, 0, 0 # keypoint not found - if keypoint_id != -1: - cx, cy, score = all_keypoints[int(keypoint_id), 0:3] - keypoints[target_id * 3 + 0] = cx - keypoints[target_id * 3 + 1] = cy - keypoints[target_id * 3 + 2] = score - coco_keypoints.append(keypoints) - scores.append(person_score * max(0, (pose[-1] - 1))) # -1 for 'neck' - return np.asarray(coco_keypoints), np.asarray(scores) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py new file mode 100644 index 00000000000..39b58486926 --- /dev/null +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py @@ -0,0 +1,302 @@ +""" +Copyright (c) 2020 Intel Corporation + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +import numpy as np +from scipy.optimize import linear_sum_assignment + +from ..adapters import Adapter +from ..config import ConfigValidator, StringField, ConfigError +from ..representation import PoseEstimationPrediction +from ..utils import contains_all + + +class AssociativeEmbeddingAdapter(Adapter): + __provider__ = 'human_pose_estimation_ae' + prediction_types = (PoseEstimationPrediction, ) + + @classmethod + def parameters(cls): + parameters = super().parameters() + parameters.update({ + 'heatmaps_out': StringField( + description="Name of output layer with keypoints heatmaps.", + optional=True + ), + 'nms_heatmaps_out': StringField( + description="Name of output layer with keypoints heatmaps after NMS.", + optional=True + ), + 'embeddings_out': StringField( + description="Name of output layer with associative embeddings.", + optional=True + ), + }) + return parameters + + def validate_config(self): + super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) + + def configure(self): + self.heatmaps = self.get_value_from_config('heatmaps_out') + self.nms_heatmaps = self.get_value_from_config('nms_heatmaps_out') + self.embeddings = self.get_value_from_config('embeddings_out') + self.decoder = AssociativeEmbeddingDecoder( + num_joints=17, + adjust=True, + refine=True, + delta=0.0, + max_num_people=30, + detection_threshold=0.1, + tag_threshold=1, + use_detection_val=True, + ignore_too_much=False) + + def process(self, raw, identifiers, frame_meta): + result = [] + raw_outputs = self._extract_predictions(raw, frame_meta) + if not contains_all(raw_outputs, (self.heatmaps, self.nms_heatmaps, self.embeddings)): + raise ConfigError('Some of the outputs are not found') + raw_output = zip(identifiers, raw_outputs[self.heatmaps][None], + raw_outputs[self.nms_heatmaps][None], + raw_outputs[self.embeddings][None], frame_meta) + + for identifier, heatmap, nms_heatmap, embedding, meta in raw_output: + poses, scores = self.decoder(heatmap, embedding, nms_heatmaps=nms_heatmap) + if len(scores) == 0: + result.append(PoseEstimationPrediction( + identifier, + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, ), dtype=float) + )) + continue + poses = poses.astype(float) + scores = np.asarray(scores).astype(float) + scale_x = meta['scale_x'] + scale_y = meta['scale_y'] + poses[:, :, 0] /= scale_x / 2 + poses[:, :, 1] /= scale_y / 2 + point_scores = poses[:, :, 2] + result.append(PoseEstimationPrediction( + identifier, + poses[:, :, 0], + poses[:, :, 1], + point_scores, + scores)) + return result + + +class Pose: + def __init__(self, num_joints, tag_size=1): + self.num_joints = num_joints + self.tag_size = tag_size + self.pose = np.zeros((num_joints, 2 + 1 + tag_size), dtype=np.float32) + self.pose_tag = np.zeros(tag_size, dtype=np.float32) + self.valid_points_num = 0 + + def add(self, idx, joint, tag): + self.pose[idx] = joint + self.pose_tag = (self.pose_tag * self.valid_points_num) + tag + self.valid_points_num += 1 + self.pose_tag /= self.valid_points_num + + @property + def tag(self): + if self.valid_points_num > 0: + return self.pose_tag + return None + + +class AssociativeEmbeddingDecoder: + def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, + ignore_too_much, tag_threshold, + adjust=True, refine=True, delta=0.0, joints_order=None): + self.num_joints = num_joints + self.max_num_people = max_num_people + self.detection_threshold = detection_threshold + self.tag_threshold = tag_threshold + self.use_detection_val = use_detection_val + self.ignore_too_much = ignore_too_much + + if self.num_joints == 17 and joints_order is None: + self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) + else: + self.joint_order = list(np.arange(self.num_joints)) + + self.do_adjust = adjust + self.do_refine = refine + self.delta = delta + + def match(self, tag_k, loc_k, val_k): + return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) + + @staticmethod + def _max_match(scores): + r, c = linear_sum_assignment(scores) + tmp = np.stack((r, c), axis=1) + return tmp + + def _match_by_tag(self, inp): + tag_k, loc_k, val_k = inp + embd_size = tag_k.shape[2] + all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) + + poses = [] + for idx in self.joint_order: + tags = tag_k[idx] + joints = all_joints[idx] + mask = joints[:, 2] > self.detection_threshold + tags = tags[mask] + joints = joints[mask] + + if len(poses) == 0: + for tag, joint in zip(tags, joints): + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joint, tag) + poses.append(pose) + continue + + if joints.shape[0] == 0 or (self.ignore_too_much and len(poses) == self.max_num_people): + continue + + poses_tags = np.stack([p.tag for p in poses], axis=0) + diff = tags[:, None] - poses_tags[None, :] + diff_normed = np.linalg.norm(diff, ord=2, axis=2) + diff_saved = np.copy(diff_normed) + if self.use_detection_val: + diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] + num_added = diff.shape[0] + num_grouped = diff.shape[1] + if num_added > num_grouped: + np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), constant_values=1e10) + pairs = self._max_match(diff_normed) + for row, col in pairs: + if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: + poses[col].add(idx, joints[row], tags[row]) + else: + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joints[row], tags[row]) + poses.append(pose) + + ans = np.asarray([p.pose for p in poses], dtype=np.float32).reshape(-1, self.num_joints, 2 + 1 + embd_size) + tags = np.asarray([p.tag for p in poses], dtype=np.float32).reshape(-1, embd_size) + return ans, tags + + def top_k(self, heatmaps, tags): + N, K, H, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] + val_k = np.take_along_axis(heatmaps, ind, axis=2) + subind = np.argsort(-val_k, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + val_k = np.take_along_axis(val_k, subind, axis=2) + + tags = tags.reshape(N, K, W * H, -1) + tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] + tag_k = np.stack(tag_k, axis=3) + + x = ind % W + y = ind // W + ind_k = np.stack((x, y), axis=3) + + ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} + return ans + + @staticmethod + def adjust(ans, heatmaps): + H, W = heatmaps.shape[-2:] + for n, people in enumerate(ans): + for person in people: + for k, joint in enumerate(person): + heatmap = heatmaps[n, k] + px = int(joint[0]) + py = int(joint[1]) + if 1 < px < W - 1 and 1 < py < H - 1: + diff = np.array([ + heatmap[py, px + 1] - heatmap[py, px - 1], + heatmap[py + 1, px] - heatmap[py - 1, px] + ]) + joint[:2] += np.sign(diff) * .25 + return ans + + @staticmethod + def refine(heatmap, tag, keypoints, pose_tag=None): + K, H, W = heatmap.shape + if len(tag.shape) == 3: + tag = tag[..., None] + + if pose_tag is not None: + prev_tag = pose_tag + else: + tags = [] + for i in range(K): + if keypoints[i, 2] > 0: + x, y = keypoints[i][:2].astype(int) + tags.append(tag[i, y, x]) + prev_tag = np.mean(tags, axis=0) + + # Allocate the buffer for tags similarity matrix. + tag_copy = np.empty_like(tag[0, ..., 0]) + for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): + if keypoints[i, 2] > 0: + continue + tag_copy[...] = _tag[..., 0] + diff = tag_copy + diff -= prev_tag + np.abs(diff, out=diff) + np.floor(diff + 0.5, out=diff) + diff -= _heatmap + idx = diff.argmin() + y, x = np.divmod(idx, _heatmap.shape[-1]) + + # detection score at maximum position + val = _heatmap[y, x] + + if val > 0: + keypoints[i, :3] = x, y, val + if 1 < x < W - 1 and 1 < y < H - 1: + diff = np.array([ + _heatmap[y, x + 1] - _heatmap[y, x - 1], + _heatmap[y + 1, x] - _heatmap[y - 1, x] + ]) + keypoints[i, :2] += np.sign(diff) * .25 + + return keypoints + + def __call__(self, heatmaps, tags, nms_heatmaps=None): + ans = self.match(**self.top_k(nms_heatmaps, tags)) + ans, ans_tags = map(list, zip(*ans)) + + if self.do_adjust: + ans = self.adjust(ans, heatmaps) + + if self.delta != 0.0: + for people in ans: + for person in people: + for joint in person: + joint[:2] += self.delta + + ans = ans[0] + scores = np.asarray([i[:, 2].mean() for i in ans]) + + if self.do_refine: + heatmap_numpy = heatmaps[0] + tag_numpy = tags[0] + for i, pose in enumerate(ans): + ans[i] = self.refine(heatmap_numpy, tag_numpy, pose, ans_tags[0][i]) + + return ans, scores diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py new file mode 100644 index 00000000000..e5a0fe0775e --- /dev/null +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py @@ -0,0 +1,414 @@ +""" +Copyright (c) 2020 Intel Corporation + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +import cv2 +import numpy as np +from skimage.measure import block_reduce + +from ..adapters import Adapter +from ..config import ConfigValidator, StringField, ConfigError, NumberField +from ..representation import PoseEstimationPrediction +from ..utils import contains_any + + +class OpenPoseAdapter(Adapter): + __provider__ = 'human_pose_estimation_openpose' + prediction_types = (PoseEstimationPrediction, ) + + @classmethod + def parameters(cls): + parameters = super().parameters() + parameters.update({ + 'part_affinity_fields_out': StringField( + description="Name of output layer with keypoints pairwise relations (part affinity fields).", + optional=True + ), + 'keypoints_heatmap_out': StringField( + description="Name of output layer with keypoints heatmaps.", optional=True + ), + 'upscale_factor': NumberField( + description="Upscaling factor for output feature maps before postprocessing.", + value_type=float, min_value=1, default=1, optional=True + ), + }) + return parameters + + def validate_config(self): + super().validate_config(on_extra_argument=ConfigValidator.WARN_ON_EXTRA_ARGUMENT) + + def configure(self): + self.upscale_factor = self.get_value_from_config('upscale_factor') + self.part_affinity_fields = self.get_value_from_config('part_affinity_fields_out') + self.keypoints_heatmap = self.get_value_from_config('keypoints_heatmap_out') + self.concat_out = self.part_affinity_fields is None and self.keypoints_heatmap is None + if not self.concat_out: + contains_both = self.part_affinity_fields is not None and self.keypoints_heatmap is not None + if not contains_both: + raise ConfigError( + 'human_pose_estimation adapter should contains both: keypoints_heatmap_out ' + 'and part_affinity_fields_out or not contain them at all (in single output model case)' + ) + self._keypoints_heatmap_bias = self.keypoints_heatmap + '/add_' + self._part_affinity_fields_bias = self.part_affinity_fields + '/add_' + + self.decoder = OpenPoseDecoder(num_joints=18, delta=0.5 if self.upscale_factor == 1 else 0.0) + self.nms = HeatmapNMS(kernel=2 * int(np.round(6 / 7 * self.upscale_factor)) + 1) + + def process(self, raw, identifiers, frame_meta): + result = [] + raw_outputs = self._extract_predictions(raw, frame_meta) + if not self.concat_out: + if not contains_any(raw_outputs, [self.part_affinity_fields, self._part_affinity_fields_bias]): + raise ConfigError('part affinity fields output not found') + if not contains_any(raw_outputs, [self.keypoints_heatmap, self._keypoints_heatmap_bias]): + raise ConfigError('keypoints heatmap output not found') + keypoints_heatmap = raw_outputs[ + self.keypoints_heatmap if self.keypoints_heatmap in raw_outputs else self._keypoints_heatmap_bias + ] + pafs = raw_outputs[ + self.part_affinity_fields if self.part_affinity_fields in raw_outputs + else self._part_affinity_fields_bias + ] + raw_output = zip(identifiers, keypoints_heatmap, pafs, frame_meta) + else: + concat_out = raw_outputs[self.output_blob] + keypoints_num = concat_out.shape[1] // 3 + keypoints_heat_map = concat_out[:, :keypoints_num, :] + pafs = concat_out[:, keypoints_num:, :] + raw_output = zip(identifiers, keypoints_heat_map, pafs, frame_meta) + for identifier, heatmap, paf, meta in raw_output: + output_h, output_w = heatmap.shape[-2:] + if self.upscale_factor > 1: + self.decoder.delta = 0 + heatmap = np.transpose(heatmap, (1, 2, 0)) + heatmap = cv2.resize(heatmap, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, + interpolation=cv2.INTER_CUBIC) + heatmap = np.transpose(heatmap, (2, 0, 1)) + paf = np.transpose(np.squeeze(paf), (1, 2, 0)) + paf = cv2.resize(paf, (0, 0), fx=self.upscale_factor, fy=self.upscale_factor, + interpolation=cv2.INTER_CUBIC) + paf = np.transpose(paf, (2, 0, 1)) + hmap = heatmap[None] + nms_hmap = self.nms(hmap) + poses, scores = self.decoder(hmap, nms_hmap, paf[None]) + if len(scores) == 0: + result.append(PoseEstimationPrediction( + identifier, + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, 17), dtype=float), + np.empty((0, ), dtype=float) + )) + continue + poses = poses.astype(float) + scores = np.asarray(scores).astype(float) + scale_x = meta['scale_x'] + scale_y = meta['scale_y'] + input_h, input_w = next(iter(meta['input_shape'].values()))[-2:] + output_scale_x = input_w / output_w + output_scale_y = input_h / output_h + poses[:, :, 0] *= output_scale_x / self.upscale_factor / scale_x + poses[:, :, 1] *= output_scale_y / self.upscale_factor / scale_y + point_scores = poses[:, :, 2] + + result.append(PoseEstimationPrediction( + identifier, + poses[:, :, 0], + poses[:, :, 1], + point_scores, + scores)) + return result + + +class HeatmapNMS: + def __init__(self, kernel): + self.kernel = kernel + self.pad = (kernel - 1) // 2 + + def max_pool(self, x): + # Max pooling kernel x kernel with stride 1 x 1. + k = self.kernel + p = self.pad + pooled = np.zeros_like(x) + hmap = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p))) + h, w = hmap.shape[-2:] + for i in range(k): + n = (h - i) // k * k + for j in range(k): + m = (w - j) // k * k + hmap_slice = hmap[..., i:i + n, j:j + m] + pooled[..., i::k, j::k] = block_reduce(hmap_slice, (1, 1, k, k), np.max) + return pooled + + def __call__(self, heatmaps): + pooled = self.max_pool(heatmaps) + return heatmaps * (pooled == heatmaps).astype(heatmaps.dtype) + + +class OpenPoseDecoder: + + BODY_PARTS_KPT_IDS = ((1, 2), (1, 5), (2, 3), (3, 4), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), + (11, 12), (12, 13), (1, 0), (0, 14), (14, 16), (0, 15), (15, 17), (2, 16), (5, 17)) + BODY_PARTS_PAF_IDS = (12, 20, 14, 16, 22, 24, 0, 2, 4, 6, 8, 10, 28, 30, 34, 32, 36, 18, 26) + + def __init__(self, num_joints=18, skeleton=BODY_PARTS_KPT_IDS, paf_indices=BODY_PARTS_PAF_IDS, + max_points=100, score_threshold=0.1, min_paf_alignment_score=0.05, delta=0.5): + self.num_joints = num_joints + self.skeleton = skeleton + self.paf_indices = paf_indices + self.max_points = max_points + self.score_threshold = score_threshold + self.min_paf_alignment_score = min_paf_alignment_score + self.delta = delta + + self.points_per_limb = 10 + self.grid = np.arange(self.points_per_limb, dtype=np.float32).reshape(1, -1, 1) + + def __call__(self, heatmaps, nms_heatmaps, pafs): + batch_size, _, h, w = heatmaps.shape + assert batch_size == 1, 'Batch size of 1 only supported' + + keypoints = self.extract_points(heatmaps, nms_heatmaps) + pafs = np.transpose(pafs, (0, 2, 3, 1)) + + if self.delta > 0: + for kpts in keypoints: + kpts[:, :2] += self.delta + np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) + np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) + + pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) + poses, scores = self.convert_to_coco_format(pose_entries, keypoints) + if len(poses) > 0: + poses = np.asarray(poses, dtype=np.float32) + poses = poses.reshape((poses.shape[0], -1, 3)) + else: + poses = np.empty((0, 17, 3), dtype=np.float32) + scores = np.empty(0, dtype=np.float32) + + return poses, scores + + def extract_points(self, heatmaps, nms_heatmaps): + batch_size, channels_num, h, w = heatmaps.shape + assert batch_size == 1, 'Batch size of 1 only supported' + assert channels_num >= self.num_joints + + xs, ys, scores = self.top_k(nms_heatmaps) + masks = scores > self.score_threshold + all_keypoints = [] + keypoint_id = 0 + for k in range(self.num_joints): + # Filter low-score points. + mask = masks[0, k] + x = xs[0, k][mask].ravel() + y = ys[0, k][mask].ravel() + score = scores[0, k][mask].ravel() + n = len(x) + if n == 0: + all_keypoints.append(np.empty((0, 4), dtype=np.float32)) + continue + # Apply quarter offset to improve localization accuracy. + x, y = self.refine(heatmaps[0, k], x, y) + np.core.umath.clip(x, 0, w - 1, out=x) + np.core.umath.clip(y, 0, h - 1, out=y) + # Pack resulting points. + keypoints = np.empty((n, 4), dtype=np.float32) + keypoints[:, 0] = x + keypoints[:, 1] = y + keypoints[:, 2] = score + keypoints[:, 3] = np.arange(keypoint_id, keypoint_id + n) + keypoint_id += n + all_keypoints.append(keypoints) + return all_keypoints + + def top_k(self, heatmaps): + N, K, _, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + # Get positions with top scores. + ind = heatmaps.argpartition(-self.max_points, axis=2)[:, :, -self.max_points:] + scores = np.take_along_axis(heatmaps, ind, axis=2) + # Keep top scores sorted. + subind = np.argsort(-scores, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + scores = np.take_along_axis(scores, subind, axis=2) + y, x = np.divmod(ind, W) + return x, y, scores + + @staticmethod + def refine(heatmap, x, y): + h, w = heatmap.shape[-2:] + valid = np.logical_and(np.logical_and(x > 0, x < w - 1), np.logical_and(y > 0, y < h - 1)) + xx = x[valid] + yy = y[valid] + dx = np.sign(heatmap[yy, xx + 1] - heatmap[yy, xx - 1], dtype=np.float32) * 0.25 + dy = np.sign(heatmap[yy + 1, xx] - heatmap[yy - 1, xx], dtype=np.float32) * 0.25 + x = x.astype(np.float32) + y = y.astype(np.float32) + x[valid] += dx + y[valid] += dy + return x, y + + @staticmethod + def merge_poses(pose_a, pose_b): + do_merge_poses = True + for j in range(len(pose_b) - 2): + if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: + do_merge_poses = False + break + if not do_merge_poses: + return False + for j in range(len(pose_b) - 2): + if pose_b[j] >= 0: + pose_a[j] = pose_b[j] + pose_a[-1] += pose_b[-1] + return True + + def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): + for connection in connections: + pose_a_idx = -1 + pose_b_idx = -1 + for j, pose in enumerate(pose_entries): + if pose[kpt_a_id] == connection[0]: + pose_a_idx = j + if pose[kpt_b_id] == connection[1]: + pose_b_idx = j + if pose_a_idx < 0 and pose_b_idx < 0: + # Create new pose entry. + pose_entry = np.full(pose_entry_size, -1) + pose_entry[kpt_a_id] = connection[0] + pose_entry[kpt_b_id] = connection[1] + pose_entry[-1] = 2 + pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + pose_entries.append(pose_entry) + elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: + # Merge two disjoint components into one pose. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + if self.merge_poses(pose_a, pose_b): + pose_a[-2] += pose_b[-2] + connection[2] + del pose_entries[pose_b_idx] + elif pose_a_idx >= 0 and pose_b_idx >= 0: + # Adjust score of a pose. + pose_entries[pose_a_idx][-2] += connection[2] + elif pose_a_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_a_idx] + if pose[kpt_b_id] < 0: + pose[-2] += all_keypoints[connection[1], 2] + pose[kpt_b_id] = connection[1] + pose[-2] += connection[2] + pose[-1] += 1 + elif pose_b_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_b_idx] + if pose[kpt_a_id] < 0: + pose[-2] += all_keypoints[connection[0], 2] + pose[kpt_a_id] = connection[0] + pose[-2] += connection[2] + pose[-1] += 1 + return pose_entries + + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): + all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) + pose_entries = [] + # For every limb. + for part_id, paf_channel in enumerate(self.paf_indices): + kpt_a_id, kpt_b_id = self.skeleton[part_id] + kpts_a = all_keypoints_by_type[kpt_a_id] + kpts_b = all_keypoints_by_type[kpt_b_id] + n = len(kpts_a) + m = len(kpts_b) + if n == 0 or m == 0: + continue + + # Get vectors between all pairs of keypoints, i.e. candidate limb vectors. + a = kpts_a[:, :2] + a = np.broadcast_to(a[None], (m, n, 2)) + b = kpts_b[:, :2] + vec_raw = (b[:, None, :] - a).reshape(-1, 1, 2) + + # Sample points along every candidate limb vector. + steps = (1 / (self.points_per_limb - 1) * vec_raw) + points = steps * self.grid + a.reshape(-1, 1, 2) + points = points.round().astype(dtype=np.int32) + x = points[..., 0].ravel() + y = points[..., 1].ravel() + + # Compute affinity score between candidate limb vectors and part affinity field. + part_pafs = pafs[0, :, :, paf_channel:paf_channel + 2] + field = part_pafs[y, x].reshape(-1, self.points_per_limb, 2) + vec_norm = np.linalg.norm(vec_raw, ord=2, axis=-1, keepdims=True) + vec = vec_raw / (vec_norm + 1e-6) + affinity_scores = (field * vec).sum(-1).reshape(-1, self.points_per_limb) + valid_affinity_scores = affinity_scores > self.min_paf_alignment_score + valid_num = valid_affinity_scores.sum(1) + affinity_scores = (affinity_scores * valid_affinity_scores).sum(1) / (valid_num + 1e-6) + success_ratio = valid_num / self.points_per_limb + + # Get a list of limbs according to the obtained affinity score. + valid_limbs = np.where(np.logical_and(affinity_scores > 0, success_ratio > 0.8))[0] + affinity_scores = affinity_scores[valid_limbs] + b_idx, a_idx = np.divmod(valid_limbs, n) + if len(affinity_scores) == 0: + continue + + # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. + order = affinity_scores.argsort()[::-1] + affinity_scores = affinity_scores[order] + a_idx = a_idx[order] + b_idx = b_idx[order] + a_idx_unique = np.unique(a_idx, return_index=True)[1] + b_idx_unique = np.unique(b_idx, return_index=True)[1] + idx = np.intersect1d(a_idx_unique, b_idx_unique, assume_unique=True) + a = kpts_a[a_idx[idx], 3].astype(np.int32) + b = kpts_b[b_idx[idx], 3].astype(np.int32) + connections = list(zip(a, b, affinity_scores[idx])) + + if len(connections) == 0: + continue + + # Update poses with new connections. + pose_entries = self.update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, + connections, pose_entries, pose_entry_size) + + # Remove poses with not enough points. + pose_entries = np.asarray(pose_entries, dtype=np.float32).reshape(-1, pose_entry_size) + pose_entries = pose_entries[pose_entries[:, -1] >= 3] + return pose_entries, all_keypoints + + @staticmethod + def convert_to_coco_format(pose_entries, all_keypoints): + num_joints = 17 + coco_keypoints = [] + scores = [] + for pose in pose_entries: + if len(pose) == 0: + continue + keypoints = np.zeros(num_joints * 3) + reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] + person_score = pose[-2] + for keypoint_id, target_id in zip(pose[:-2], reorder_map): + if target_id < 0: + continue + cx, cy, score = 0, 0, 0 # keypoint not found + if keypoint_id != -1: + cx, cy, score = all_keypoints[int(keypoint_id), 0:3] + keypoints[target_id * 3 + 0] = cx + keypoints[target_id * 3 + 1] = cy + keypoints[target_id * 3 + 2] = score + coco_keypoints.append(keypoints) + scores.append(person_score * max(0, (pose[-1] - 1))) # -1 for 'neck' + return np.asarray(coco_keypoints), np.asarray(scores) From aca1ccc0fbe07a6f873ffd7a5cbb0e0b559ba644 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 02:11:16 +0300 Subject: [PATCH 37/58] fixes --- .../human_pose_estimation.py | 4 +- .../human_pose_estimation_demo/decoder.py | 220 +----------------- .../human_pose_estimation_demo/decoder_ae.py | 205 ++++++++++++++++ ...penpose_decoder.py => decoder_openpose.py} | 181 +++++++------- .../human_pose_estimation_demo/model.py | 7 +- .../pose_estimation_associative_embedding.py | 3 +- .../adapters/pose_estimation_openpose.py | 74 +++--- 7 files changed, 341 insertions(+), 353 deletions(-) create mode 100644 demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py rename demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/{openpose_decoder.py => decoder_openpose.py} (61%) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index 13b8c652bcc..f4a34ab4b6e 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -71,10 +71,10 @@ def build_argparser(): args.add_argument('--type', default='ae', choices=('ae', 'openpose'), type=str, help='Optional. Type of the network, either "ae" for associative embedding' - 'or "openpose" for openpose.' ) + 'or "openpose" for openpose.') args.add_argument('--tsize', default=None, type=int, help='Optional. Target input size. By default target size is derived from image input shape' - 'of a provided network and depends on the network type.' ) + 'of a provided network and depends on the network type.') return parser diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py index 42076109947..3e696295028 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py @@ -1,218 +1,2 @@ -import numpy as np -from openvino.inference_engine import IECore -from scipy.optimize import linear_sum_assignment - - -class AssociativeEmbeddingDecoder: - - def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, - ignore_too_much, tag_threshold, adjust=True, refine=True, delta=0.0, joints_order=None): - self.num_joints = num_joints - self.max_num_people = max_num_people - self.detection_threshold = detection_threshold - self.tag_threshold = tag_threshold - self.use_detection_val = use_detection_val - self.ignore_too_much = ignore_too_much - - if self.num_joints == 17 and joints_order is None: - self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) - else: - self.joint_order = list(np.arange(self.num_joints)) - - self.do_adjust = adjust - self.do_refine = refine - self.delta = delta - - def match(self, tag_k, loc_k, val_k): - return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) - - def _max_match(self, scores): - r, c = linear_sum_assignment(scores) - tmp = np.stack((r, c), axis=1) - return tmp - - def _match_by_tag(self, inp): - tag_k, loc_k, val_k = inp - - embd_size = tag_k.shape[2] - - class Pose: - def __init__(self, num_joints, tag_size=1): - self.num_joints = num_joints - self.tag_size = tag_size - self.pose = np.zeros((num_joints, 2 + 1 + tag_size), dtype=np.float32) - self.pose_tag = np.zeros(tag_size, dtype=np.float32) - self.valid_points_num = 0 - - def add(self, idx, joint, tag): - self.pose[idx] = joint - self.pose_tag = (self.pose_tag * self.valid_points_num) + tag - self.valid_points_num += 1 - self.pose_tag /= self.valid_points_num - - @property - def tag(self): - if self.valid_points_num > 0: - return self.pose_tag - else: - return None - - all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) - - poses = [] - for idx in self.joint_order: - tags = tag_k[idx] - joints = all_joints[idx] - mask = joints[:, 2] > self.detection_threshold - tags = tags[mask] - joints = joints[mask] - - if joints.shape[0] == 0: - continue - - if len(poses) == 0: - for tag, joint in zip(tags, joints): - pose = Pose(self.num_joints, embd_size) - pose.add(idx, joint, tag) - poses.append(pose) - else: - if self.ignore_too_much and len(poses) == self.max_num_people: - continue - poses_tags = np.stack([p.tag for p in poses], axis=0) - - diff = tags[:, None] - poses_tags[None, :] - diff_normed = np.linalg.norm(diff, ord=2, axis=2) - diff_saved = np.copy(diff_normed) - - if self.use_detection_val: - diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] - - num_added = diff.shape[0] - num_grouped = diff.shape[1] - - if num_added > num_grouped: - diff_normed = np.concatenate( - (diff_normed, - np.zeros((num_added, num_added - num_grouped), - dtype=np.float32) + 1e10), - axis=1) - - pairs = self._max_match(diff_normed) - for row, col in pairs: - if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: - poses[col].add(idx, joints[row], tags[row]) - else: - pose = Pose(self.num_joints, embd_size) - pose.add(idx, joints[row], tags[row]) - poses.append(pose) - - if len(poses): - ans = np.stack([p.pose for p in poses]).astype(np.float32) - tags = np.stack([p.tag for p in poses]).astype(np.float32) - else: - ans = np.empty((0, self.num_joints, 2 + 1 + embd_size), dtype=np.float32) - tags = np.empty((0, embd_size), dtype=np.float32) - return ans, tags - - def top_k(self, heatmaps, tags): - N, K, H, W = heatmaps.shape - heatmaps = heatmaps.reshape(N, K, -1) - ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] - val_k = np.take_along_axis(heatmaps, ind, axis=2) - subind = np.argsort(-val_k, axis=2) - ind = np.take_along_axis(ind, subind, axis=2) - val_k = np.take_along_axis(val_k, subind, axis=2) - - tags = tags.reshape(N, K, W * H, -1) - tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] - tag_k = np.stack(tag_k, axis=3) - - x = ind % W - y = ind // W - ind_k = np.stack((x, y), axis=3) - - ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} - return ans - - def adjust(self, ans, heatmaps): - H, W = heatmaps.shape[-2:] - for n, people in enumerate(ans): - for person in people: - for k, joint in enumerate(person): - heatmap = heatmaps[n, k] - px = int(joint[0]) - py = int(joint[1]) - if 1 < px < W - 1 and 1 < py < H - 1: - diff = np.array([ - heatmap[py, px + 1] - heatmap[py, px - 1], - heatmap[py + 1, px] - heatmap[py - 1, px] - ]) - joint[:2] += np.sign(diff) * .25 - return ans - - def refine(self, heatmap, tag, keypoints, pose_tag=None): - K, H, W = heatmap.shape - if len(tag.shape) == 3: - tag = tag[..., None] - - if pose_tag is not None: - prev_tag = pose_tag - else: - tags = [] - for i in range(K): - if keypoints[i, 2] > 0: - x, y = keypoints[i][:2].astype(int) - tags.append(tag[i, y, x]) - prev_tag = np.mean(tags, axis=0) - - # Allocate the buffer for tags similarity matrix. - tag_copy = np.empty_like(tag[0, ..., 0]) - for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): - if keypoints[i, 2] > 0: - continue - tag_copy[...] = _tag[..., 0] - diff = tag_copy - diff -= prev_tag - np.abs(diff, out=diff) - np.floor(diff + 0.5, out=diff) - diff -= _heatmap - idx = diff.argmin() - y, x = np.divmod(idx, _heatmap.shape[-1]) - - # detection score at maximum position - val = _heatmap[y, x] - - if val > 0: - keypoints[i, :3] = x, y, val - if 1 < x < W - 1 and 1 < y < H - 1: - diff = np.array([ - _heatmap[y, x + 1] - _heatmap[y, x - 1], - _heatmap[y + 1, x] - _heatmap[y - 1, x] - ]) - keypoints[i, :2] += np.sign(diff) * .25 - - return keypoints - - def __call__(self, heatmaps, tags, nms_heatmaps=None): - ans = self.match(**self.top_k(nms_heatmaps, tags)) - ans, ans_tags = map(list, zip(*ans)) - - if self.do_adjust: - ans = self.adjust(ans, heatmaps) - - if self.delta != 0.0: - for people in ans: - for person in people: - for joint in person: - joint[:2] += self.delta - - ans = ans[0] - scores = np.asarray([i[:, 2].mean() for i in ans]) - - if self.do_refine: - heatmap_numpy = heatmaps[0] - tag_numpy = tags[0] - for i in range(len(ans)): - ans[i] = self.refine(heatmap_numpy, tag_numpy, ans[i], ans_tags[0][i]) - - return ans, scores +from .decoder_ae import AssociativeEmbeddingDecoder +from .decoder_openpose import OpenPoseDecoder diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py new file mode 100644 index 00000000000..05bbf4bcaf6 --- /dev/null +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py @@ -0,0 +1,205 @@ +import numpy as np +from scipy.optimize import linear_sum_assignment + + +class Pose: + def __init__(self, num_joints, tag_size=1): + self.num_joints = num_joints + self.tag_size = tag_size + self.pose = np.zeros((num_joints, 2 + 1 + tag_size), dtype=np.float32) + self.pose_tag = np.zeros(tag_size, dtype=np.float32) + self.valid_points_num = 0 + + def add(self, idx, joint, tag): + self.pose[idx] = joint + self.pose_tag = (self.pose_tag * self.valid_points_num) + tag + self.valid_points_num += 1 + self.pose_tag /= self.valid_points_num + + @property + def tag(self): + if self.valid_points_num > 0: + return self.pose_tag + return None + + +class AssociativeEmbeddingDecoder: + def __init__(self, num_joints, max_num_people, detection_threshold, use_detection_val, + ignore_too_much, tag_threshold, + adjust=True, refine=True, delta=0.0, joints_order=None): + self.num_joints = num_joints + self.max_num_people = max_num_people + self.detection_threshold = detection_threshold + self.tag_threshold = tag_threshold + self.use_detection_val = use_detection_val + self.ignore_too_much = ignore_too_much + + if self.num_joints == 17 and joints_order is None: + self.joint_order = (0, 1, 2, 3, 4, 5, 6, 11, 12, 7, 8, 9, 10, 13, 14, 15, 16) + else: + self.joint_order = list(np.arange(self.num_joints)) + + self.do_adjust = adjust + self.do_refine = refine + self.delta = delta + + def match(self, tag_k, loc_k, val_k): + return list(map(self._match_by_tag, zip(tag_k, loc_k, val_k))) + + @staticmethod + def _max_match(scores): + r, c = linear_sum_assignment(scores) + tmp = np.stack((r, c), axis=1) + return tmp + + def _match_by_tag(self, inp): + tag_k, loc_k, val_k = inp + embd_size = tag_k.shape[2] + all_joints = np.concatenate((loc_k, val_k[..., None], tag_k), -1) + + poses = [] + for idx in self.joint_order: + tags = tag_k[idx] + joints = all_joints[idx] + mask = joints[:, 2] > self.detection_threshold + tags = tags[mask] + joints = joints[mask] + + if len(poses) == 0: + for tag, joint in zip(tags, joints): + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joint, tag) + poses.append(pose) + continue + + if joints.shape[0] == 0 or (self.ignore_too_much and len(poses) == self.max_num_people): + continue + + poses_tags = np.stack([p.tag for p in poses], axis=0) + diff = tags[:, None] - poses_tags[None, :] + diff_normed = np.linalg.norm(diff, ord=2, axis=2) + diff_saved = np.copy(diff_normed) + if self.use_detection_val: + diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3] + num_added = diff.shape[0] + num_grouped = diff.shape[1] + if num_added > num_grouped: + diff_normed = np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), constant_values=1e10) + + pairs = self._max_match(diff_normed) + for row, col in pairs: + if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: + poses[col].add(idx, joints[row], tags[row]) + else: + pose = Pose(self.num_joints, embd_size) + pose.add(idx, joints[row], tags[row]) + poses.append(pose) + + ans = np.asarray([p.pose for p in poses], dtype=np.float32).reshape(-1, self.num_joints, 2 + 1 + embd_size) + tags = np.asarray([p.tag for p in poses], dtype=np.float32).reshape(-1, embd_size) + return ans, tags + + def top_k(self, heatmaps, tags): + N, K, H, W = heatmaps.shape + heatmaps = heatmaps.reshape(N, K, -1) + ind = heatmaps.argpartition(-self.max_num_people, axis=2)[:, :, -self.max_num_people:] + val_k = np.take_along_axis(heatmaps, ind, axis=2) + subind = np.argsort(-val_k, axis=2) + ind = np.take_along_axis(ind, subind, axis=2) + val_k = np.take_along_axis(val_k, subind, axis=2) + + tags = tags.reshape(N, K, W * H, -1) + tag_k = [np.take_along_axis(tags[..., i], ind, axis=2) for i in range(tags.shape[3])] + tag_k = np.stack(tag_k, axis=3) + + x = ind % W + y = ind // W + ind_k = np.stack((x, y), axis=3) + + ans = {'tag_k': tag_k, 'loc_k': ind_k, 'val_k': val_k} + return ans + + @staticmethod + def adjust(ans, heatmaps): + H, W = heatmaps.shape[-2:] + for n, people in enumerate(ans): + for person in people: + for k, joint in enumerate(person): + heatmap = heatmaps[n, k] + px = int(joint[0]) + py = int(joint[1]) + if 1 < px < W - 1 and 1 < py < H - 1: + diff = np.array([ + heatmap[py, px + 1] - heatmap[py, px - 1], + heatmap[py + 1, px] - heatmap[py - 1, px] + ]) + joint[:2] += np.sign(diff) * .25 + return ans + + @staticmethod + def refine(heatmap, tag, keypoints, pose_tag=None): + K, H, W = heatmap.shape + if len(tag.shape) == 3: + tag = tag[..., None] + + if pose_tag is not None: + prev_tag = pose_tag + else: + tags = [] + for i in range(K): + if keypoints[i, 2] > 0: + x, y = keypoints[i][:2].astype(int) + tags.append(tag[i, y, x]) + prev_tag = np.mean(tags, axis=0) + + # Allocate the buffer for tags similarity matrix. + tag_copy = np.empty_like(tag[0, ..., 0]) + for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): + if keypoints[i, 2] > 0: + continue + tag_copy[...] = _tag[..., 0] + diff = tag_copy + diff -= prev_tag + np.abs(diff, out=diff) + np.floor(diff + 0.5, out=diff) + diff -= _heatmap + idx = diff.argmin() + y, x = np.divmod(idx, _heatmap.shape[-1]) + + # detection score at maximum position + val = _heatmap[y, x] + + if val > 0: + keypoints[i, :3] = x, y, val + if 1 < x < W - 1 and 1 < y < H - 1: + diff = np.array([ + _heatmap[y, x + 1] - _heatmap[y, x - 1], + _heatmap[y + 1, x] - _heatmap[y - 1, x] + ]) + keypoints[i, :2] += np.sign(diff) * .25 + + return keypoints + + def __call__(self, heatmaps, tags, nms_heatmaps=None): + ans = self.match(**self.top_k(nms_heatmaps, tags)) + ans, ans_tags = map(list, zip(*ans)) + + if self.do_adjust: + ans = self.adjust(ans, heatmaps) + + if self.delta != 0.0: + for people in ans: + for person in people: + for joint in person: + joint[:2] += self.delta + + ans = ans[0] + scores = np.asarray([i[:, 2].mean() for i in ans]) + + if self.do_refine: + heatmap_numpy = heatmaps[0] + tag_numpy = tags[0] + for i, pose in enumerate(ans): + ans[i] = self.refine(heatmap_numpy, tag_numpy, pose, ans_tags[0][i]) + + return ans, scores diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py similarity index 61% rename from demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py rename to demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py index f6de17a7bb0..6897eacc1a1 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/openpose_decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py @@ -90,9 +90,10 @@ def top_k(self, heatmaps): y, x = np.divmod(ind, W) return x, y, scores - def refine(self, heatmap, x, y): + @staticmethod + def refine(heatmap, x, y): h, w = heatmap.shape[-2:] - valid = np.logical_and(np.logical_and(0 < x, x < w - 1), np.logical_and(0 < y, y < h - 1)) + valid = np.logical_and(np.logical_and(x > 0, x < w - 1), np.logical_and(y > 0, y < h - 1)) xx = x[valid] yy = y[valid] dx = np.sign(heatmap[yy, xx + 1] - heatmap[yy, xx - 1], dtype=np.float32) * 0.25 @@ -103,71 +104,77 @@ def refine(self, heatmap, x, y): y[valid] += dy return x, y - def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): - if part_id == 0: - pose_entries = [np.full(pose_entry_size, -1, dtype=np.float32) for _ in range(len(connections))] - for pose, connection in zip(pose_entries, connections): - pose[kpt_a_id] = connection[0] + @staticmethod + def is_disjoint(pose_a, pose_b): + pose_a = pose_a[:-2] + pose_b = pose_b[:-2] + return np.all(np.logical_or.reduce((pose_a == pose_b, pose_a < 0, pose_b < 0))) + + def update_poses(self, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): + for connection in connections: + pose_a_idx = -1 + pose_b_idx = -1 + for j, pose in enumerate(pose_entries): + if pose[kpt_a_id] == connection[0]: + pose_a_idx = j + if pose[kpt_b_id] == connection[1]: + pose_b_idx = j + if pose_a_idx < 0 and pose_b_idx < 0: + # Create new pose entry. + pose_entry = np.full(pose_entry_size, -1, dtype=np.float32) + pose_entry[kpt_a_id] = connection[0] + pose_entry[kpt_b_id] = connection[1] + pose_entry[-1] = 2 + pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] + pose_entries.append(pose_entry) + elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: + # Merge two poses are disjoint merge them, otherwise ignore connection. + pose_a = pose_entries[pose_a_idx] + pose_b = pose_entries[pose_b_idx] + if self.is_disjoint(pose_a, pose_b): + pose_a += pose_b + pose_a[:-2] += 1 + pose_a[-2] += connection[2] + del pose_entries[pose_b_idx] + elif pose_a_idx >= 0 and pose_b_idx >= 0: + # Adjust score of a pose. + pose_entries[pose_a_idx][-2] += connection[2] + elif pose_a_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_a_idx] + if pose[kpt_b_id] < 0: + pose[-2] += all_keypoints[connection[1], 2] pose[kpt_b_id] = connection[1] - pose[-1] = 2 - # pose score = sum of all points' scores + sum of all connections' scores - pose[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] - else: - for connection in connections: - pose_a_idx = -1 - pose_b_idx = -1 - for j, pose in enumerate(pose_entries): - if pose[kpt_a_id] == connection[0]: - pose_a_idx = j - if pose[kpt_b_id] == connection[1]: - pose_b_idx = j - if pose_a_idx < 0 and pose_b_idx < 0: - # Create new pose entry. - pose_entry = np.full(pose_entry_size, -1) - pose_entry[kpt_a_id] = connection[0] - pose_entry[kpt_b_id] = connection[1] - pose_entry[-1] = 2 - pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] - pose_entries.append(pose_entry) - elif pose_a_idx >= 0 and pose_b_idx >= 0: - if pose_a_idx != pose_b_idx: - # Merge two disjoint components into one pose. - pose_a = pose_entries[pose_a_idx] - pose_b = pose_entries[pose_b_idx] - do_merge_poses = True - for j in range(len(pose_b) - 2): - if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: - do_merge_poses = False - break - if not do_merge_poses: - continue - for j in range(len(pose_b) - 2): - if pose_b[j] >= 0: - pose_a[j] = pose_b[j] - pose_a[-1] += pose_b[-1] - pose_a[-2] += pose_b[-2] + connection[2] - del pose_entries[pose_b_idx] - else: - # Adjust score of a pose. - pose_entries[pose_a_idx][-2] += connection[2] - elif pose_a_idx >= 0: - # Add a new limb into pose. - pose = pose_entries[pose_a_idx] - if pose[kpt_b_id] < 0: - pose[-2] += all_keypoints[connection[1], 2] - pose[kpt_b_id] = connection[1] - pose[-2] += connection[2] - pose[-1] += 1 - elif pose_b_idx >= 0: - # Add a new limb into pose. - pose = pose_entries[pose_b_idx] - if pose[kpt_a_id] < 0: - pose[-2] += all_keypoints[connection[0], 2] - pose[kpt_a_id] = connection[0] - pose[-2] += connection[2] - pose[-1] += 1 + pose[-2] += connection[2] + pose[-1] += 1 + elif pose_b_idx >= 0: + # Add a new limb into pose. + pose = pose_entries[pose_b_idx] + if pose[kpt_a_id] < 0: + pose[-2] += all_keypoints[connection[0], 2] + pose[kpt_a_id] = connection[0] + pose[-2] += connection[2] + pose[-1] += 1 return pose_entries + @staticmethod + def connections_nms(a_idx, b_idx, affinity_scores): + # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. + order = affinity_scores.argsort()[::-1] + affinity_scores = affinity_scores[order] + a_idx = a_idx[order] + b_idx = b_idx[order] + idx = [] + has_kpt_a = set() + has_kpt_b = set() + for t, (i, j) in enumerate(zip(a_idx, b_idx)): + if i not in has_kpt_a and j not in has_kpt_b: + idx.append(t) + has_kpt_a.add(i) + has_kpt_b.add(j) + idx = np.asarray(idx, dtype=np.int32) + return a_idx[idx], b_idx[idx], affinity_scores[idx] + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] @@ -207,50 +214,40 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): # Get a list of limbs according to the obtained affinity score. valid_limbs = np.where(np.logical_and(affinity_scores > 0, success_ratio > 0.8))[0] - affinity_scores = affinity_scores[valid_limbs] - b_idx, a_idx = np.divmod(valid_limbs, n) - if len(affinity_scores) == 0: + if len(valid_limbs) == 0: continue + b_idx, a_idx = np.divmod(valid_limbs, n) + affinity_scores = affinity_scores[valid_limbs] - # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. - order = affinity_scores.argsort()[::-1] - affinity_scores = affinity_scores[order] - a_idx = a_idx[order] - b_idx = b_idx[order] - a_idx_unique = np.unique(a_idx, return_index=True)[1] - b_idx_unique = np.unique(b_idx, return_index=True)[1] - idx = np.intersect1d(a_idx_unique, b_idx_unique, assume_unique=True) - a = kpts_a[a_idx[idx], 3].astype(np.int32) - b = kpts_b[b_idx[idx], 3].astype(np.int32) - connections = list(zip(a, b, affinity_scores[idx])) - + # Suppress incompatible connections. + a_idx, b_idx, affinity_scores = self.connections_nms(a_idx, b_idx, affinity_scores) + connections = list(zip(kpts_a[a_idx, 3].astype(np.int32), + kpts_b[b_idx, 3].astype(np.int32), + affinity_scores)) if len(connections) == 0: continue # Update poses with new connections. - pose_entries = self.update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, + pose_entries = self.update_poses(kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size) # Remove poses with not enough points. - filtered_entries = [] - for i in range(len(pose_entries)): - if pose_entries[i][-1] < 3: - continue - filtered_entries.append(pose_entries[i]) - pose_entries = np.asarray(filtered_entries, dtype=np.float32) + pose_entries = np.asarray(pose_entries, dtype=np.float32).reshape(-1, pose_entry_size) + pose_entries = pose_entries[pose_entries[:, -1] >= 3] return pose_entries, all_keypoints - def convert_to_coco_format(self, pose_entries, all_keypoints): + @staticmethod + def convert_to_coco_format(pose_entries, all_keypoints): num_joints = 17 coco_keypoints = [] scores = [] - for n in range(len(pose_entries)): - if len(pose_entries[n]) == 0: + for pose in pose_entries: + if len(pose) == 0: continue keypoints = np.zeros(num_joints * 3) reorder_map = [0, -1, 6, 8, 10, 5, 7, 9, 12, 14, 16, 11, 13, 15, 2, 1, 4, 3] - person_score = pose_entries[n][-2] - for keypoint_id, target_id in zip(pose_entries[n][:-2], reorder_map): + person_score = pose[-2] + for keypoint_id, target_id in zip(pose[:-2], reorder_map): if target_id < 0: continue cx, cy, score = 0, 0, 0 # keypoint not found @@ -260,5 +257,5 @@ def convert_to_coco_format(self, pose_entries, all_keypoints): keypoints[target_id * 3 + 1] = cy keypoints[target_id * 3 + 2] = score coco_keypoints.append(keypoints) - scores.append(person_score * max(0, (pose_entries[n][-1] - 1))) # -1 for 'neck' + scores.append(person_score * max(0, (pose[-1] - 1))) # -1 for 'neck' return np.asarray(coco_keypoints), np.asarray(scores) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 21f833f7ef9..b694c82a14c 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -8,8 +8,7 @@ import numpy as np from openvino.inference_engine import IENetwork -from .decoder import AssociativeEmbeddingDecoder -from .openpose_decoder import OpenPoseDecoder +from .decoder import AssociativeEmbeddingDecoder, OpenPoseDecoder log = logging.getLogger() @@ -122,8 +121,6 @@ def __init__(self, *args, size_divisor=8, k = 2 * p + 1 pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(k, k), pads_begin=(p, p), pads_end=(p, p), strides=(1, 1)) nms_mask = ng.equal(heatmap, pooled_heatmap) - # TODO. Cast to type of the heatmap. - # nms_mask_float = ng.convert_like(nms_mask, heatmap) nms_mask_float = ng.convert(nms_mask, 'f32') nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') f = ng.impl.Function( @@ -204,7 +201,7 @@ def postprocess(self, outputs, meta): scores = poses[:, -1] poses = poses[:, :-1].reshape(-1, 18, 3) poses = poses[:, self.reorder_map, :] - poses[:, :, :2] /= upsample_ratio / 8 + poses[:, :, :2] /= upsample_ratio else: nms_heatmaps = outputs[self.nms_heatmaps_blob_name] poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py index 39b58486926..f7e031b0075 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py @@ -182,7 +182,8 @@ def _match_by_tag(self, inp): num_added = diff.shape[0] num_grouped = diff.shape[1] if num_added > num_grouped: - np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), constant_values=1e10) + diff_normed = np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), constant_values=1e10) + pairs = self._max_match(diff_normed) for row, col in pairs: if row < num_added and col < num_grouped and diff_saved[row][col] < self.tag_threshold: diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py index e5a0fe0775e..772fb0d2042 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py @@ -262,21 +262,12 @@ def refine(heatmap, x, y): return x, y @staticmethod - def merge_poses(pose_a, pose_b): - do_merge_poses = True - for j in range(len(pose_b) - 2): - if pose_a[j] >= 0 and pose_b[j] >= 0 and pose_a[j] != pose_b[j]: - do_merge_poses = False - break - if not do_merge_poses: - return False - for j in range(len(pose_b) - 2): - if pose_b[j] >= 0: - pose_a[j] = pose_b[j] - pose_a[-1] += pose_b[-1] - return True - - def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): + def is_disjoint(pose_a, pose_b): + pose_a = pose_a[:-2] + pose_b = pose_b[:-2] + return np.all(np.logical_or.reduce((pose_a == pose_b, pose_a < 0, pose_b < 0))) + + def update_poses(self, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size): for connection in connections: pose_a_idx = -1 pose_b_idx = -1 @@ -287,18 +278,20 @@ def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose_b_idx = j if pose_a_idx < 0 and pose_b_idx < 0: # Create new pose entry. - pose_entry = np.full(pose_entry_size, -1) + pose_entry = np.full(pose_entry_size, -1, dtype=np.float32) pose_entry[kpt_a_id] = connection[0] pose_entry[kpt_b_id] = connection[1] pose_entry[-1] = 2 pose_entry[-2] = np.sum(all_keypoints[connection[0:2], 2]) + connection[2] pose_entries.append(pose_entry) elif pose_a_idx >= 0 and pose_b_idx >= 0 and pose_a_idx != pose_b_idx: - # Merge two disjoint components into one pose. + # Merge two poses are disjoint merge them, otherwise ignore connection. pose_a = pose_entries[pose_a_idx] pose_b = pose_entries[pose_b_idx] - if self.merge_poses(pose_a, pose_b): - pose_a[-2] += pose_b[-2] + connection[2] + if self.is_disjoint(pose_a, pose_b): + pose_a += pose_b + pose_a[:-2] += 1 + pose_a[-2] += connection[2] del pose_entries[pose_b_idx] elif pose_a_idx >= 0 and pose_b_idx >= 0: # Adjust score of a pose. @@ -321,6 +314,24 @@ def update_poses(self, part_id, kpt_a_id, kpt_b_id, all_keypoints, connections, pose[-1] += 1 return pose_entries + @staticmethod + def connections_nms(a_idx, b_idx, affinity_scores): + # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. + order = affinity_scores.argsort()[::-1] + affinity_scores = affinity_scores[order] + a_idx = a_idx[order] + b_idx = b_idx[order] + idx = [] + has_kpt_a = set() + has_kpt_b = set() + for t, (i, j) in enumerate(zip(a_idx, b_idx)): + if i not in has_kpt_a and j not in has_kpt_b: + idx.append(t) + has_kpt_a.add(i) + has_kpt_b.add(j) + idx = np.asarray(idx, dtype=np.int32) + return a_idx[idx], b_idx[idx], affinity_scores[idx] + def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): all_keypoints = np.concatenate(all_keypoints_by_type, axis=0) pose_entries = [] @@ -360,28 +371,21 @@ def group_keypoints(self, all_keypoints_by_type, pafs, pose_entry_size=20): # Get a list of limbs according to the obtained affinity score. valid_limbs = np.where(np.logical_and(affinity_scores > 0, success_ratio > 0.8))[0] - affinity_scores = affinity_scores[valid_limbs] - b_idx, a_idx = np.divmod(valid_limbs, n) - if len(affinity_scores) == 0: + if len(valid_limbs) == 0: continue + b_idx, a_idx = np.divmod(valid_limbs, n) + affinity_scores = affinity_scores[valid_limbs] - # From all retrieved connections that share starting/ending keypoints leave only the top-scoring ones. - order = affinity_scores.argsort()[::-1] - affinity_scores = affinity_scores[order] - a_idx = a_idx[order] - b_idx = b_idx[order] - a_idx_unique = np.unique(a_idx, return_index=True)[1] - b_idx_unique = np.unique(b_idx, return_index=True)[1] - idx = np.intersect1d(a_idx_unique, b_idx_unique, assume_unique=True) - a = kpts_a[a_idx[idx], 3].astype(np.int32) - b = kpts_b[b_idx[idx], 3].astype(np.int32) - connections = list(zip(a, b, affinity_scores[idx])) - + # Suppress incompatible connections. + a_idx, b_idx, affinity_scores = self.connections_nms(a_idx, b_idx, affinity_scores) + connections = list(zip(kpts_a[a_idx, 3].astype(np.int32), + kpts_b[b_idx, 3].astype(np.int32), + affinity_scores)) if len(connections) == 0: continue # Update poses with new connections. - pose_entries = self.update_poses(part_id, kpt_a_id, kpt_b_id, all_keypoints, + pose_entries = self.update_poses(kpt_a_id, kpt_b_id, all_keypoints, connections, pose_entries, pose_entry_size) # Remove poses with not enough points. From cc24fe5e010e7f6d478d6a5df06fa01571561b19 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 14:01:09 +0300 Subject: [PATCH 38/58] fix GPU inference in demo --- .../human_pose_estimation_demo/model.py | 21 +++++++++++-------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index b694c82a14c..2939f4e3c93 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -103,10 +103,10 @@ class HPEOpenPose(Model): def __init__(self, *args, size_divisor=8, target_size=None, upsample_ratio=1, use_cpp_postprocessing=False, device='CPU', max_num_requests=1, **kwargs): - super().__init__(*args, **kwargs) + super().__init__(*args, device=device, max_num_requests=max_num_requests, **kwargs) self.use_cpp_postprocessing = use_cpp_postprocessing - self.nms_heatmaps_blob_name = None + self.pooled_heatmaps_blob_name = None function = ng.function_from_cnn(self.net) paf = function.get_output_op(0) paf = paf.inputs()[0].get_source_output().get_node() @@ -119,16 +119,14 @@ def __init__(self, *args, size_divisor=8, # Heuristic NMS kernel size adjustment depending on the feature maps upsampling ratio. p = int(np.round(6 / 7 * upsample_ratio)) k = 2 * p + 1 - pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(k, k), pads_begin=(p, p), pads_end=(p, p), strides=(1, 1)) - nms_mask = ng.equal(heatmap, pooled_heatmap) - nms_mask_float = ng.convert(nms_mask, 'f32') - nms_heatmap = ng.multiply(heatmap, nms_mask_float, name='nms_heatmaps') + pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(k, k), pads_begin=(p, p), pads_end=(p, p), + strides=(1, 1), name='pooled_heatmaps') f = ng.impl.Function( [ng.result(heatmap, name='heatmaps'), - ng.result(nms_heatmap, name='nms_heatmaps'), + ng.result(pooled_heatmap, name='pooled_heatmaps'), ng.result(paf, name='pafs')], function.get_parameters(), 'hpe') - self.nms_heatmaps_blob_name = 'nms_heatmaps' + self.pooled_heatmaps_blob_name = 'pooled_heatmaps' else: self.reorder_map = np.array([0, 15, 14, 17, 16, 5, 2, 6, 3, 7, 4, 11, 8, 12, 9, 13, 10]) # Just rename the outputs for more convenient postprocessing. @@ -188,6 +186,10 @@ def preprocess(self, inputs): inputs[self.image_blob_name] = img[None] return inputs, meta + @staticmethod + def heatmap_nms(heatmaps, pooled_heatmaps): + return heatmaps * (heatmaps == pooled_heatmaps) + def postprocess(self, outputs, meta): heatmaps = outputs[self.heatmaps_blob_name] pafs = outputs[self.pafs_blob_name] @@ -203,7 +205,8 @@ def postprocess(self, outputs, meta): poses = poses[:, self.reorder_map, :] poses[:, :, :2] /= upsample_ratio else: - nms_heatmaps = outputs[self.nms_heatmaps_blob_name] + pooled_heatmaps = outputs[self.pooled_heatmaps_blob_name] + nms_heatmaps = self.heatmap_nms(heatmaps, pooled_heatmaps) poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) # Rescale poses to the original image. From f56b5ed7a11283989b3542ec4007d2c9a4c162fe Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 18:14:52 +0300 Subject: [PATCH 39/58] improve performance of ae decoder --- .../human_pose_estimation_demo/decoder_ae.py | 14 ++++---------- .../pose_estimation_associative_embedding.py | 14 ++++---------- 2 files changed, 8 insertions(+), 20 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py index 05bbf4bcaf6..42e2318b262 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py @@ -152,23 +152,17 @@ def refine(heatmap, tag, keypoints, pose_tag=None): tags.append(tag[i, y, x]) prev_tag = np.mean(tags, axis=0) - # Allocate the buffer for tags similarity matrix. - tag_copy = np.empty_like(tag[0, ..., 0]) for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): if keypoints[i, 2] > 0: continue - tag_copy[...] = _tag[..., 0] - diff = tag_copy - diff -= prev_tag - np.abs(diff, out=diff) - np.floor(diff + 0.5, out=diff) + # Get position with the closest tag value to the pose tag. + diff = np.abs(_tag[..., 0] - prev_tag) + 0.5 + diff = diff.astype(np.int32).astype(_heatmap.dtype) diff -= _heatmap idx = diff.argmin() y, x = np.divmod(idx, _heatmap.shape[-1]) - - # detection score at maximum position + # Corresponding keypoint detection score. val = _heatmap[y, x] - if val > 0: keypoints[i, :3] = x, y, val if 1 < x < W - 1 and 1 < y < H - 1: diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py index f7e031b0075..7e1a2757f75 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py @@ -250,23 +250,17 @@ def refine(heatmap, tag, keypoints, pose_tag=None): tags.append(tag[i, y, x]) prev_tag = np.mean(tags, axis=0) - # Allocate the buffer for tags similarity matrix. - tag_copy = np.empty_like(tag[0, ..., 0]) for i, (_heatmap, _tag) in enumerate(zip(heatmap, tag)): if keypoints[i, 2] > 0: continue - tag_copy[...] = _tag[..., 0] - diff = tag_copy - diff -= prev_tag - np.abs(diff, out=diff) - np.floor(diff + 0.5, out=diff) + # Get position with the closest tag value to the pose tag. + diff = np.abs(_tag[..., 0] - prev_tag) + 0.5 + diff = diff.astype(np.int32).astype(_heatmap.dtype) diff -= _heatmap idx = diff.argmin() y, x = np.divmod(idx, _heatmap.shape[-1]) - - # detection score at maximum position + # Corresponding keypoint detection score. val = _heatmap[y, x] - if val > 0: keypoints[i, :3] = x, y, val if 1 < x < W - 1 and 1 < y < H - 1: From 15bae7bc86169441a86273e8923492c645ed77d1 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 18:20:44 +0300 Subject: [PATCH 40/58] add license headers --- .../human_pose_estimation_demo/decoder.py | 16 ++++++++++++++++ .../human_pose_estimation_demo/decoder_ae.py | 16 ++++++++++++++++ .../decoder_openpose.py | 16 ++++++++++++++++ .../human_pose_estimation_demo/model.py | 16 ++++++++++++++++ .../human_pose_estimation_demo/visualization.py | 16 ++++++++++++++++ 5 files changed, 80 insertions(+) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py index 3e696295028..256f83314fd 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder.py @@ -1,2 +1,18 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + from .decoder_ae import AssociativeEmbeddingDecoder from .decoder_openpose import OpenPoseDecoder diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py index 42e2318b262..9c1a2a3fc43 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py @@ -1,3 +1,19 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + import numpy as np from scipy.optimize import linear_sum_assignment diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py index 6897eacc1a1..d9658778cee 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py @@ -1,3 +1,19 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + import numpy as np diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 2939f4e3c93..a1dd3e0bc2c 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -1,3 +1,19 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + import logging import os.path as osp import threading diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py index a80df1f9320..e4d68389b9d 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/visualization.py @@ -1,3 +1,19 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + import cv2 import numpy as np From 3f92178ecda3513720a73e69b7a2f11df52059b8 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 18:31:47 +0300 Subject: [PATCH 41/58] add adapters description to readme --- .../accuracy_checker/accuracy_checker/adapters/README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/README.md b/tools/accuracy_checker/accuracy_checker/adapters/README.md index 0a74adaaf37..81f799ac33b 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/README.md +++ b/tools/accuracy_checker/accuracy_checker/adapters/README.md @@ -191,6 +191,14 @@ AccuracyChecker supports following set of adapters: * `part_affinity_fields_out` - name of output layer with keypoints pairwise relations (part affinity fields). * `keypoints_heatmap_out` - name of output layer with keypoints heatmaps. The output layers can be omitted if model has only one output layer - concatenation of this 2. +* `human_pose_estimation_openpose` - converting output of OpenPose-like model for human pose estimation to `PoseEstimationPrediction`. + * `part_affinity_fields_out` - name of output layer with keypoints pairwise relations (part affinity fields). + * `keypoints_heatmap_out` - name of output layer with keypoints heatmaps. + * `upscale_factor` - upscaling factor for heatmaps and part affinity fields before post-processing. +* `human_pose_estimation_ae` - converting output of Associative Embedding-like model for human pose estimation to `PoseEstimationPrediction`. + * `heatmaps_out` - name of output layer with keypoints heatmaps. + * `nms_heatmaps_out` - name of output layer with keypoints heatmaps after non-maximum suppression. + * `embeddings_out` - name of output layer with embedding (tag) maps. * `beam_search_decoder` - realization CTC Beam Search decoder for symbol sequence recognition, converting model output to `CharacterRecognitionPrediction`. * `beam_size` - size of the beam to use during decoding (default 10). * `blank_label` - index of the CTC blank label. From a37d6e9ab5b506313c7006c5183dde25f8b6be4f Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 18:34:20 +0300 Subject: [PATCH 42/58] handle scipy absence gently Co-authored-by: Ekaterina Aidova --- .../adapters/pose_estimation_associative_embedding.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py index 7e1a2757f75..a28a0a5e495 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py @@ -15,12 +15,16 @@ """ import numpy as np -from scipy.optimize import linear_sum_assignment from ..adapters import Adapter from ..config import ConfigValidator, StringField, ConfigError from ..representation import PoseEstimationPrediction -from ..utils import contains_all +from ..utils import contains_all, UnsupportedPackage + +try: + from scipy.optimize import linear_sum_assignment +except ImportError as error: + linear_sum_assignment = UnsupportedPackage('scipy.optimize', error.msg) class AssociativeEmbeddingAdapter(Adapter): From 991a13ab69631740c4af7eceafe96d6530be66c8 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 18:36:48 +0300 Subject: [PATCH 43/58] fix models doc pages Co-authored-by: Ekaterina Aidova --- .../description/human-pose-estimation-0002.md | 2 +- .../description/human-pose-estimation-0003.md | 2 +- .../description/human-pose-estimation-0004.md | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md index ec87d1488ab..b0c5627d883 100644 --- a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md +++ b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md @@ -17,7 +17,7 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr | Average Precision (AP) | 44.4% | | GFlops | 5.9393 | | MParams | 8.1504 | -| Source framework | PyTorch* | +| Source framework | PyTorch\* | Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). diff --git a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md index abf56584ab6..1b03d65305b 100644 --- a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md +++ b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md @@ -17,7 +17,7 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr | Average Precision (AP) | 50.2% | | GFlops | 8.8720 | | MParams | 8.1504 | -| Source framework | PyTorch* | +| Source framework | PyTorch\* | Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). diff --git a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md index 01c0543be05..4890ff8aa5d 100644 --- a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md +++ b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md @@ -17,7 +17,7 @@ The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wr | Average Precision (AP) | 52.9% | | GFlops | 14.3707 | | MParams | 8.1504 | -| Source framework | PyTorch* | +| Source framework | PyTorch\* | Average Precision metric described in [COCO Keypoint Evaluation site](https://cocodataset.org/#keypoints-eval). From 81bc936ae1db2fdd16c05cd91867f720aed8b68b Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 18:50:05 +0300 Subject: [PATCH 44/58] fix indent --- .../adapters/pose_estimation_associative_embedding.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py index a28a0a5e495..8db4402a692 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py @@ -24,7 +24,7 @@ try: from scipy.optimize import linear_sum_assignment except ImportError as error: - linear_sum_assignment = UnsupportedPackage('scipy.optimize', error.msg) + linear_sum_assignment = UnsupportedPackage('scipy.optimize', error.msg) class AssociativeEmbeddingAdapter(Adapter): From 2257addb5b2a97b66735aabe366f2eb960b94e6f Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 19:06:28 +0300 Subject: [PATCH 45/58] move AC configs --- .../accuracy-check.yml | 27 ++++++++++++++++++ .../accuracy-check.yml | 27 ++++++++++++++++++ .../accuracy-check.yml | 27 ++++++++++++++++++ .../configs/human-pose-estimation-0002.yml | 28 +------------------ .../configs/human-pose-estimation-0003.yml | 28 +------------------ .../configs/human-pose-estimation-0004.yml | 28 +------------------ 6 files changed, 84 insertions(+), 81 deletions(-) create mode 100644 models/intel/human-pose-estimation-0002/accuracy-check.yml create mode 100644 models/intel/human-pose-estimation-0003/accuracy-check.yml create mode 100644 models/intel/human-pose-estimation-0004/accuracy-check.yml diff --git a/models/intel/human-pose-estimation-0002/accuracy-check.yml b/models/intel/human-pose-estimation-0002/accuracy-check.yml new file mode 100644 index 00000000000..3cc19db2792 --- /dev/null +++ b/models/intel/human-pose-estimation-0002/accuracy-check.yml @@ -0,0 +1,27 @@ +models: + - name: human-pose-estimation-0002 + + launchers: + - framework: dlsdk + allow_reshape_input: True + adapter: + type: human_pose_estimation_ae + heatmaps_out: heatmaps + nms_heatmaps_out: nms_heatmaps + embeddings_out: embeddings + + datasets: + - name: ms_coco_val2017_keypoints + + preprocessing: + - type: resize + size: 288 + interpolation: LINEAR + aspect_ratio_scale: greater + - type: padding + stride: 32 + pad_type: right_bottom + + metrics: + - name: AP + type: coco_orig_keypoints_precision diff --git a/models/intel/human-pose-estimation-0003/accuracy-check.yml b/models/intel/human-pose-estimation-0003/accuracy-check.yml new file mode 100644 index 00000000000..64905e81d63 --- /dev/null +++ b/models/intel/human-pose-estimation-0003/accuracy-check.yml @@ -0,0 +1,27 @@ +models: + - name: human-pose-estimation-0003 + + launchers: + - framework: dlsdk + allow_reshape_input: True + adapter: + type: human_pose_estimation_ae + heatmaps_out: heatmaps + nms_heatmaps_out: nms_heatmaps + embeddings_out: embeddings + + datasets: + - name: ms_coco_val2017_keypoints + + preprocessing: + - type: resize + size: 352 + interpolation: LINEAR + aspect_ratio_scale: greater + - type: padding + stride: 32 + pad_type: right_bottom + + metrics: + - name: AP + type: coco_orig_keypoints_precision diff --git a/models/intel/human-pose-estimation-0004/accuracy-check.yml b/models/intel/human-pose-estimation-0004/accuracy-check.yml new file mode 100644 index 00000000000..a8869c6903a --- /dev/null +++ b/models/intel/human-pose-estimation-0004/accuracy-check.yml @@ -0,0 +1,27 @@ +models: + - name: human-pose-estimation-0004 + + launchers: + - framework: dlsdk + allow_reshape_input: True + adapter: + type: human_pose_estimation_ae + heatmaps_out: heatmaps + nms_heatmaps_out: nms_heatmaps + embeddings_out: embeddings + + datasets: + - name: ms_coco_val2017_keypoints + + preprocessing: + - type: resize + size: 448 + interpolation: LINEAR + aspect_ratio_scale: greater + - type: padding + stride: 32 + pad_type: right_bottom + + metrics: + - name: AP + type: coco_orig_keypoints_precision diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml index 3cc19db2792..b1e5c63e0a3 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml @@ -1,27 +1 @@ -models: - - name: human-pose-estimation-0002 - - launchers: - - framework: dlsdk - allow_reshape_input: True - adapter: - type: human_pose_estimation_ae - heatmaps_out: heatmaps - nms_heatmaps_out: nms_heatmaps - embeddings_out: embeddings - - datasets: - - name: ms_coco_val2017_keypoints - - preprocessing: - - type: resize - size: 288 - interpolation: LINEAR - aspect_ratio_scale: greater - - type: padding - stride: 32 - pad_type: right_bottom - - metrics: - - name: AP - type: coco_orig_keypoints_precision +../../../models/intel/human-pose-estimation-0002/accuracy-check.yml \ No newline at end of file diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml index 64905e81d63..0b2774baea3 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml @@ -1,27 +1 @@ -models: - - name: human-pose-estimation-0003 - - launchers: - - framework: dlsdk - allow_reshape_input: True - adapter: - type: human_pose_estimation_ae - heatmaps_out: heatmaps - nms_heatmaps_out: nms_heatmaps - embeddings_out: embeddings - - datasets: - - name: ms_coco_val2017_keypoints - - preprocessing: - - type: resize - size: 352 - interpolation: LINEAR - aspect_ratio_scale: greater - - type: padding - stride: 32 - pad_type: right_bottom - - metrics: - - name: AP - type: coco_orig_keypoints_precision +../../../models/intel/human-pose-estimation-0003/accuracy-check.yml \ No newline at end of file diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml index a8869c6903a..c8f2d4b7f6b 100644 --- a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml +++ b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml @@ -1,27 +1 @@ -models: - - name: human-pose-estimation-0004 - - launchers: - - framework: dlsdk - allow_reshape_input: True - adapter: - type: human_pose_estimation_ae - heatmaps_out: heatmaps - nms_heatmaps_out: nms_heatmaps - embeddings_out: embeddings - - datasets: - - name: ms_coco_val2017_keypoints - - preprocessing: - - type: resize - size: 448 - interpolation: LINEAR - aspect_ratio_scale: greater - - type: padding - stride: 32 - pad_type: right_bottom - - metrics: - - name: AP - type: coco_orig_keypoints_precision +../../../models/intel/human-pose-estimation-0004/accuracy-check.yml \ No newline at end of file From 679b8a46dad9987117850f3d657610c95ecadc34 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Wed, 18 Nov 2020 22:18:35 +0300 Subject: [PATCH 46/58] remove pseudo links --- tools/accuracy_checker/configs/human-pose-estimation-0002.yml | 1 - tools/accuracy_checker/configs/human-pose-estimation-0003.yml | 1 - tools/accuracy_checker/configs/human-pose-estimation-0004.yml | 1 - 3 files changed, 3 deletions(-) delete mode 100644 tools/accuracy_checker/configs/human-pose-estimation-0002.yml delete mode 100644 tools/accuracy_checker/configs/human-pose-estimation-0003.yml delete mode 100644 tools/accuracy_checker/configs/human-pose-estimation-0004.yml diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml deleted file mode 100644 index b1e5c63e0a3..00000000000 --- a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml +++ /dev/null @@ -1 +0,0 @@ -../../../models/intel/human-pose-estimation-0002/accuracy-check.yml \ No newline at end of file diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml deleted file mode 100644 index 0b2774baea3..00000000000 --- a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml +++ /dev/null @@ -1 +0,0 @@ -../../../models/intel/human-pose-estimation-0003/accuracy-check.yml \ No newline at end of file diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml deleted file mode 100644 index c8f2d4b7f6b..00000000000 --- a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml +++ /dev/null @@ -1 +0,0 @@ -../../../models/intel/human-pose-estimation-0004/accuracy-check.yml \ No newline at end of file From 4946f64e57a584d72b6c83faf2cd59f31914a66c Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 19 Nov 2020 16:51:58 +0300 Subject: [PATCH 47/58] fix typo Co-authored-by: Vladimir Dudnik --- demos/python_demos/human_pose_estimation_demo/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md index 98d2df5e387..01e0b35faa1 100644 --- a/demos/python_demos/human_pose_estimation_demo/README.md +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -80,7 +80,7 @@ Options: ``` Running the application with the empty list of options yields the short usage message and an error message. -You can use the following command to do inference on GPU with a pre-trained human pose estimation model: +You can use the following command to do inference on CPU with a pre-trained human pose estimation model: ``` python3 human_pose_estimation.py -i /inputVideo.mp4 -m /hpe.xml -d CPU ``` From cb1af2ebd7c30bd62cf397992cda78372762fda9 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Thu, 19 Nov 2020 17:02:00 +0300 Subject: [PATCH 48/58] update arguments description --- .../human_pose_estimation_demo/human_pose_estimation.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index f4a34ab4b6e..79115540ba5 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -46,6 +46,9 @@ def build_argparser(): required=True, type=str) args.add_argument('-i', '--input', help='Required. Path to an image, video file or a numeric camera ID.', required=True, type=str) + args.add_argument('--type', choices=('ae', 'openpose'), required=True, type=str, + help='Required. Type of the network, either "ae" for associative embedding ' + 'or "openpose" for openpose.') args.add_argument('-d', '--device', help='Optional. Specify the target device to infer on; CPU, GPU, FPGA, HDDL or MYRIAD is ' 'acceptable. The sample will look for a suitable plugin for device specified. ' @@ -69,11 +72,8 @@ def build_argparser(): args.add_argument('-u', '--utilization_monitors', default='', type=str, help='Optional. List of monitors to show initially.') - args.add_argument('--type', default='ae', choices=('ae', 'openpose'), type=str, - help='Optional. Type of the network, either "ae" for associative embedding' - 'or "openpose" for openpose.') args.add_argument('--tsize', default=None, type=int, - help='Optional. Target input size. By default target size is derived from image input shape' + help='Optional. Target input size. By default target size is derived from an input shape ' 'of a provided network and depends on the network type.') return parser From 86544c2623a04fe300dbbed68cd9862340cc8636 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 20 Nov 2020 16:38:38 +0300 Subject: [PATCH 49/58] move image resize to base Model class --- .../human_pose_estimation_demo/model.py | 130 +++++++----------- 1 file changed, 53 insertions(+), 77 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index a1dd3e0bc2c..0445c9481bb 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -32,6 +32,7 @@ class Model: def __init__(self, ie, xml_file_path, bin_file_path=None, + size_divisor=8, target_size=None, device='CPU', plugin_config={}, max_num_requests=1, results=None, caught_exceptions=None): self.ie = ie @@ -44,9 +45,12 @@ def __init__(self, ie, xml_file_path, bin_file_path=None, self.max_num_requests = max_num_requests self.device = device self.plugin_config = plugin_config - self.input_shapes = {} self.exec_net = ie.load_network(network=self.net, device_name=device, config=plugin_config, num_requests=max_num_requests) + self.image_blob_name = '' + self.size_divisor = size_divisor + self.target_size = target_size + self.requests = self.exec_net.requests self.empty_requests = deque(self.requests) self.completed_request_results = results if results is not None else [] @@ -62,7 +66,7 @@ def reshape_net(self, inputs): reshape_needed = True break if reshape_needed: - print('reshape net to ', input_shapes) + log.info('reshape net to {}'.format(input_shapes)) self.await_all() self.net.reshape(input_shapes) self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) @@ -76,8 +80,37 @@ def unify_inputs(self, inputs): inputs_dict = inputs return inputs_dict + @staticmethod + def _get_inputs(net): + image_blob_name = None + for blob_name, blob in net.input_info.items(): + if len(blob.input_data.shape) == 4: + image_blob_name = blob_name + else: + raise RuntimeError('Unsupported {}D input layer "{}". Only 2D and 4D input layers are supported' + .format(len(blob.shape), blob_name)) + if image_blob_name is None: + raise RuntimeError('Failed to identify the input for the image.') + return image_blob_name + + @staticmethod + def _resize_image(frame, size): + return cv2.resize(frame, (size, size)) + def preprocess(self, inputs): - meta = {} + img = self._resize_image(inputs[self.image_blob_name], self.target_size) + meta = {'original_shape': inputs[self.image_blob_name].shape, + 'resized_shape': img.shape} + h, w = img.shape[:2] + divisor = self.size_divisor + if w % divisor != 0 or h % divisor != 0: + img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor - h), + (0, (w + divisor - 1) // divisor * divisor - w), + (0, 0)), + mode='constant', constant_values=0) + # Change data layout from HWC to CHW + img = img.transpose((2, 0, 1)) + inputs[self.image_blob_name] = img[None] return inputs, meta def postprocess(self, outputs, meta): @@ -116,10 +149,8 @@ def await_any(self): class HPEOpenPose(Model): - def __init__(self, *args, size_divisor=8, - target_size=None, upsample_ratio=1, use_cpp_postprocessing=False, - device='CPU', max_num_requests=1, **kwargs): - super().__init__(*args, device=device, max_num_requests=max_num_requests, **kwargs) + def __init__(self, *args, upsample_ratio=1, use_cpp_postprocessing=False, **kwargs): + super().__init__(*args, **kwargs) self.use_cpp_postprocessing = use_cpp_postprocessing self.pooled_heatmaps_blob_name = None @@ -160,52 +191,24 @@ def __init__(self, *args, size_divisor=8, self.heatmaps_blob_name = 'heatmaps' self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - 1 # The last channel is for background. - self.size_divisor = size_divisor - self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-2] - self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-2] - if target_size is not None: + target_size = self.net.input_info[self.image_blob_name].input_data.shape[-2] + self.output_scale = target_size / self.net.outputs[self.heatmaps_blob_name].shape[-2] + if self.target_size is None: self.target_size = target_size self.decoder = OpenPoseDecoder(num_joints=self.num_joints) - def _get_inputs(self, net): - image_blob_name = None - for blob_name, blob in net.input_info.items(): - if len(blob.input_data.shape) == 4: - image_blob_name = blob_name - else: - raise RuntimeError('Unsupported {}D input layer "{}". Only 2D and 4D input layers are supported' - .format(len(blob.shape), blob_name)) - if image_blob_name is None: - raise RuntimeError('Failed to identify the input for the image.') - return image_blob_name + @staticmethod + def heatmap_nms(heatmaps, pooled_heatmaps): + return heatmaps * (heatmaps == pooled_heatmaps) @staticmethod def _resize_image(frame, size): - h, w = frame.shape[:2] - scale = max(size[1] / h, size[0] / w) + h = frame.shape[0] + scale = size / h resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) return resized_frame - def preprocess(self, inputs): - img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size)) - meta = {'original_shape': inputs[self.image_blob_name].shape, - 'resized_shape': img.shape} - h, w = img.shape[:2] - divisor = self.size_divisor - if w % divisor != 0 or h % divisor != 0: - img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor - h), - (0, (w + divisor - 1) // divisor * divisor - w), - (0, 0))) - # Change data layout from HWC to CHW - img = img.transpose((2, 0, 1)) - inputs[self.image_blob_name] = img[None] - return inputs, meta - - @staticmethod - def heatmap_nms(heatmaps, pooled_heatmaps): - return heatmaps * (heatmaps == pooled_heatmaps) - def postprocess(self, outputs, meta): heatmaps = outputs[self.heatmaps_blob_name] pafs = outputs[self.pafs_blob_name] @@ -237,19 +240,19 @@ def postprocess(self, outputs, meta): class HPEAssociativeEmbedding(Model): - def __init__(self, *args, target_size=None, size_divisor=32, **kwargs): - super().__init__(*args, **kwargs) + def __init__(self, *args, size_divisor=32, **kwargs): + super().__init__(*args, size_divisor=size_divisor, **kwargs) self.image_blob_name = self._get_inputs(self.net) self.heatmaps_blob_name = find_layer_by_name('heatmaps', self.net.outputs) self.nms_heatmaps_blob_name = find_layer_by_name('nms_heatmaps', self.net.outputs) self.embeddings_blob_name = find_layer_by_name('embeddings', self.net.outputs) - self.size_divisor = size_divisor self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - self.target_size = self.net.input_info[self.image_blob_name].input_data.shape[-1] - self.output_scale = self.target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] - if target_size is not None: + h, w = self.net.input_info[self.image_blob_name].input_data.shape[-2:] + target_size = min(h, w) + self.output_scale = target_size / self.net.outputs[self.heatmaps_blob_name].shape[-1] + if self.target_size is None: self.target_size = target_size self.decoder = AssociativeEmbeddingDecoder( @@ -263,40 +266,13 @@ def __init__(self, *args, target_size=None, size_divisor=32, **kwargs): use_detection_val=True, ignore_too_much=False) - def _get_inputs(self, net): - image_blob_name = None - for blob_name, blob in net.input_info.items(): - if len(blob.input_data.shape) == 4: - image_blob_name = blob_name - else: - raise RuntimeError('Unsupported {}D input layer "{}". Only 2D and 4D input layers are supported' - .format(len(blob.shape), blob_name)) - if image_blob_name is None: - raise RuntimeError('Failed to identify the input for the image.') - return image_blob_name - @staticmethod def _resize_image(frame, size): h, w = frame.shape[:2] - scale = max(size[1] / h, size[0] / w) + scale = max(size / h, size / w) resized_frame = cv2.resize(frame, None, fx=scale, fy=scale) return resized_frame - def preprocess(self, inputs): - img = self._resize_image(inputs[self.image_blob_name], (self.target_size, self.target_size)) - meta = {'original_shape': inputs[self.image_blob_name].shape, - 'resized_shape': img.shape} - h, w = img.shape[:2] - divisor = self.size_divisor - if w % divisor != 0 or h % divisor != 0: - img = np.pad(img, ((0, (h + divisor - 1) // divisor * divisor - h), - (0, (w + divisor - 1) // divisor * divisor - w), - (0, 0))) - # Change data layout from HWC to CHW - img = img.transpose((2, 0, 1)) - inputs[self.image_blob_name] = img[None] - return inputs, meta - def postprocess(self, outputs, meta): heatmaps = outputs[self.heatmaps_blob_name] nms_heatmaps = outputs[self.nms_heatmaps_blob_name] From 0972357e0d3bcf2581032095d93a306d10834707 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 20 Nov 2020 16:40:11 +0300 Subject: [PATCH 50/58] extend documentation of --tsize arg --- .../human_pose_estimation.py | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index 79115540ba5..213df725674 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -42,21 +42,29 @@ def build_argparser(): parser = ArgumentParser(add_help=False) args = parser.add_argument_group('Options') args.add_argument('-h', '--help', action='help', default=SUPPRESS, help='Show this help message and exit.') - args.add_argument('-m', '--model', help='Required. Path to an .xml file with a trained model.', - required=True, type=str) args.add_argument('-i', '--input', help='Required. Path to an image, video file or a numeric camera ID.', required=True, type=str) + args.add_argument('-m', '--model', help='Required. Path to an .xml file with a trained model.', + required=True, type=str) args.add_argument('--type', choices=('ae', 'openpose'), required=True, type=str, - help='Required. Type of the network, either "ae" for associative embedding ' - 'or "openpose" for openpose.') - args.add_argument('-d', '--device', - help='Optional. Specify the target device to infer on; CPU, GPU, FPGA, HDDL or MYRIAD is ' - 'acceptable. The sample will look for a suitable plugin for device specified. ' - 'Default value is CPU.', default='CPU', type=str) + help='Required. Type of the network, either "ae" for Associative Embedding ' + 'or "openpose" for OpenPose.') + args.add_argument('--tsize', default=None, type=int, + help='Optional. Target input size. This demo implements image pre-processing pipeline ' + 'that is common to human pose estimation approaches. Image is resize first to some ' + 'target size and then the network is reshaped to fit the input image shape. ' + 'By default target image size is determined based on the input shape from IR. ' + 'Alternatively it can be manually set via this parameter. Note that for OpenPose-like ' + 'nets image is resized to a predefined height, which is the target size in this case. ' + 'For Associative Embedding-like nets target size is the length of a short image side.') args.add_argument('-t', '--prob_threshold', help='Optional. Probability threshold for poses filtering.', default=0.1, type=float) args.add_argument('-r', '--raw_output_message', help='Optional. Output inference results raw values showing.', default=False, action='store_true') + args.add_argument('-d', '--device', + help='Optional. Specify the target device to infer on; CPU, GPU, FPGA, HDDL or MYRIAD is ' + 'acceptable. The sample will look for a suitable plugin for device specified. ' + 'Default value is CPU.', default='CPU', type=str) args.add_argument('-nireq', '--num_infer_requests', help='Optional. Number of infer requests', default=1, type=int) args.add_argument('-nstreams', '--num_streams', @@ -71,10 +79,6 @@ def build_argparser(): args.add_argument('-no_show', '--no_show', help="Optional. Don't show output", action='store_true') args.add_argument('-u', '--utilization_monitors', default='', type=str, help='Optional. List of monitors to show initially.') - - args.add_argument('--tsize', default=None, type=int, - help='Optional. Target input size. By default target size is derived from an input shape ' - 'of a provided network and depends on the network type.') return parser From 187d39b1f90f759d5bac4c6c94f5be0a11bf8f6a Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 20 Nov 2020 16:43:11 +0300 Subject: [PATCH 51/58] support old numpy versions --- .../human_pose_estimation_demo/decoder_ae.py | 3 ++- .../human_pose_estimation_demo/decoder_openpose.py | 13 +++++++++---- .../pose_estimation_associative_embedding.py | 3 ++- .../adapters/pose_estimation_openpose.py | 13 +++++++++---- 4 files changed, 22 insertions(+), 10 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py index 9c1a2a3fc43..9a3737f4601 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_ae.py @@ -100,7 +100,8 @@ def _match_by_tag(self, inp): num_added = diff.shape[0] num_grouped = diff.shape[1] if num_added > num_grouped: - diff_normed = np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), constant_values=1e10) + diff_normed = np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), + mode='constant', constant_values=1e10) pairs = self._max_match(diff_normed) for row, col in pairs: diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py index d9658778cee..66fd9ca6e67 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/decoder_openpose.py @@ -16,6 +16,11 @@ import numpy as np +try: + from numpy.core.umath import clip +except ImportError: + from numpy import clip + class OpenPoseDecoder: @@ -46,8 +51,8 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): if self.delta > 0: for kpts in keypoints: kpts[:, :2] += self.delta - np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) - np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) + clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) + clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) poses, scores = self.convert_to_coco_format(pose_entries, keypoints) @@ -81,8 +86,8 @@ def extract_points(self, heatmaps, nms_heatmaps): continue # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) - np.core.umath.clip(x, 0, w - 1, out=x) - np.core.umath.clip(y, 0, h - 1, out=y) + clip(x, 0, w - 1, out=x) + clip(y, 0, h - 1, out=y) # Pack resulting points. keypoints = np.empty((n, 4), dtype=np.float32) keypoints[:, 0] = x diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py index 8db4402a692..781e0423f6f 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_associative_embedding.py @@ -186,7 +186,8 @@ def _match_by_tag(self, inp): num_added = diff.shape[0] num_grouped = diff.shape[1] if num_added > num_grouped: - diff_normed = np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), constant_values=1e10) + diff_normed = np.pad(diff_normed, ((0, 0), (0, num_added - num_grouped)), + mode='constant', constant_values=1e10) pairs = self._max_match(diff_normed) for row, col in pairs: diff --git a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py index 772fb0d2042..c70f859a3db 100644 --- a/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py +++ b/tools/accuracy_checker/accuracy_checker/adapters/pose_estimation_openpose.py @@ -18,6 +18,11 @@ import numpy as np from skimage.measure import block_reduce +try: + from numpy.core.umath import clip +except ImportError: + from numpy import clip + from ..adapters import Adapter from ..config import ConfigValidator, StringField, ConfigError, NumberField from ..representation import PoseEstimationPrediction @@ -187,8 +192,8 @@ def __call__(self, heatmaps, nms_heatmaps, pafs): if self.delta > 0: for kpts in keypoints: kpts[:, :2] += self.delta - np.core.umath.clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) - np.core.umath.clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) + clip(kpts[:, 0], 0, w - 1, out=kpts[:, 0]) + clip(kpts[:, 1], 0, h - 1, out=kpts[:, 1]) pose_entries, keypoints = self.group_keypoints(keypoints, pafs, pose_entry_size=self.num_joints + 2) poses, scores = self.convert_to_coco_format(pose_entries, keypoints) @@ -222,8 +227,8 @@ def extract_points(self, heatmaps, nms_heatmaps): continue # Apply quarter offset to improve localization accuracy. x, y = self.refine(heatmaps[0, k], x, y) - np.core.umath.clip(x, 0, w - 1, out=x) - np.core.umath.clip(y, 0, h - 1, out=y) + clip(x, 0, w - 1, out=x) + clip(y, 0, h - 1, out=y) # Pack resulting points. keypoints = np.empty((n, 4), dtype=np.float32) keypoints[:, 0] = x From 230b52e924aafd882fe5a90e84305f0bbce536c7 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 20 Nov 2020 16:46:22 +0300 Subject: [PATCH 52/58] fix docs --- .../human_pose_estimation_demo/README.md | 37 +++++++++++-------- .../description/human-pose-estimation-0002.md | 2 +- .../description/human-pose-estimation-0003.md | 2 +- .../description/human-pose-estimation-0004.md | 2 +- 4 files changed, 25 insertions(+), 18 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md index 01e0b35faa1..095c6b8786a 100644 --- a/demos/python_demos/human_pose_estimation_demo/README.md +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -32,30 +32,42 @@ python3 human_pose_estimation.py -h ``` The command yields the following usage message: ``` -usage: human_pose_estimation.py [-h] -m MODEL -i INPUT [-d DEVICE] - [-t PROB_THRESHOLD] [-r] - [-nireq NUM_INFER_REQUESTS] +usage: human_pose_estimation.py [-h] -i INPUT -m MODEL --type {ae,openpose} + [--tsize TSIZE] [-t PROB_THRESHOLD] [-r] + [-d DEVICE] [-nireq NUM_INFER_REQUESTS] [-nstreams NUM_STREAMS] [-nthreads NUM_THREADS] [-loop LOOP] [-no_show] [-u UTILIZATION_MONITORS] - [--type {ae,openpose}] [--tsize TSIZE] Options: -h, --help Show this help message and exit. - -m MODEL, --model MODEL - Required. Path to an .xml file with a trained model. -i INPUT, --input INPUT Required. Path to an image, video file or a numeric camera ID. + -m MODEL, --model MODEL + Required. Path to an .xml file with a trained model. + --type {ae,openpose} Required. Type of the network, either "ae" for + Associative Embedding or "openpose" for OpenPose. + --tsize TSIZE Optional. Target input size. This demo implements + image pre-processing pipeline that is common to human + pose estimation approaches. Image is resize first to + some target size and then the network is reshaped to + fit the input image shape. By default target image + size is determined based on the input shape from IR. + Alternatively it can be manually set via this + parameter. Note that for OpenPose-like nets image is + resized to a predefined height, which is the target + size in this case. For Associative Embedding-like nets + target size is the length of a short image side. + -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD + Optional. Probability threshold for poses filtering. + -r, --raw_output_message + Optional. Output inference results raw values showing. -d DEVICE, --device DEVICE Optional. Specify the target device to infer on; CPU, GPU, FPGA, HDDL or MYRIAD is acceptable. The sample will look for a suitable plugin for device specified. Default value is CPU. - -t PROB_THRESHOLD, --prob_threshold PROB_THRESHOLD - Optional. Probability threshold for poses filtering. - -r, --raw_output_message - Optional. Output inference results raw values showing. -nireq NUM_INFER_REQUESTS, --num_infer_requests NUM_INFER_REQUESTS Optional. Number of infer requests -nstreams NUM_STREAMS, --num_streams NUM_STREAMS @@ -72,11 +84,6 @@ Options: -no_show, --no_show Optional. Don't show output -u UTILIZATION_MONITORS, --utilization_monitors UTILIZATION_MONITORS Optional. List of monitors to show initially. - --type {ae,openpose} Optional. Type of the network, either "ae" for - associative embeddingor "openpose" for openpose. - --tsize TSIZE Optional. Target input size. By default target size is - derived from image input shapeof a provided network - and depends on the network type. ``` Running the application with the empty list of options yields the short usage message and an error message. diff --git a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md index b0c5627d883..dbb1b971a73 100644 --- a/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md +++ b/models/intel/human-pose-estimation-0002/description/human-pose-estimation-0002.md @@ -2,7 +2,7 @@ ## Use Case and High-Level Description -This is a multi-person 2D pose estimation network based on the EfficientHRNet approach. +This is a multi-person 2D pose estimation network based on the EfficientHRNet approach (that follows the Associative Embedding framework). For every person in an image, the network detects a human pose: a body skeleton consisting of keypoints and connections between them. The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wrists, hips, knees, and ankles. diff --git a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md index 1b03d65305b..7b074bcd1d0 100644 --- a/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md +++ b/models/intel/human-pose-estimation-0003/description/human-pose-estimation-0003.md @@ -2,7 +2,7 @@ ## Use Case and High-Level Description -This is a multi-person 2D pose estimation network based on the EfficientHRNet approach. +This is a multi-person 2D pose estimation network based on the EfficientHRNet approach (that follows the Associative Embedding framework). For every person in an image, the network detects a human pose: a body skeleton consisting of keypoints and connections between them. The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wrists, hips, knees, and ankles. diff --git a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md index 4890ff8aa5d..ae47c2c840d 100644 --- a/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md +++ b/models/intel/human-pose-estimation-0004/description/human-pose-estimation-0004.md @@ -2,7 +2,7 @@ ## Use Case and High-Level Description -This is a multi-person 2D pose estimation network based on the EfficientHRNet approach. +This is a multi-person 2D pose estimation network based on the EfficientHRNet approach (that follows the Associative Embedding framework). For every person in an image, the network detects a human pose: a body skeleton consisting of keypoints and connections between them. The pose may contain up to 17 keypoints: ears, eyes, nose, shoulders, elbows, wrists, hips, knees, and ankles. From 2116b47abd2c912c3655b7d798f1350656c88914 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Fri, 20 Nov 2020 16:52:04 +0300 Subject: [PATCH 53/58] removed cpp postprocessing --- .../human_pose_estimation_demo/model.py | 67 +++++++------------ 1 file changed, 23 insertions(+), 44 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py index 0445c9481bb..59c6273a1bb 100644 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation_demo/model.py @@ -149,47 +149,39 @@ def await_any(self): class HPEOpenPose(Model): - def __init__(self, *args, upsample_ratio=1, use_cpp_postprocessing=False, **kwargs): + def __init__(self, *args, upsample_ratio=1, **kwargs): super().__init__(*args, **kwargs) - self.use_cpp_postprocessing = use_cpp_postprocessing - self.pooled_heatmaps_blob_name = None + self.pooled_heatmaps_blob_name = 'pooled_heatmaps' + self.heatmaps_blob_name = 'heatmaps' + self.pafs_blob_name = 'pafs' + function = ng.function_from_cnn(self.net) paf = function.get_output_op(0) paf = paf.inputs()[0].get_source_output().get_node() - paf.set_friendly_name('pafs') + paf.set_friendly_name(self.pafs_blob_name) heatmap = function.get_output_op(1) heatmap = heatmap.inputs()[0].get_source_output().get_node() - heatmap.set_friendly_name('heatmaps') - if not self.use_cpp_postprocessing: - # Add keypoints NMS to the network. - # Heuristic NMS kernel size adjustment depending on the feature maps upsampling ratio. - p = int(np.round(6 / 7 * upsample_ratio)) - k = 2 * p + 1 - pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(k, k), pads_begin=(p, p), pads_end=(p, p), - strides=(1, 1), name='pooled_heatmaps') - f = ng.impl.Function( - [ng.result(heatmap, name='heatmaps'), - ng.result(pooled_heatmap, name='pooled_heatmaps'), - ng.result(paf, name='pafs')], - function.get_parameters(), 'hpe') - self.pooled_heatmaps_blob_name = 'pooled_heatmaps' - else: - self.reorder_map = np.array([0, 15, 14, 17, 16, 5, 2, 6, 3, 7, 4, 11, 8, 12, 9, 13, 10]) - # Just rename the outputs for more convenient postprocessing. - f = ng.impl.Function( - [ng.result(heatmap, name='heatmaps'), ng.result(paf, name='pafs')], - function.get_parameters(), 'hpe') + heatmap.set_friendly_name(self.heatmaps_blob_name) + + # Add keypoints NMS to the network. + # Heuristic NMS kernel size adjustment depending on the feature maps upsampling ratio. + p = int(np.round(6 / 7 * upsample_ratio)) + k = 2 * p + 1 + pooled_heatmap = ng.max_pool(heatmap, kernel_shape=(k, k), pads_begin=(p, p), pads_end=(p, p), + strides=(1, 1), name=self.pooled_heatmaps_blob_name) + f = ng.impl.Function( + [ng.result(heatmap, name=self.heatmaps_blob_name), + ng.result(pooled_heatmap, name=self.pooled_heatmaps_blob_name), + ng.result(paf, name=self.pafs_blob_name)], + function.get_parameters(), 'hpe') + self.image_blob_name = self._get_inputs(self.net) self.net = IENetwork(ng.impl.Function.to_capsule(f)) self.exec_net = self.ie.load_network(network=self.net, device_name=self.device, num_requests=self.max_num_requests) self.requests = self.exec_net.requests self.empty_requests = deque(self.requests) - self.image_blob_name = self._get_inputs(self.net) - self.pafs_blob_name = 'pafs' - self.heatmaps_blob_name = 'heatmaps' - self.num_joints = self.net.outputs[self.heatmaps_blob_name].shape[1] - 1 # The last channel is for background. target_size = self.net.input_info[self.image_blob_name].input_data.shape[-2] self.output_scale = target_size / self.net.outputs[self.heatmaps_blob_name].shape[-2] @@ -212,22 +204,9 @@ def _resize_image(frame, size): def postprocess(self, outputs, meta): heatmaps = outputs[self.heatmaps_blob_name] pafs = outputs[self.pafs_blob_name] - - if self.use_cpp_postprocessing: - from pose_extractor import extract_poses - - upsample_ratio = 4 - poses = extract_poses(heatmaps[0], pafs[0], upsample_ratio) - # scale coordinates to features space - scores = poses[:, -1] - poses = poses[:, :-1].reshape(-1, 18, 3) - poses = poses[:, self.reorder_map, :] - poses[:, :, :2] /= upsample_ratio - else: - pooled_heatmaps = outputs[self.pooled_heatmaps_blob_name] - nms_heatmaps = self.heatmap_nms(heatmaps, pooled_heatmaps) - poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) - + pooled_heatmaps = outputs[self.pooled_heatmaps_blob_name] + nms_heatmaps = self.heatmap_nms(heatmaps, pooled_heatmaps) + poses, scores = self.decoder(heatmaps, nms_heatmaps, pafs) # Rescale poses to the original image. original_image_shape = meta['original_shape'] resized_image_shape = meta['resized_shape'] From 38efe54cb7c84b4ce81378891d3b980200b3aeee Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Sun, 22 Nov 2020 01:11:03 +0300 Subject: [PATCH 54/58] add symlinks to AC config files --- tools/accuracy_checker/configs/human-pose-estimation-0002.yml | 1 + tools/accuracy_checker/configs/human-pose-estimation-0003.yml | 1 + tools/accuracy_checker/configs/human-pose-estimation-0004.yml | 1 + 3 files changed, 3 insertions(+) create mode 120000 tools/accuracy_checker/configs/human-pose-estimation-0002.yml create mode 120000 tools/accuracy_checker/configs/human-pose-estimation-0003.yml create mode 120000 tools/accuracy_checker/configs/human-pose-estimation-0004.yml diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0002.yml b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml new file mode 120000 index 00000000000..b1e5c63e0a3 --- /dev/null +++ b/tools/accuracy_checker/configs/human-pose-estimation-0002.yml @@ -0,0 +1 @@ +../../../models/intel/human-pose-estimation-0002/accuracy-check.yml \ No newline at end of file diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0003.yml b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml new file mode 120000 index 00000000000..0b2774baea3 --- /dev/null +++ b/tools/accuracy_checker/configs/human-pose-estimation-0003.yml @@ -0,0 +1 @@ +../../../models/intel/human-pose-estimation-0003/accuracy-check.yml \ No newline at end of file diff --git a/tools/accuracy_checker/configs/human-pose-estimation-0004.yml b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml new file mode 120000 index 00000000000..c8f2d4b7f6b --- /dev/null +++ b/tools/accuracy_checker/configs/human-pose-estimation-0004.yml @@ -0,0 +1 @@ +../../../models/intel/human-pose-estimation-0004/accuracy-check.yml \ No newline at end of file From a980b1e259f5e5c3e1b3c2ab27250ccdfb393b7b Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 23 Nov 2020 14:17:07 +0300 Subject: [PATCH 55/58] add demo to the list of all demos in readme --- demos/README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/demos/README.md b/demos/README.md index 10a28e83dd0..56339778279 100644 --- a/demos/README.md +++ b/demos/README.md @@ -14,6 +14,7 @@ The Open Model Zoo includes the following demos: - [Formula Recognition Python* Demo](./python_demos/formula_recognition_demo/README.md) - The demo demonstrates how to run Im2latex formula recognition models and recognize latex formulas. - [Gaze Estimation C++ Demo](./gaze_estimation_demo/README.md) - Face detection followed by gaze estimation, head pose estimation and facial landmarks regression. - [Human Pose Estimation C++ Demo](./human_pose_estimation_demo/README.md) - Human pose estimation demo. +- [Human Pose Estimation Python\* Demo](./python_demos/human_pose_estimation_demo/README.md) - Human pose estimation demo. - [Image Inpainting Python Demo](./python_demos/image_inpainting_demo/README.md) - Demo application for GMCNN inpainting network. - [Image Retrieval Python* Demo](./python_demos/image_retrieval_demo/README.md) - The demo demonstrates how to run Image Retrieval models using OpenVINO™. - [Image Segmentation C++ Demo](./segmentation_demo/README.md) - Inference of image segmentation networks like FCN8 (the demo supports only images as inputs). @@ -69,7 +70,10 @@ The table below shows the correlation between models, demos, and supported plugi | person-vehicle-bike-detection-crossroad-0078 | [Crossroad Camera Demo](./crossroad_camera_demo/README.md) | Supported | Supported | Supported | Supported | | person-vehicle-bike-detection-crossroad-1016 | [Crossroad Camera Demo](./crossroad_camera_demo/README.md) | Supported | | | | | person-vehicle-bike-detection-crossroad-yolov3-1020 | [Object Detection for YOLO V3 Python\* Demo](./python_demos/object_detection_demo_yolov3_async/README.md) | Supported | | | | -| human-pose-estimation-0001 | [Human Pose Estimation Demo](./human_pose_estimation_demo/README.md) | Supported | Supported | Supported | Supported | +| human-pose-estimation-0001 | [Human Pose Estimation Demo](./human_pose_estimation_demo/README.md)
[Human Pose Estimation Python\* Demo](./python_demos/human_pose_estimation_demo/README.md) | Supported | Supported | Supported | Supported | +| human-pose-estimation-0002 | [Human Pose Estimation Python\* Demo](./python_demos/human_pose_estimation_demo/README.md) | Supported | Supported | | | +| human-pose-estimation-0003 | [Human Pose Estimation Python\* Demo](./python_demos/human_pose_estimation_demo/README.md) | Supported | Supported | | | +| human-pose-estimation-0004 | [Human Pose Estimation Python\* Demo](./python_demos/human_pose_estimation_demo/README.md) | Supported | Supported | | | | image-retrieval-0001 | [Image Retrieval Python\* Demo](./python_demos/image_retrieval_demo/README.md) | Supported | Supported | Supported | Supported | | semantic-segmentation-adas-0001 | [Image Segmentation Demo](./segmentation_demo/README.md) | Supported | Supported | | Supported | | instance-segmentation-security-0010 | [Instance Segmentation Demo](./python_demos/instance_segmentation_demo/README.md) | Supported | | | Supported | From 3d8b5f3b082ae80fdaa0502f235d6221690cb76b Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 23 Nov 2020 14:43:59 +0300 Subject: [PATCH 56/58] fix readme Co-authored-by: Eduard Zamaliev --- demos/python_demos/human_pose_estimation_demo/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md index 095c6b8786a..069acf761df 100644 --- a/demos/python_demos/human_pose_estimation_demo/README.md +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -1,4 +1,4 @@ -# Human Pose Estimation Python* Demo +# Human Pose Estimation Python\* Demo This demo showcases the work of multi-person 2D pose estimation algorithms. The task is to predict a pose: body skeleton, which consists of a predefined set of keypoints and connections between them, for every person in an input image/video. From 1c0954caa87966744dcb53f57b64a9784832b4a9 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 23 Nov 2020 14:48:09 +0300 Subject: [PATCH 57/58] change CLI arg name --- .../human_pose_estimation_demo/human_pose_estimation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py index 213df725674..bd6ed1912e8 100755 --- a/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py +++ b/demos/python_demos/human_pose_estimation_demo/human_pose_estimation.py @@ -46,7 +46,7 @@ def build_argparser(): required=True, type=str) args.add_argument('-m', '--model', help='Required. Path to an .xml file with a trained model.', required=True, type=str) - args.add_argument('--type', choices=('ae', 'openpose'), required=True, type=str, + args.add_argument('-at', '--architecture_type', choices=('ae', 'openpose'), required=True, type=str, help='Required. Type of the network, either "ae" for Associative Embedding ' 'or "openpose" for OpenPose.') args.add_argument('--tsize', default=None, type=int, @@ -142,7 +142,7 @@ def main(): mode_info = {mode: ModeInfo()} exceptions = [] - if args.type == 'ae': + if args.architecture_type == 'ae': HPE = HPEAssociativeEmbedding else: HPE = HPEOpenPose From 190a85d42bb4205f7ba7f19a3e9b630cbddcba58 Mon Sep 17 00:00:00 2001 From: Pavel Druzhkov Date: Mon, 23 Nov 2020 15:53:27 +0300 Subject: [PATCH 58/58] fix demo readme... --- demos/python_demos/human_pose_estimation_demo/README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/demos/python_demos/human_pose_estimation_demo/README.md b/demos/python_demos/human_pose_estimation_demo/README.md index 069acf761df..e7915802e49 100644 --- a/demos/python_demos/human_pose_estimation_demo/README.md +++ b/demos/python_demos/human_pose_estimation_demo/README.md @@ -32,7 +32,7 @@ python3 human_pose_estimation.py -h ``` The command yields the following usage message: ``` -usage: human_pose_estimation.py [-h] -i INPUT -m MODEL --type {ae,openpose} +usage: human_pose_estimation.py [-h] -i INPUT -m MODEL -at {ae,openpose} [--tsize TSIZE] [-t PROB_THRESHOLD] [-r] [-d DEVICE] [-nireq NUM_INFER_REQUESTS] [-nstreams NUM_STREAMS] @@ -46,7 +46,8 @@ Options: camera ID. -m MODEL, --model MODEL Required. Path to an .xml file with a trained model. - --type {ae,openpose} Required. Type of the network, either "ae" for + -at {ae,openpose}, --architecture_type {ae,openpose} + Required. Type of the network, either "ae" for Associative Embedding or "openpose" for OpenPose. --tsize TSIZE Optional. Target input size. This demo implements image pre-processing pipeline that is common to human

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%0AU}nb}V-n&wBBBKq9F6 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%0AU}nb}V-n&wBBBKq9F6 zIaf$!>zGjcROKZi$g&*--TJS@r{JMQP{XE zL}681AA1qn3HQrE2r-`?EWTL_-v*-N!>YDZ z2{XjF#VY3VT&le4lC!>vPr%q0kESJwwbDX5=+gJ&4dbOxI?G$*`4ED`7s z+YttNu>oX9VXV7xqbS^G&YndK4Xoeb#IUJJ5a+1)l0)mlD7lbiJ^8lFVcI1e7X172 z)$8XkUMcOurHfatt*$|Cm|^=mjuJEO24_?R`+gqo<2f>R*%@w(N~8=XN|~{!TS(>J zq$f*m!gy)?YrpZEqgm^3v~9OC4lC!cocru=U;45id2)5vWV#$@ZFU&#qXx&9Iyg5m zJ9CiTnKhA@99Z(ea?NU9 z+m4-YXp7mo-j;iBN#k@WzStQ0E*7T#-1E1*eSSS64FAgWhu3&GzG%uB=L zQ$J)}I%{q-uZ926c2a{W6pZ{Jxqdi^Yx}yVJF4T(QDKQ&m2pcfu}uJ>MC@wjM{b-n zUwMskbOAbUrO?Z$7Q^7Vvdd9(L<~SbS*>cSn<6V$vEA+b7HnvZWTl7&ZbX^VKY_(gkX^gbX+put32+(hM+@=YsI-=jQPm(lw z>CVYy?m3=`Wl1>~Q3RsH0yHnakvH&iE4W2sKf5BRQQTq_4qD84mNJ+w(#t2a4kcD^ zl-RW{xdNepma>QN0Pz980<(vy{OYyUQtTjRA6o2}Lz9~(dWj>Gr0eK>`G}S5V?xWF zm~AFg9D1_4zINf_#WUy5!Uhk$94EtcKbaLbpNNcwe@lO&Zh$RGAR=<1EoWE7&p{K6 zm%LM9Ut_Ribg|nrTKca)^TOF*%e#&}{Q57fUi$PDGu7~Ot-V%qYVeb61t(4}~cP@@U$BJ#+s?loaQyT1V z;!c^c9#dUk1SL+`18s}gxpAqz$1(I)nD7C_e!$#<)Jc7?&-~2K{K!W>ik-Wfw}3HL z9BPudBDw5iW~r%C4RRj4A@lA0n{T}N@sI!YFaPo{|LLFo8G;>HK@JK!G<7VwqRgFS z?eJtr>_WWYI}Ai;^*!h`b1h6s3#%=H3t$^eyR1yhT$|>W9S&c(Ikod7;B+g;ThL1Wc@6?|TCKR@z6@#0bhK*tV*qpYKlD)0Bp!Q2H zy&=Wl)`EK(?G|hLHb&r`LAq}UQ`i0@Y9J#^;I}&Tz#;5kO#XDbsbaCns!W_m);t9( zUqcodjN3W5rcH$lHIrFfyD`1Keq*iZO*QIz$W!wzwfd@YBNh zWjQOi2wy%{JS!L1S`q^n4_mS(+boUFsGYHMUts~`H0NXOAN}+5|MTZQ^+*5u+#mk? z3-`^QT}r!FmeX?|dH5q=|LE8K%(EZvcL&5P*9j-z zMq}n_V1^6PLUDw-Mmy^+Ub_6+k=I^)>16~xAngEI45hG*q@c2YXBH%rEJMxjFul@J zSfK6L&|MrrbV7!(?A^DI&|&y43E5~cw*%6d!3h*WNqGLLpZXE;l#pS?>WpTr0Qpr+ zS%q#MCRj1hSGT5m!f$nwWkc-A+5$a!mXo@9Bq7l@IU7l(XYtbz*>6Y{p7 z7}>0zIciO4I33ttP7yuhz=3^u@i4lE3OR~BAAIP+lp^99i0R{fS%#jcl?tR6E?$5G z74v)+8~&9mS5X}Zn8S^458Z#Luq#HlN)7Tt)tcNZVYD*ZXg7 zR47I2=TtcNq5I9tAX5j{?>(A0s*#bm0!d^fb*iXi@|bcIeL=i4<>&ls`S~Ivvnjjb z`vpB@imX1r6e_G7}Yw<$Hka+{8K;xn?o$#&$24pG@4F>5IwtDl$Q#V z3mQ%;@stgE6y7FHpuUg6^l~1kg(F7KW64pZ??s0@b|qE{0=IxbopH>c_=z7Z=gX17 zEVMykT?2LsNi?9=c42sqHcepVS8UpYh$}b&g%+Ba=kMXcAwOBWF#17~s5j0Pm{9D!P zvTkXk`_|feU1_?@+!)JiCF&gZpia+u0gcBZ02gm}!w8|cFj&$upEA}SdF0_Q|MD-t z@4kal*eVi}03(WHg<#zUXsCw^;cVEEL$k44spLU{gw77GW5wK&jx|sf8Ej#a$|~^B z1aDg?E3WH|7F5k$7`tmj{6PFI<&}js*SWRA@Am_coZVvb41YBzQ@nWN&N_VuOY_3^ zfqricl^0)p>4g_QjnEZQtYRob9H_JO=t(cfYTcq|8W9^<_v zr;Nlk7RBxjmpyd3ntn#(0j=u;o3|>8SfMCo=QywHSqz()AJ$7jq?X@XXBLymawqS6m9k`_^#)B*9os3CySPdwniArj?Ny)(5)bb8qcd(~)` zax8qkDCvYGq7u(OV@o1YVr4d3EAuk#he407DTp)_3DN%s$}tgh1|liWRn?tPLFof} z85URxA}jFC*6G4)7s6LK$!J_+r*YL~e`Ta**3hD+pln7s+hT-=dxRusprY8Zqc)D! zdu@AHhi4FX9g~jm@xXxtPdxENOtHlMPNvu!e+cN-kfgjkjjZ@j)YutFU`ZTb+o+($ z;mBYBfB9E``3HaahwE$Wm@>fH=eG8m-Zt)OR2r*3P(&0`6X+sWdbVval9?t4OFx#a zc&7&zU%pzuFvzBQsK}-9>ryUS9sv(k12M3P}#&zK+^(zDY%=PH`ggghDvcZ&2cy$6cl+&v$ks}x&JY@CxF^L#l?ilSU`?8e)wm%N zpP#LQUM-EeuR>EvFKiKnd}hG~uAoHb{sa3lD)8h(2uw%Wx)$}|t1J+q@L|J^a!r!Q zfB>^DKJ#j%7|l9(tl=yNoYal$*O0ficJ2E5x+Iuou`7#mAMS+ruu~AO5GTHJ_4?^E zXHUQT?wNDvkb{INLN2dlxRohHY`2<(A?+T*dM4L&u8FQq4$Qb2`K3K>X}soM{Kcd1 z{`s0)3oY1B*Cv1C^62PeU+KR3=N|sxHywz3-1R1QW7lHfIB52%i6Ku?EAaC!Ok-)Y z&f$ibC@S^aQVLStFx>mF_*{)c;LF+h*d^~n7t?jPQ7&G-c;Qm)%3MuzTZ*yv9!0kB z+e9B|J?+^4BWLcl{kC0_@F~@ys=2*p($?i>xGAja%a9QkUb_|Zm!h&R^osh%GN9Vt z0}powEet%r$0xO_1U(PbS7KL69zOKY!(cRg&)5~?jmc!eW{Oug!K^Dt6!fT4u)ni|3AYrX%?PJMYYseOxmZ{Z-ukVP@aYo%EFkmc3lLh-}BMf?V5%lI@N4!h>;*aV=-r@!5RSGYb$I(PMP@& zQ?b$-9=Sj>%C!hSm)0goxk1VBab3$co*a!U+#XGwi;=VSgZ^qx+(Fx|(w=(#L1rIX z3fSiO$|P>GvV=W}`t@o`9BHQc<(q{|>ctZyQ|l7p>X2^|1Rem64{~(u!FM;e`qV#a zPo7f%qlv)m0E4~;RJVc`6K6OY=JD*KZ=-8&PUH3Uo2ziKU0(ys#|nJd9XYDF$Rrf# zPDx@jQ&+&z(DY`dwtWUAlS|(Q`4^3|en8m-0?e;clM_k9CP< z!En|XapqB*mam+czWzrS|L{MbYt9|Q4mbS>U(ModI$k^QvHT5x`{|XBxY>auA##&0 zPaQb^9H>Y_lc*2N@9<>XhQZyghe6|>^e$6=+%}|{O7$7{WuKmDoF`U@=PXI5< zf~uz-{X=XPqZQ&q}K~ojM-bm+?920AscRr3d9wyfqyo#)dgZIrWlOOUS<%nYvi& zp&`bYY1vp3A7%@ESD)N~^o*M-S!SN2R;nW~3K>0HYciS_XPhR=bn8mC%^JEhZBZnd z4aji08_%dKeBfA+^ef$gWKmp6gSdS!v_LSu1%ig9StP+EB5Vb3hhc+id$6T%0*F}~ zHC0c$BJJ&6PI#R+X4CaP=`F^hCl(GSVd{RC61J}u7}p!%_i&gc#`sXO?A?BMJm;iZ zq(6(PS}b^>X=kyx%mEk1oM{lfqRPv+B~!rq_P_*5vQy0n@I?V&nC3EST%a7?dh_T1 z_xKCHuzDaK1c&zR*nv|o#r4tU&;6E%zVt^Q{k$J}Xu2m&$2s{90}uIpu`P)(V<`F& zeBGl_$a?P~#L3hm9dAWda50JFStb*pdY`{=er8_7#p$j+NdwA5-7}6$rvvY2@L8D-FUX{8RmyN9Iq|)lH|o z&Kf!??yxv_-m>X5Mo<3m4!PX<;ctiRWU8mrbUon>4P+}!UQ|^;J&SFM@uX?Vno9lv zLoH;!OPpDVCN8xa$+MSnw5OhW8XO%A8^_1|$>+~(bsUzeGx6SOgC}37*uX$J8Ut>} zvqYjLxh)ob3Ck}b`aCR2p~=|JV&$fwCJ34vr-3Evc)pxzBx|d#Iy*LYv+%$8fU=#Ps zzjK6wK?K~uF-?b&VutghVocgGO*n)WG#d5iQ0K|u?iQGoU8uyvdrz*;)3Hinpp94Vunde#uhXn_25trl1S>JB`aKk zpg^+%FV0vVSQBDOM0)2=?*n;Vp{pfhg8K%ZW!-Edr$8cPMK3sBu3uRjN&mqkrRol@l6t z3hV|RP2hy)hkoe0SyrnW)T21DW*mh)JVx9wM#8I~Pk>Fx&i#(M+0b#d9cfh3EkE22 z18qAbneC;4L4gBV4PN7V0rYTrIoH3^D$Yorp{IaZ@|sOh0OaRFZ>=zo%g7gg~FU??Xsf$1u}7PtHv!C2IuL z^lc)PMRIcaGZSX10v$uX`GR@V8q8*I)^=9ae(7e$lE+J?c$!x5pp1$YZYV5Vs%sy( z@4heif-ijX$tQ5-xI&h(VF0_HjXkqyRt+bnY$qm8S!(-G_p_D>-e3uoa$C-jax4vI z93uYeoJv1u)!i{Q9rMOwMwdh2dF2bzou&9DV#)Z^{7ds~j|Vm<;&H zgV>t8N_9*PvpQ`*;k9woT{+_xz@SRJCR_VX7)~sF-BM6m&-L|OD1+|1Ga1~<2kvDG2 zvTbFcnJkZn^OE$>01qj~3q*~XKo$nNevSQ$1|OO8_5aSaSk8<0P;9(41lPT9#D@;{ z%z>73F2)T$Q?je7E8!~|@F=Dklw~_pw9h^F>|>8U2DWiv|ABq`_9H@^-~iM*Ik9s7 zr8inr()p2)aUd32)kqC7Y^aM>8DW-IXAojsfnsEl|Dyei&mMLFX3wjRXQq)X#U(w< zpW(#VZ|~kxK5o?ZMCHvUFH!I-TMRKM6#E8=45!vhNHtiqv4EJ2jatKq2ck7XPeo$| z;c^Lz%Tp^;&osK$>IwLcDxb!>=}S=|x`vnM7-zedOPTY_S1utG4%f&acDluQSyhT6 zKU3qzaQHO00C5}JzWk||q@0+nPUjbVRL(l!+=k7VVCM}5jL47{+ws)quTFq1Apb2Q z#bA=y%uc92^|XQd+ooowy@eRY11`gBQ+A7Y+`($HZ?8b>N9>G&=7r=Kwz%%Xe|E*uW z_9y@8`1zM7ZC+lAyPD`Ht{ab5cEjLua5DPHrLX))4;=b}Q3j|S;)C5}=5FGU42j5w z9B=J?BI_!Wy2jnbiR>pMuY=ZTdcRUyRENb%$yCO!`fnSEhfxIAAO8+ zD?24wF!?fJ3pYzf;BoK?^CVrs!R%o@q*@yo%N?_G#aX{M#MnY@qFugkFPnk5h<|m? z<7yN)4@N?@7g0IG&hT9*C^%nnj}2c9=7_ZdwnuNe9*eAp=Fwr5XKbLmh~zZ&bP zs>z)Z?`s_e#s<1z#a!Gm79Gch!=6!i_>Vp(XAzx@xtFy7GY4HLmtF$j z4(#7o;B({%g{wB`wfHn9`(co!ikkImv257mDYeiCYw-u8DVjo~Q1MmZSu^%umU6Xw zu*8$$Cb}nzEW)=TuwImRU`s#~H@Xzw@UCK;RXDSh(69wJv2XXve$?G+o88Um=9Sg| z^l$&exp&Wunqr-WxPjsvyliEg4TBk!Cv91R$U8qw`E~UZnbrcb3Am(N=X$Pi`>m05 z!}xdmtyx)k?w~ARX`$ng4LdG^eH_H%@wHm`IloCrY(m3D5ao1T%HfDyJ5o0R{*LPA``7Jr>(+pctaCwU(( zoWJ<|^T(vij`tCfa+6#Wv*<6d=wt5R64ZY0Dl8z z!<2>v>a4{W2(omYzKsItu@en8-VBJ}>(Nvp*b&@K{F zYD?6bNxus9LOO0PRN1pfh-CI6QI6Z&teEEJTIJNLQfpj~RDo3Ew#qC^(db1qFmNLy zJzXo1>Fsj=x1b(85_S2@HjlnAzp%8lC?ZCN{!RKG6HHMSgQ&<3O~F|G3teS$xIo{u zeT#x&PF$9J4(i5`rP#tEh3T+ZJyqrMs8w^%=6@pjY|Rc8_%A~a`d|KDPm{|+wquyf zWdW5jrMWr+w-apvm$!0*W~Lr4&du$Tm_uD_3PFx5moNX!KluBnPn|SGb8|CdG9aML z^~CEoq~W?7>ZHVF0A9owG^ZvLN;+}tTTj`#; zQ{Qy0lj=T6X=I5M=B^DANKA|0PNx1Jt22J(dJt zLJR~RC~u4!jOr|mwSsYi(TXUD*{geB@P6q!jeasu0Oo>gFrfE)`IPvJCkDfYpT9^k6QI$9Cl#*gkCJOwzP6uSV z%3GH?8ndmLTYe0LmP$7OrCRB=N=e%j3NZK(^jD-UdU1En5C6#bbx08^yNF^c^Hd-2 zaJJHOP-kd7eF@5fAj`EF~q3gF$MoH*?RjCt=Yurp&iu;}1N(vD$g!t4` zN1YvH?~~`}hI{w!nw=R)=fkf1Xp+g+)`k?1Uc7KY8mGpX5Hpcn0_6ulG|ttpe)Vf! z^V-*FvRu!4N6B6SIz5_&yz6gYLr_YH02I$vI_s5mP~q3e23^!Xy9ypFV7iWq4s}Os z5tynh>q`D98(P_+UAr{RuofDey^D+U*(tZ`f;TEHSbtm;IVjD27X~l>Hz4*Y)k+Le zjojAX7sk12kSA3pIv$WEtDCJcNPwj~beHnbUswMhNQtx(%0L;Ygq<-a?VzRF$Yk8J zB`c->(mzwoggPU&=7uva`}oXJ;I060*FEqLcAuId^mW9s^;cMZk65`Y_R8U2)G znUsZ%$WxANiGg+YKvLMA7JB#U?)3!5uBuxF2%%3$-(NqvDza#Fq};6~UrSlas#Bh3 zrT8*b5D?|%OEVAR=?F5%$R(Ko9T-9r96bgbm6AJv0>up>)R`&a(#4BE{nI}!tZ;-V zOfqWFmTggu!oqT;EwEH25kO@fr_@I>$i#FwV>QwGCItiQp4**XhOe!oj^)^gQ|+vW zUUu&MrHd9CAjtr*29lw?(h|?We6tdt{=x;Mt$lm;OK}cx3Or6QW@M;&6Ib@$vUvYn zZhQXNMc+h*pca)zuC1ZS2@0+7bhv`?Ypl-u-y3UlX%ePfm?~{lBo#QQs)dDlU1}Zf zJ(Us-oECM}tsw#f)|e`XT4fKpbmvj)Va+8QskNDit=QArw4ZyQ= z!+ra92`YSJbDdeA%Esc_+RBL&$K`4XH-%<U9No^Sr7S=WZO(B{b z=hsxdXm0C_0%C@P3iDPzCrH=3087}g z7qPnrDH%h|3nTRjz!4_bL63ce9iWmHY6b=rYOa=tF_pRjYE1Sb|5&&I3W2U(WrdWg z^jg(H`Kwc!)VOHHkZwR9{_uxC_OXvSS4ohjsw>?n%CGmzZIa$L&Sn^v(o8BfkY-|x zaT%ytSCuhjI-|L+TrT0@(hDFl_i%aG2PHF3cC?quR6lJPFqApvOMIguh$-ObOBL*d znO}xpM?D|JKzVylfSMRf9Bra1;l@dP_L1cSdl!ZamaPX!7!kpsp@z1&-njd9dj?B% z;mWAl3W*yB8Qj z*)~L%-7f9LFH;6qXE@~vO}q@F6EbK>n+{-IJ8_gwo;VSF&@F@$7;EyfB9l{`%48-J z%2dSp{%S-0**m`yW14_Ye(;Arl%HwUiCV=Y~3hQ{$ z)k9>aPq&PlmmSfk66N5Olti6~cK$_GiX}RcViH*U%JRB%L;blBxgR*NmpL|mq}XGv zces4z(wQ@-1$;OfHHKXF&PmCob0=<;IQut#(>D^4C|2eiKWwE?c%jw~D43~4o(poT z5O{S?ZPFcCDTX@bHr*FlpYJEqFmsp2w;ePY`=azOhKzHv_{3SyAUWq21nOz6xa{+7 z=zC70Mk%&w2w|@h*$}?U%&;{Yx1A&UAd5o9uK@L;LdwoU#-h>8f^BVB<0`Uj$+izy z1Wa+m8S)r_nS2~TG>IS)r)-3BwoREb2`v*@gp}<72G+zsBSe6d+5=@@G=IQcH&?rQ zZaBLj|LWT2!X*QU5Gm){GySp`gu@+o-U)!5V(3bVL^L8>M&tm!+Oz8-N~QnGHpLdI zy!Dr-ij2D|7JBgpqgk%Iuc_ZkSr~!^)?VH z@7Ra6->Ax5pVnumk5PjTg)k?G5t@=vr>*>-|L6ZD9ZGYSrN&Gu96K@_?0EeM!4kTT zSX&$OSGh^CqAZ3jp+_5lk|8-I0glXyB_~57LACY>B$rVa*0`>`F`tcsGt}Kq&uPyJ zzn)PXZ>(0YZJE`pOu_9{&J-c;E8~xT4PbN##?Zh9d;F=(&pp1nZ~vm3t;Qi(>k!mz z@{G;g{_5^G?_IdXtgMQK95_K>3m9?@X2qEYz}iY_H3=#NM>+cQQa@%NpRqH35U1yI z=qU>ZVd)d98SfieDFS$sWvMz!<4juJDHF90wFt}*kU{HA77K{ZRnlWk*a!`gT4=hw z?4;$EEuOvpk@}jl<`GHCIwm~J1*g+*aIXoZ{=jQ{KJ1LqV4n7Ze@|tA`n3FQ&!SAc zS|VCEFV0ocKsPrrj54xu-|h~&l@zMil%gcgwINTb8 z!mC#5k}=LA6Kjm_rk1R;TIDTU&OnYb6jfddee$t1|I?3Nbh#$9C7+ z~gcvC4{fJa4vLFIaj6eC8Bi4t8buwZpx)^wzMmcvL8r)nwQhn2p-1DaI-@jRn8{353RyO&u zPhrg7LrB@yv5*KNV0z_YhucfPfpXOK35c@uiuZEth2xKX<+0<(kGrZORmr{EN*6Na zQRdo28xe!|*4hIH4p?K0bzAzS>i=-9l!^@vR+Vi*lSEjzGAK>9=~|ftlS)wIzX)Lf zpP4|qn0(y%x_6A@y6sR(ab;yCdzRbI()FIVNgnVPOm5^E9`bBQKIU;~E_n`io zF?#cA0dA$Dz&H7){H`j-iKs4@pJc~kMk}>!p)$>)6OE}%({$yfV2v%$N7zX^k6*ih zD7npGao4W-g~j1;mW+{B&B81_YQ|dgmSTd!qR`Q2DN>{BtKM}OEA7j$JIfj&08}>Y z#E@gnK7|;X6cYgsYrm^%YLf`j_+Xj{fm7t5Erk^MrR?|!+W9W)21p3`s)4cOtkLf5 zXb~`DyV`Fp8e~XO20^MVIfD+-f~ieCbhTk#zI5@#3(r@EqzGX~WH>O!3^Ff7Nj4RF zQKHiN4*F91$@Ti3x3hBVO?3g=7AIf4+y3K4iLJb?bA$##*_&3-cm#qSEEf z<|Vb%c0sPHyayAoi~{z{lQOVBc4loW9UbB8CD*U0uSN3>A3Ul*N~TT%FRD&|VdEqJ z;4wZo95joTU1jD{!03Y|U>7#%(#-AY+yCUfyIzO0cbH8(YG{mxF_)(RkoFQm3;_If z?x3xr{Z%zzZZdC}^jdxRp+}y7?s<7!R*SOY6k-D%SSAR{D%R1_;BHA%))gR{4*5}< zrsgqyjq-CQi7+neytJ6=cZ;4@=cW8}TW!wQg_F29eh&+E#RJN|1Urh_Nk!JzH-OPu z7h}@m1J!Lgj#mL-ySZfX-b>wiXE$I8AwmZhd-91Vq_jGdPV3dh68bJhiiHx+O_X|z z1#{WqF`d>QWRait_|D2@#jp}~Zl4@)18jelNL%G=mA5u>A zLXr_;gHV#NNjK0cgN2PM2IZYE+q!0v^O1oy?F|u_DWufI)l@WC2&MT>7{F-=F`LU;cled-iCZ3qUm_qB2!-s;Co@Z3qme1WVO= z(Q|O4y_K@`-Slm{k6hp3MrZw4uwoj@t($57j8;vkPaZ>%p`NH5t+ur33LF&lfG~mD zDd%gyw0sgREIo${?62cv*Md(?81)gB}qSUwS=YQ$B-~1OxhZ~D?;m}N4 z8knl_n+%BzHECm`y70OW?t9bs-Zr=onu?S0DRLMm1I7>r;1G8{RsAqLcHZQ%_6V>x&mJJ69Eos?KUxXF`>3AF|L|rD7av&t+pwA(Mw**QBY-QF=TY zQ`9+_AN{c(%D-=Vl<#~!CxMLeLLJ+~B$`|0Tct$i)uFgHJHB&b<|X9LrwT)FqFYYd zA%mjqQN>Z%$t=xRMeQK%1$pl5xie=k7%QrEXpA$)96Ypt*RF+6eB$F@_`>H!^GYX8 zV`ydN>ak-l96Nq2#-teSyh~U`N3?TeCE#z2dDZ>*`!KfF5CK9Ma~klD5XrulTxIFom`(Xzvf43IjRqzw`Hy3(VuG+N-_(qe`Mzv zRq6-jl%o)_lyI%FPT>pcZ21tBk5zeD<(me4lYB;B7-EB*#4NJGCE(f(?`!V+arnva zgztF|y>CAqdG6AsE4XC*tQqftt%GrVkkcOI8KjB`!T1y+6beVSob*J3$;w?Jfgy&- z9u2p;-PLLm<)kT9GR-K2tg}oA##yk=j+*B4U;NUSANsOPUiXIA&(6>1W~reWH@dPi zIwthXG^XxMlRF`nn@g2>A(T)I__lsIW+Cee4PaTrfcdNcu07>lHWN-v8Dyl1J%v4H zOHe@)dfhbEq+x}m4yX+1+|Vxe7_|VQe2@Y)nQG#reIv>i1I#d;BPgq06?tJG>NQbM zDFzQ9U5hUM%CG#2wRTfvYqM!ay0(FNqW-OZAl2wbN2Lt~CL3891w)K#*G*2##6l?_ z8TCgUs>2RyIT$LyBAs*>yFUtt#LlAE@kSe0;Xu3wLZO5f@Cu~QUwP;|V&tf70Z1kR zAz2?7!MRkYtKrgv8%LiyzyJ1G9*)g`QUIca77}Dmsloc;`xg)0v-i}AWizr4z!{^B zqYwtFWi-4(N+mRj>jof87aIiRK6es34Y z;z<`S4h@j6t*whanm29i6jRD;*cEh_k_{V!%$)PF^@R%;lJ=s@Jw9B6Q#OlemUtT>=g+zsl{g6sTO4^Y@;1tJOo0*J7+g3I? zj)WZ5RkJ{tE5dDzT9KZ#96B-wO%q24zPX93o8omvE3w{UJy!`P2wB4&$| zczl8wfemsYAAB`sEg5?U&pI{glkY9fRXt)Zu%ep=9Q z;@SAjBC$Cp7Hyq!?p&ZayLRmo^D6geWC6~|=Hi@{ zT=Jwr{k1~<;{9xzUAcNyIZZ?Gd7n(mpblED(7}jY#~9P=1>Q9iC++7=uA_N@ZNe;2 zFv;*rh&HQ;91z(#NiohXE-uZ@FAPOyhLUNN@->+XhDcT(Y7|{Y4u1#lwYoR&lAwWx z((D=&nhbV{DU8B+Gd5$0h)okbEYs_Dzjh(a9ja%X8EnP@+r81xv7f^@Yhd2OE}Qn5 zc*Oc!aD0&bUTW?z%`M~)P&j1#-PXU>gg20v@qml(s^d4#@VkcaKn?d-c-Zm+B*QU4 ziqQw(gmIH{RU1Xd1Uw#Z0MyYZWUj2)v$R_#|KuP4?0@~!KXvlNaS6!^J#JR2FFm*S z5|fuH^_vrQftXxPubtoIz%eQapt7cN##vo9l&e~)^s&<*vtsFcNY+$(%E{1)4)uNI zMe4jJbwQUbPgjPjf0h#4v_mHPSF2*q?mt?K))}Sc%}ZN5o2dDsYO&<|HGn~NyQ#rf z9(zp8<;{)F91cNaNY!vDf!7+7Ongn)bCe3Gp<~XX0$a00){v!kbl;*9WotOcYMO!2 zAZEseNx?4aCtP-gcy60PNZ0h~xmIq}IfTlue9h#Q zz~bqzXRA-)s2mX*=Ms_!2*9*ZFAc}@{)Bn(Kb*Y$SX`vT4rfDT!x?HpVT)HsgO%ms z$?yDc@4x3;cdfa#^|S&8y5>Vh0mwIeZ(WTtG~L$IOFInp?E6Dm0n5eAyR%YDYV#hM z8&?kj%nQd(KKA$%(gZK3hbZRFT)S1N0ewB^sie<^6pIWosAz69DnYnXcFO#T$Da`Q zPt=O?UNd*ER@ir=NXSFuvFVy|699qUxH%TwGKH_Bu#TIiuIqPy1c0R9<$n^{OSxsI z7EcTIfruV|;&C}jd5d6f^?lkJt3LE#KgNFpjrtcWCXsb^dDaH;jMjaB^ zQWj$iX`rH%ESUn!vn7L$*NP!h{ZDz3>vr(cunySA@8k@3uKlX2diO2?x=UhF=+r7# zyO#H5*yj6nBh@_+GOjJ;HCMW#c<*)F({m1*{Y-!<#WW7kG_gq`x)Bf7XYX0OpSNH& zT$#i5LkGuk?&vvwh^tjwkLp3JE2`|EwllSvu~0d*1ZN z%2Un#n;-k=U;nFr<;3x0lp(L#$&W8lmrr#pg(;cBRcXdLB|Y}}-ty_2jHsMOU_hO2}xmK>BgH>OvkWpkzT;VHpm6c(g4AT+MM1YB9&|jYILEGb6>hMEa zBrl`nA2p$_uDLF}BxR5GD4sbC+St$XXmV z!(tF*5Nb$6V;h_eAkw4Ozh#w=wX-vWT2OLAy&xotLh3ji$YV}FR%yF)L%FsskIehy zhHe#eK|j8TFzB+l(YCzvrui~kUU$sN1(uNz*qB_Gj?ofsj5Zle6_+kP5ug0X=12d* z^SH8L!@Nn>8aq)e#KCT?y3>2!K;QPq?)}godsj19AH}V#EJG$?^}PK%r@}kNy4Age zoeufN0}xr4#e|xQ0z+bS)gUE);rSPi9Xrn1d6PnkT(hpfqgKeYI=9yD-?uNnYuO64 zRqKRHG=zBU*s&8QPfGRBlTSV=8XYnZX?Zo$KIapAUQK%Wx>f*QMvv1M2U9To9u@BY z*XPs)MBfBvuBw6do~km_s%-0Wyzjnyj~tOcr^66@_P4jJwNuR>3PZk%KxQvoyda8S ze0l-dX)U+{??dTstV9h(@(x&K$!}h17ZwHgxhzU}`PI4p(K zZ{{$SDS|vyN>3-HwaHs}>yJB8p|h2(u(oD_hI`DyBG1;zXfw1BS^f_(Ho0F-j0rQt zIVcgHx?(XxNL2XGAOQqsKZCS19^6;G=6$<9a2wn+PR%2uhfl;89=-bWN8>-aI{W`t z3(uOlvp85`+5i|4HU`JeMvG)%4io1=lnf1t<))Eqp;x`mkS<@n z^wiT&5)mZEltMF(Az+^+LRF)RRx;q^E~v7Zp=_7>h_U66jS3z5e9WG@!U%K^@4URq zC)w$juh2Tu_>ORCXix1L|WOuGJ% z#9ZtgB^Fgx6*EfL78V8%yycCrdiA|O|Ns2U|NQH}{F6WR6L;Nt=iWU_t82?2``AZ6 z|M|~tY-|k&^C=O6ajw$sSB}e?3|@94UT`he)g2R8WW5*)i@*7q-$Y~AHpj-+S^cGV zy#4L}^Z)!m-+9L!a-w}oeQa7x5x5_uF(v0!s#Kv9E+FkzFtP6M$df{64uG9U9-u2s zpJ;9MO$qf&b$|cn(o0`DqJ$WVN|AZtEK(^cxuPSdLctwWC+WLbXMsVVe}fY18@D6I z0y5tgT+P`i8$9&zmw)I-zF&BXmg>dP+J=u~&w&X7urrQ;jHzp57Un9--&BZ^Yh%fp zWDzXJ%2bAGU>7KP6A`ci;^?!*fCaw9EQ2*jfoUuh!DXrV+?^YAaTrRq()N6t?p#kfte{sIAY#~i+iB__YuHC z$B=dn!4xMww>ty925bp9f9Vdxv!h@=kPSW?a~!Oz zQUjHp-8>P`etxw%U$3r=jICk?vQn&(lNsCDi2 zzkTU60Q^d2B~|bm>>-my@i=65>f{CQAw(WG(OM@al`u>=Yu47+?zr=g*S_{O(y=jw z7T&zFyc}c9myklpgzcFmQju{=W-4=GTse2{JQ>SL$y}#Jqx`K_ZW>K4r;Y$!y$>x{ z)9|I{kZhK&y=MEZa0}-olR9B~t#InpVbSbVI992ZereM*-nI1g0}Oy@_Tt=~TZ?yG z7~bNS7RU9S&HUX_Zbz{*Rs}26_|S~TX>)Tt+RCv|+k`;TJ7XLX2cOrsg@_fnIhp~( zyW{RRxCdT?Z<>qqGZ6=fSn-wW(iidbC(Q9ty%wu2z=S4%Sz~vGt7mxdP#S(F&U}Jr zJ_^H6K>aYd=g^%4bCqe6AxsM4(8q)kIf4g@xi;BWW-zRVj#9?0T8Q(hIpjC)h0!-) zxW~XD4tGcYc7WTEOu~)Km6NojP(!v4J^0Yy{#$=b7Jy_@)di+3r3}5u&Wm)asdnKP zxsJYxHNm38Whu>OWP;ZVV82~2Vo&QMs(se$=tEQPctMIy>3iU5Ks~(jf-zWNzp=4A zZW>8#fyH2ApcEh^2+SCPBc_BYni#<#*Az|QXpLvi{f3&*$Ql$zQL%uV^>G-dkT6E% zs5ezU0a~hVH0n^&zt};jG@YTQNBdO61e+!W$94!*W$s}kD`|dikGSgxb`Pc9VD97R z2x|isMQ5TlSQ#@Qsx=URR;jghf9%3A2B~XX4LP*L*ddh^=zygxNlR*VFsJ?&{d<#| zCSrkWA%SM0jY+mj)i4Ym{m&OZ`wM5E{P@*syvqQQWj0`{LFSW+V_K>2Xzu-6OTnWIM^fBbPlw%2uCZbLxqCE&F2AZh8SXnCpS z07N1DKqPguiMJEP?o8y_?-rTR*R7+i%G7Evn3)nDH>6@NUc8bEuUR$dKItv6e;*l? zfcabB`c}b~D@l2)(VNy4&i546)gTvifp$of%!gc9)yCs-BaA}%P0jX+cC`e1jU{9w z6Em%S5qSf7o9u(@CfjEP(MPmqT~?BS^~7Hc-uL6EYC)-#*3PIVXW^wT((k>k3#I2g zC5HS6QAjf=hYS`QW4%Gm`sUi|mCcP+`LlgUz+{n}bsPc45tu{kTt$oM2$gUqHa>dZ z756@{@W89xtM;b75F1X7vAki|o(fN$N+-s&l^`G|ny_m!P=ijC`uXTiM)z#2o=WbC zR6oY`Q(Qd-?knsbOx5R8^`+##lI%0=PC|V?xN}>4tidx8R~bWMHZFsslra~9Xqe)B zN;ZLKN(?gz5DhfGVTKTrdPUY!zB=R2e)h8;|HQ{bh_*-L^P+vJr-|WGQomV-w!Blg zppxrp=vzH?qe6M;l&A}*Yu^0&B>kkP8f4KYYxLQ4b^vARU;Qb$K8m|@zmQh~x`hBv z66c@#^e3Cq$O5)xGQcq_!Nde?7)(TD7$@+FlfKWtSlPp@(?mquLI>d!tYPf4 zxhYZf0Ff~z8C{;ct2yMCt3Fa;U(SavMFgPrH3reRszzfTfBeZ)r_WrzvV8i?SxJ9C z_x$tEKKIo1azz;w1acu+S3$$6`KVhfcP){0hbN-UK{B+qYFZh~-d?(>knRXO zNqV`k#+?PW6;&2r8wEbqo1u(r;|6TV6sNRs5?I@U)y0OQoQ{-JfB*gWzw@1MzwP!T z08uW-(@#GMz>?v}E%QLip({7Ac3?~eKp`Y+olyHa=R^~aTQ%G$y6x2I(mf!rm21?I?9MI3+|-JWJ}e z*6W*)z#HSO)`%I<<{mmfzu8m_2FVQ#&)ADW^tq4Y+{vIauC8rmnQG$(Xu()*&Jj}J z=&ebHc;M>UH1`b)@46@6wX2y2-ynOoX%*K_@`+>gJlNdR#e-!RqsQzf0Ycu=WnkVV z0@zVax$ej*M&nX1o-QitJ#p?a)wkB{u5oAB_Mp7!QgFeg2pj(9HO z>10l@eWCqbdzA4U)71u_mjD3TtFE>io4yqOWuOV?`h!YH1Aq2sfA;z3pEq6Uv#x19 zmWj-Egu-!B$=0DFDl#ixP?QX$Sh^%%Pcepo<@;@MZ5q>7QT?q#{RX&s)}L%^i=^E7 z%5*ZF2!BQSJP;u!_{{HoZhmIQKyqXNDJonlIneq-q?CLuYIL@y3Inn(2+FF10i$-- zk7_JQnVH;>!q*wbzLji0l~c-y#S}A>riJ+ugcO?C$S-Y zKt{lfp>fvDRl{9U`XSvN7KKGoS)ppJFEEHk`?q35hzhY%be?AMoi#{o5EY}(h*^f z$)^SDe(d-O;g8$c94RrVpxF-{K72rG)D9ewiO9Y8+#@R^8{wtUJc$pM+fp{n>~i1g zT&@P<&}n6p?#hwJ9zS*J*o6yc|EK@ye-exT`@ZMN57{a5E zJo>rMf9}Zbx2fT!x-G;|`fBvJMz$9<%nQk@=G_yP-z-*@=16h!vJn#|;A?a(GHz2W ziaMD#p*z2SCvZuxO~{S`cDw+oKvut5*3v#*IqW0}X!O)m&%SW!OgWLwO^PwMz$RuMZMB|sPK8UemPG|dYLj2Bwg@?5TGuV8cw^k? ztEk3mw6g}8l#(tf;M6oh^iIq!JBXCrdAwFakRhV;V94~*t%#*NI-xdx>B-BAmg9+=c2F89A(k4`=+~OzeJ-_6ZejBSbTLo#jw!E^YeMH)* zJAg7Xb|7#1^rt^9mq1mNLJ?vvW!H*Qg+b`0%q(W5X%d$kJ_&fdfMtYdRxne}2|Xy7G#tzGRs(sTY(&)8uvx0M_P~{vg?S z!_h;8WXQUNaWFF9vhx1Fu=`KEYwLj{xPP98^Hnuh50+*Y_RK8o9o7p2Sx1XQw@{mC zDb^N;Er+uiRIawBGP#SOg&ek{#H0{uB-Wyj4C{=}=o z{t)dJVRA&4EbssjW7;q#s+;=qwUsX7F8ZD`VJS3ThG*2(W64^{tqSFlaB>_va?8Tv zlK6EJrp>JXMrkoQB{k3GabqZk*g9t1kspUB${PVBMVnHps!BZj9APjqjd#M8{Q zbPTT4%GbI5jw*763&QW7X!(7I^TNv2ibq&oT|=Z0lai_D+EqkK#z2e>Lz3*6A!$Q< zRg^k25?SX4bv5gKl*sqpci&sr(iwf9b51!gy>CJYu5#zjpEpD|+*!Gojx4mV03k++ z!h~!Ygw6_+xVrGxiAWG0`;vi;ovtz6V^oy1RwJqC|Ejx7yuAoqpHIzM#=-0m$;8CN zy~FbdMx(hfSdfojEmaG5j`zJT9=fwSPz~qm;mqM%k7UMc0}eU1UrO}K#@%jT{f61M z9poc0G7M%MK#p$Co^hw17(c#IZ6tz-XgHG-N3NK((pV#q2o+BHG!!ROiR&zbNgM#i zfF3X*C4gMGp*`0yAwu9Z4nC&nSWjbO{mV>W7dd+f1a{^kGZgAXAH2u8q?O6^cu0F=wUEpxG&PP8E2gqd$fQFa z?bhI~`fVS2!=HX&;d?*usz37nyZ)Pf@zsm|jwOHF?r__DI7{S|;M@ZT$8%&H)dnpgq9z#>SQO*bouGh0P_`M;x+mo`HUtJu?GjQwGY7^&1v7R~ z5#1UO|LEKw{>fW@@(t-*zWvTWeNGu1%RMLNV!It{!5p2+nObUDfz- z{`|#|d$f4(btCp6Xm~X-$1KvuDJ3@6#L^)wf39%`Nr}k+h$s%5da#mF?Qx6((6utb z(R6coxx!`O&SkaN1BJdW!q<&bW~*H5&Q->`JgG&UOJ*#FB;{u@rn;^OkvU48Y2qYv zQLfnucA2$@m@y>~qA&n+*IoDAd++@-!&$}7`rws8U5?J$){WlUGREMv?ONFSN+E5h zhV!PYNAG>i(q`qya_PrP=wJA-O8%R6h;U3XjP@$d^+33t=u4`%5W$+NO$;s#Ht)7^ zF%9P0n39}^~dug9En`~QCWfCpr9uKiG;P&HfZ(aDteg2S%HIp5u z1V|$spEno3!jD`u7orQgnIaehQ-O1da+p12Vl#tmkr~Q13^|a;lvu06B7!H#jyt2V z6^cM%2)9by(K=pXBgPS93=kWRo>PD}S2`Md=Oq3yFMYA4g(e~Trb#h&L_je^&B;|x zuIVrQ!Y^LV9D+&*(PPR*J=;5YQ+Vwap`PeAVmpDJ6jqX#RA`iXqLzMXBB|t!Au=P#H@-f)6mb|Rlj{tbMLNryItEoAMYI6 zMPftAIH&=Vg_(ol-ovY}+U<|ry}J0$c*p(C{@E~$2qs%j#yZj-{3)yR90f`0xR$P$ zrPUh(S+bQ=P3r8hCEYYNQ8f^YHO<{+?|D1D``hTd7uWANd8|J7g0O^q>s)%*9KXHx z57hq6v+-^7{PsoqhIxGRJiTS9dgo&G&N=&*S@VWD`OkoVHwRt&On*bum7#au8u2(ag^Ur>2`Pcvc(RgAuUan^CQtc|h z3EBkfxaF?i`j+_*{x@%?{b7SPq0X60a6mPqxk*Cn{v)V|9u%%@mTC}9W|Iv_O?TE| zt&`5t;%CY33=FZYeriRxZq?Z$qU@D+M)zBdz2&}}S)otrn^ILd?aZe9@VEnGEtUoQ zvMnwGE+e-DPGtb6ufICS?K-tgNlb~gi*bf8J6p*R22*R@rArryD4*3h7|ev=L-d){ zGAzu``ruQX#72Or$yLY9B-JoWOS^aN+O38a0KD;yZ}jb}_?!s0WK3(LdGD^LDrAil zOkA+OH={0;x;4t`InJVryucu+-#L%^j`fRsQGFFoI4#s`a+%rPqVZ#~(EgEYF(N?oKdnhg40s9Wl?%TI(Pd%*L1QL?e=5pc+s`u8~X=oh7kiK zV6YfB>$OMY<4@7i3=lDZ`rNv%vIk#XxqSJV zXPz0<1G8N_`6(Rx^{tZ%bDv)2DY_9uow-(;mE=iG?P4fbuq>Do4==_->V$jJ;i*Yk ziTYtX>g4)0ag)2nPS3=fs%a+UAUD!YAvU9s+2eyX&|)WH*Bs9dV^wp7iH$Kp9w}r4 ziwSMw;W*TR*$%7SSRJbiG;-#Sa*IPcy*U%h#;e(k{AM!Xw&4!Mp#ItvI*N?SyV z)BZ0~0s?4NeS#DrFeii7CZ4GYAeb;SzqR!E&tLiS&tE?Gl@;<9vk4HuZh0SQypEfj z^XK35|GD#>-+RmOfD3jjn02(w>|iI!OIxWbvlN9sjrP#FYBxywK({4A?k|~g_6vOs zAtiyh3;AniF$q$a1ORnzzgfI+L=+|xrB~E$pCV26%GIVX5p<=LvDR`*x$Zow>Y5g{ zC;-0RQ5Wn6A-?i2tD=7DP3%4Dpd)~Dc6M&o<;G1?rDlxXyLbPa-~7NE-|zp^9$nO~SABCQG!F=-uHN@;m{<>7}Px#NyIlxXh3oaMq{&1r15klEmh(g zpyFgErXzTUkbPmJmAl!1j)W=l2(STY7)Ai&T=4`3$e=U0M5Z!C4%>vLv%tK?X{&Nj z4eY4#SC%i6@rl)V(nuj#WAy~a7!8@L%U6H(SASKq9ugc=$bx)r+l*Y#`VM~fRJ~b> zi8@iOUlsHe>ar+rhK~N?d8zWEzm-yY5j0$A4jnuY$6>tT z(aa;WjkPm#o3MUj{flGR@F`&hV_XLw5hI`r=n~IwK(mZzpgy(c&j zXbvreVHl6&Xp}Z%3Xw4H#F_=oU4IqnHp%pAg<4_-qG2T443_+!1iauDUJI}J9{S*$ z!rNw=xslyip)>c3THd>O#P~66dc;5`Su@HIxDhvjJkrQg<4$%?;FI|F4@=H@$Mm3m0?aJ;D~&4?bTI&pLDWDt^sTU z$oSSsDb|E?%z;lbj3$9{a4c=kJ@+5ie&=T{Zaz00;DR#)B%6?fsB>Q1aLdEH!rOoN z@cey#T#cKw2^io-M9bN52Ue1@4XYqc24EkhSgL=~7_+&#apJ^@CevEGsud^0TD_^1 z=Uak)Eq^ON=6c*a!51WZKT zBQW9E))6~ydM;=IG_b?Sy1NWL4azKzsJjW?XiP0c>}YIs^!riabr@UCH1u0JU1zwI zWVLEo4l$lQdFqjeA0G}D?!EUl-}MK++d44D&&@mUw|?bUepyIfg(0AFgVoh_1(^8| z5h-)Qwz!6sR@T1ho8HAK9XxRGpZ?Q-YK@T#$GJ&!@Xf1U^(sk(WCIHgSxrkS_AU2i zpQzqaW|RuYyL`piwHf6QA}7|aTE(mAW!JErCI&8((vwq9PRC?`%I{vN2=YHY5cb0N zz+e!o8F$N}gEhI)=GYtZDK_H~jMH#TA+F^>L{*a|;>~ItTnMSTaP{K)>hd7Y-6sd>?mvyL}UPCuG*`Qr!PF!e8mqVa5ULG<(${ZBW3Mt4G@9>R<)`hK@Lh|o2Z?l z_7_plSqt;^!*gNb>O5p*(4JhmDTswqfuGyZAK1TN!t9}C3vVu8y0Wsm4rn0r0_ig* zX-L2fqHGnyw|?uliaJ*v+-E1uJ5e62rg@{VHkmU=HLUd{YekB#t5QW4)8siN0i&v2 zpLu<_i-8MMw+G+NtR=ITwAKEl^+dWI(_Mv z{_QUcs`B#sGK~XcY?9yd%@(hnSbOx`>=R#J`N;F5Plu)Tt-0k@dupAIt>KjobNr%t z`g#AA)%wbXbouPYSC2+E<$H<@`U^XVR#H_ZyC(Lp&XpTEYX6bGs+Y8o%KgJ_+2>7k-GEGimt zLJo~a{}?2+e#4(Vx`CJLR~>m{^fA&%A^(Yzsj=$k2{#@v^$6x;kA;k{88}6{fpBBF-q+dYTcvlt9z{Zm!+?w} z3~B&A`NY%DK6~tzTkd%GyWhLIvi9%)!!I&#-Fx4iQmyn0zwq;N(v7W_udbXub1sCK zQdIgL<;PxJSjxOT@Q!!9dv2yS#(el^ex_;00!>%kp9EgyI^B8aT_FTztk8YbikntuYdHI)w>I>3)m3T&k}T%aX#9;KJUm zslV0zq$qVzpqe328%E~3U63(VJ&>+(Vs%L)uS=J&tgde^uWhh$@%GBHA&ae?b=Egt zp8uvdy{QCFQWj46FQj5e6doTva!Rp4u~Zq$TrYv@^^{VHc;{yPMlXv@^b?m0*?H|I zFDxpLPc;E4&-@w@ljx?fbFJExIxn5}g7>V6FiT(j%;)~oul`CR2!x9`XOUt^##T)| zT7}c6$44)~vGL&C8ZNKFr42m07Ef*B)lEFL>ds!EGpCxpUeJz6Qa-M|K6Y_Cfm4Oao4M7UiJE!H}8*!hH19RHETqC zDP4R#J^5Q(pZv<^7tYw{)~j=Xml>`iT_JOc%rfH^Km(W^eh!=|%`=&~>F!X(?CNmH zJAN|gt18YB&s*42(cZ=3U3+HUckjOM+fzSqaQFRdo9DOu1>>~lq?a?jId$H@K>f)M zzfyip*A>7-a~o@PL8@L4K4^O}{kw`F?x-MC1NHLO-21ri zxq5LG!0g?>6nLBKF^udCAGvGa24CG|-)wr!3`AcdBM|0KQpj~qTM)G?!+8}&Zu`AiJjBekkq-nX$tcYPyKVZAQa zSeM)ElQF}YmXk;N&cx zK6C0{|C@iceD(726UU{nJEc_DgUp+rv}0WiQ9yGmE6WmPEqgHlU%YrxvhVs)4<9_F0o-o5hXpI9Bzj!=Q{V6R!6|=>{D`)RS{VbQR{TW6suJLk&`HiyfsX zOc_O&lj4K2m1-i$D%=>2z+i5>&vDkR&+yfH%Tz-GioQuc)gx11iEa}&mPdnTcuTzJ z&4afcY!22~M{XP<8@_6nKX>KRPw*pG&H7eKF(ioUtpaxqjR19~1CT(Qbg7~$9V}it z-;+8|n$Ti>m=H~NkpZb`8Yw&3*l4+cxFb*OXgIlKm1FKYpQ#*AtZ%HRo)m&NZDv@C z&4LeQ^f59DkC%BVGLzAfxmxXMrn_qCjjKA_>N8Y~$;ZiK)RU5tElwT3cTJ%;!EGlDBR!8pi~NM>vFGg>EZtY^L=Qu1CAMmaeYDxlKB^g_p)| zrK!%1t4rRkj_UQxi_1?pCsqeOIkI4Z9VK@t&A-VUxgQQMngx^V(PC^;_8B6`kZGjM zEvA$?2_QutjE6_Uk#CrP`~C5?yS8>yV@4@9NLwLXNEeU7)1TY?o%8katM2?dtv0ak z`9#E{>>lLmvrv7G-Iv)tn#{A&oJ{suGH02tL|lou?qSoj55NH+=1$>;P&;&5MJ6(s zxZwO7_6&Z|`BzurKG=L<&V7@CC1%xyE++%h*Dao|G~<-HNS$>usk2nB5{p(>oi=@j zS6VnR5d|Ndb%;1?7B^3r=RUdi>~Ec)8Sksp5_lT}B*X@rt9<(2Z(e-IA3FT4KlTyQD!LxF@v|om9 z$KHDc91dD(pO#CC;VaUUK5ZG4aR`9X{~h_k2@|(fhD}-vPNm0GPXH zLI^=7F~*He37M?!*|SRsXUM?Tmh`rJOrxw1Jn(?ER%0)D-B(hwE?d9$i7d54h&`B7 z9*9|Ib?U0~-+E;xHzv$cP1Bp>v?eR2LBB$&Ctb|6oA=@>fE<04k#WvAAd7@!!=riJ zoDXDy44`4)NaJee(#&AZi7y0U_;&lv2f~qx2hm4ye+}Rjyzu4G=boNjl1UzUWqOLAnMrmho^MA#+*z%n(vsSzBLOT^qGv#z@voqU*U+P8XD&SQ(1SVO2=jCGCauLm8nJKCLmGpn z1j!&+s+j|D!{C#N$!(!yYq&NH#ymURe17Y~W*h~G(ZvC~8Lsxi%-e={-A)H8u8lE{ z(5K*2xG7yJz2X*T%hbuwc-VLtC-6F`4+Zf94BopI@_= zI8iW`O_O*n8k?*JjuM*{uAUOg;W!YQ!v7S9{~^h-{%ERyJJnx~)zi_Q^{_mOqpc7U zHGzHN05lG`5nu~Ug2Xe`d~RtUAjM%lKRdWP@gSx`Wl3M>^tc8UFpJQfNrCm@BZnmu ztkA8*$r`Jx7rqAgJ>6RK8jcijZoGKmcLpE-htHk*t%DubJ#~{tjGGBZF*U|)0c-*Kj-p40hTltgVVg!mJ$+A8#r4Vp!MRhQq-D>X zIh#w=B9Vz9`J6G8FHJ3p@(#I%Z7Ua=>n)&6A-Yp({gj;246FnFE%ml!m@?!!{b7vj z5A3J9`9&S{ombKgO02h+=^uTa{RY9iF{jyC333b`edHmjnf}m+zWcuW?o&JT;K4)A z4aOrcl}r2f?KjqPcI<+0xqIYDgtN0V@**1>>l%^0^R7DqPz%*!Ox9Qlt$g{x2eo-L z0OgJ>T@<;rf+*m#oaj{GRZ`JT*ZpSIC2dYrbotKlh+++BG*}-j{hD_m;nfx9IR@_` zf^~zK>B6mPqJ%(qg^iglPrxa+SHaEMG0m=+!=wGL;@1ygX2g*l*N#KjddNKZ@$tuw z;jx8!*3}>j86&00s%jKnqG5^t=#_+)4ASY-#b;0{RRLVfYz6vig-BjsoqtAC1wPqR--`3@{9!%4^CJ1Pijb({Y8NcMA$-Hz2JhOvwR^yI zgaptyhMI@u;n}&z9vy$Nnc1iY#thhSTCl>Mv|y^5DozF>nTVPCfa*jsnI=IM(FeTZ z>4k%E+W4oJ!hc%fhgbNiE9s$4_xR@ED;MI&NAA%` zn?S^LX?6V3gjc)pZv^fDB|FM1dG#4|tqMH*yTALpKlGswz4IOKlznn(X(^>tI`bCF zlUHzyR?pQrmtqRz=%@}&K*XV6IQ7}pU;lg0tUOrHjSjiA2&wYpNEp~O&2Zz;TkCiJ z;RCS08F2$lK54FPHZ+o|w`zs&2<&v0OjxqSIDWFc*ht(!v` z%77uGP;&RBFqyw-#4Ke&Ma&BHoxmbA*0++*$?;;psM zK6`X!^~#mY7an}@i)YTBF~&&w@vXPse#Z%`M1{Y@6J(0~Jr#Iprm& zWQJ1w;+z|Z3N=&!zL{h8utl5F;5)nCyr7*SlNpf&(*g z#)OPL<;Xc`lhG>P23#61yu-coEi>ORKUyR-9vg$sk^xAoy!=%C^y8afY33UoIzU&G zshmZE7Q}4PT1S@Hq(q#sN@P-QK9Vpc7z1uHtoyhccrD_xhYMpqz1}>}gL9jF?DFW5 zGi#qZvHX#9YoB=T(npT3eeBfMfBwpu|NW`ezx8bMe?5Nne>=7E2{tRnbl6rLoEV+r^HmlE?|nU}|M(yO<3IirKmHxx`5oW<&EG5md0MLP5)XnHY;=64@*+)_i^QoH$NNels z!b>69*Jq!7?)evvN!PWb&pdnl_=%GzPOdDkNWNT&7h{Twlbp$tL-c9b%3xN$9cim; z?d*;d@1#GnhY*!bGQ@T=HAKo>t%e;X=~2ftv~5R&0I!wnRS}kP{R1y=3sYULUa8uf z?fDG>3D?$Ets^q&cYf#7KlgM0`ak@K|M=-o{nqC``*~%F5iAA(I@|TJ$m_dl#w#mV z&z?EGynN+zpZ}~x)CD9jFUSB2TPsc5o_y-5|LK4FAFp0ro}XVpB4?{iEoU@>Qj#l5 zLXt(9F506)sWc5+(&snjDfJ815Q^|k_qbE-nHZWF*0wgsna4Eq6+5(q6~!to@AAw0 zM$5CSW8*!~Ubs4Y@#I0g`Z_m0VyoFr*g9{{KLL+Eo*vq$SCWZram_tt#UzWe5rqW&M$arpL!f&IaZ-ciu7W z>3{jgF2SUHEr2C)E<}M(KJldL*HSm3l_!;aWwFkxOnqCL?zm2$7ZkdRS_L{0(Z&0F ztOr>_2v`d`QyTY2P>BA78!T7b;UHN}fCdM3*kng`@EJL(La9s`X?b2UcB8wX*CO z3)bYK6>Ykbdvz-2jwc>o%!8F~PV=rw1X9C3z&O!bvKNy(6YW_UBRH{z&u-A?&WwKX z_~t)9J^J^tI)f&p=z$}vreXf-F4jxvdR~~G$&{OJb!AnKx8HXAcYeore(-}I6i;2! zi}&4o-@d*3B=tDaxSU=V01KgvQus4f%S4=FXdp2JoWn)BGJEkW@z?&@V{6Y-x;$T} zU51?xO~CO+eP;gE745(> zih}R@s2Yj4OKWT)4i^BHK#nriYnOlvk@fchwg0l%w7FW!Yx_0%)_Z^I)JawRh)6l2 zwapO8OerBv;#Fm&6gkFJhGyxD#7P!J zmFn`zlgEGKH$L*;{dfP}Z~o@TpL_QC!-tOCbI*OZ-gf)p!$*P-h}8Jp+On0jHQH#J zt@G#3{_+911;ClM$Xa4*D{=a|fsi*6Dpo<=XCIbmd zlK2{vg|Df7(%Fs9XlcNgrC*i)BIg)ySjVCdBnBcQ7%?)2V;UGMWfg89|J#~!)qZ{T z-2Bz6wLiaHJ$31}lk2ZJap}m(3rib5EW3+O!=sP#!s)sT|G>0dh~`r*1sPot}BAMov!H+Hq6XiTd&D`#sNl^nqkBd%?3Tv-t$`vw!H z%*3ZFx)8M%;uk$X+*w+3?}-if$Rm&BZ;KN&*@lW3GAdh|jZU zy((&qrkIrYb~KSKkwTN87L3c5j^YM%>rhwwxfh-!2$iK2f(1e*0uIdjgE}Xb&Cq26fuUZDZoQz zf@h=%9V0?-U>D+y-M!}Ipj3veS|KxwaSAMgtE2HnfXtc0CYQrRfYhPk;@7&_blDT4 z{=tCKSn}k_le%K>z4zYl`oMSnzz_VuJKph**T4St^9%Dcv$L`xq!_<;T%Y-aHwZvX zxp67RX6%6HVX(^} zfX$d1?Lk_+&|bc8%Ku@J9<+<5UDw{T361JYWvx(?9Em~*rFpRyc1lo6zz4FIrj%Un z$tm{G-28lq@zSMBNn0e7X+2JfAy4V@qL_6uWdtQoeJM{XQq+0jrT(hbx$3JjUMZCP zOJTIj$1J(Q42V*POtikZILDAQ5-56iZGGdjpZ(mIzx-eei`#!dQt8@=-WtlW8i>&Y zupr|uU%7bx+&S6Yr8!3~E+Pf}88RV6GRE0TI;;MZfAUWyDPmovD!e-dT?d?^hVz$( z$IIzXG4*kODmqj3ktg~>MYZeW*l)WHIy&jsu=Q0W7n~EhFd9c67!nwCWGgf^S;;FR!rNPFpkKg!UbL1i~j(GlR-21p+f1-Zo1U?@*2D>?mZMGkUA8#beJJxn}hHdE!L$H0bxRy&xmWKr|-%#PzTe4%*@D(AAX;MMA7^ZeCdy0G!+~ zTOlP4zn9lcJY7gxtXUsCA;lOagPvl-EcywqXD>HdO4_Tt$+2*x>yOlP&ks!ZKKZ>O zJPo1YEFlKf-f|SDL^k~vvKy23TrWY1jP*6D*O|F2y!ExUvnS7BN`@JIaOycj?ukoP z1Y&f6HkT%wz=;4I*ntcL3&9W@Lp4DKwM9pkHgM|#t$r4sJ5^nY9859>$P&ocJS{xH zhZk^>l67FIp*fy=@BFvj74CObM?h66|)6493Ai&G30t> z6GNR66Ioyd!F|1#MJ8MT@4fhhU;N@1gAcl@#VMDNyQI=T@ZBHy&<8*ChBv%^_nzIZ zs=kJ0Ne~%h1Q*eA=7L9CB{0Ez6S0m%z6yM_`sCkxX7qS%Hs>N*1g;>F8{r)r@B7I+ z?|s)|W19ry5F#_BME$D2ZO`p>{Cs%bph+9KoW8?c;BKuWvMGUYJoT!Xtg{kTmm+mZ zHUR<|TH4jpi`smToIP_!=*vRL?OuS%XG1`v;AO;^w70+1yh#gRsjuyitn!;Ow3enw z$kHoq=4oj9OLfkB^1IR%pn!BF@l&}<_tSad8=o8Ab=MsaJn*JBKk$H@6N#}mO?dDj z$$dYvvA!v|k3)wJ#Sk?8td)h7(KJodoIG_Z#86dL%f%l8k@1ZO#9YzQ?q>4(VrhN; z^Pe{&y>PJ#b=|V{o5Hl!sdBCGQR(UR0xsBDv>32!tCl*wUb?Q83v+!W9vMw!Y=R#( zZcrzKfN0S;IWQ)Uxht>ngY-PS@N1V>{>7!y-@UN<;fq&J%{;VjFE)T7nkux7pyzhY z4CjZlgGEEbOv&X5jWtfS7iTW~?a1SGT&K}{_t>Px1NMwIR8jn#kvy%~!n^lK*Q5P% z(FZxYaOv{ZD_14%u-ZD5ZTsO-h-rdk)VsT5_AU`A-Av_XG-Ne&apL&Nrt!87tyj4z zqAd_bl|qWHY4tuVU8Cq4Y**i0xnejA{N9t2VAPa($`V3YS(dPia90ccPMaVsoWzO} zm`Gh&Yt;zQB)Zo2Fu+$Hd;H?%P2+}vgNMc^Ir_lB#x~%i9fM2}@<1&(FlY=~Rgw;= z)@?MO&KjyYbj+K}_4*TZ`q*z*i<0*dZ(dNrnXV%wf!~=rC%*X&5azxHxzSu*c8f*nvDJRW@nU!l!2oL}p zK%ez@MDp@2V$3?;0b4|4AR7c=7zPPk01n&$MrX)^;b`)TLO{>#^BFVQH4nuw}=YKApoxk{{FKSj>iHD{2)Z5Fax(z;BTxZ)WHRE5Ep|MRiW{hL$I{=ch>o3~OkKk^hYjp)){Z(VxF z2M&#D9>WG>>Off$FhJQ!WK8!q!r~0}oek(oOo4&NzF}lrSz&1x=V5kkMp(t#BB;eh z*?B}ew3v~>Kp7qpQ6Aa9Z~wtVhm4^oo_ON(U-*LFJ|P4`G#~h$?~EypeQf+V<)max zsqu}H%7qx3#&4<84l<(V0CM+0uR24cKarCTW%pojXk#l>nPNd&J3S< z`e}JQSDFogLDJr*PfK2Wivd^H*5#;hHmxsImN%1cJ2}sTTD}GvKhF`)k{V}Bwn=OCo^h&&vW|oO) ze&xWSFOj`O5MoFMC}DE7BV(PZ0S&O{OpjHRn-<0CpE+G^)e*Qs39P6>QB~VdX#wbY z$Tm@N^+|L|8*$11LWt^H2v%i0YGO*-kREf8K(x{N#s=XeWez16K=~`5K~AiYMtL=B z-8=O^+AVUizIgaA9=+U6CH@v{%2QXF?CGWJggu zLCNkTCrwtYCLJ_!pwIz5XlPxlag^yC4y9F?2qe;=I;7Oy zN}M?FvhfS_?9EL2;H@yNyPh+@C>5vJo$)xedoXHhko6hGgjD>kvVBg zLSt#tz=qj@HPM)0H!r8BzjSFZsP^qUm@qMHB@<`%4DNmNq1DUFSFVnN8;@{=-T>q< zA?S?{Q!&tMV9Py#cJamZKV=BoyLYcxIg3k+d-t>=_RYflg0ZHq>h_Mvn=ct^zjaQY zEQNpKA-r(x_!qwLMY)e$RRf@N)t)_j&3nJ?o5kA*%DR;D;3U3gjFVuyc0cb(D_KFg zGSA-v8Dzl7sW((}LqbgLoJBOWphIfU|#J-6I)Bqc8cFsfmZ zn`Ta^HbU@nQFB-9Hc`?vP04_y4&vT#VqOBDdInOAT%MzVAw(+bs6>1-y2_9#ZCTXt z?5CWy|7y$y`p(+ji%TY-zVX&Lr6kMDw>8A07$b*`x%%{heT&}LbF&L`gY(v%IlP|- z)_b3fGp=$PSyi(o1g{KD#*noJOWpvPj49n{bO$SIHFbIH#44Ts2JQeX&=E!U`^-R2 zpwyxR09lhqV#!Ixh@4)^ZnIvT^{6q6z3jy9MJnPU%JulrhzQ8*oMyY05uzVXf@It+uO`k)uc6j#$7-zq>JZ)lnkl-qLGft<|*`VvASLu(ZZ! zQPwc)Y~|E!s#TN{hqCDF7&7`6n!Gba($D6f{*!<5{BzGL<5+%}^%S=w$1g2XVpeiu zXC%2;gso<4E^EoH9W=(b8fa`mO%VD36yRiR0dS+pROh?1g6xYzxxLtfB}k$Gn|7 zi5H5$e&FB%aR!bZKmO#CPl<9NV|BALrtL9Ey6G#OnRwyCauq|&gz#3kPUl>Uh#wB+ zep4HnJ0P!aF4xtYrIJ)nI_IRK9^m#R2YOI>g}MeXzwEB5T+|;lz7aWi@ZcZ#&hLE7 zTi)`Hcf9TXd+$1O_~5Hwb^qGRDo5>qQ2OdX$nEIm3Nf=@!M=<$7mWm1ZoTzZxk7TO zVvLf=5d5?EKBFO`I@ywZ>Se6;AL>n=QVE2o9vtlzp@ERE&H^YfV>HSGCqwJHr`UI8 z=rgq~uWrGjx0rC`o5buBB2|PAx#H-m>geJ9r}xZX8dmcBd%@fqX;94!khtxFPRW=^ zMgxz?hzU4ORC|OjJya_3C`*|aT--GifHLpG?8>InXB0QKbB6P`6I~+hP@QvG&05OY z+|A9FMFx>dtD>&TpSQyaf_7h!(iAbSv%QiH@DA0kApwybX|5H{-7Ax%Yg*O*o{>^L zdd=U)P%6krTMDclYph5Cy0Y>md?PYD*M5mbn;j9SX#ArYgVo#7K6#>6uT z?mWBo4ZG)l2v^>^Ho7z5>I-it*U>$p+%uD+Gt!!NV= zP#p8ogHFOGD@N0`p8E<^0)r>-}<9}?2mri`@ik4{I$y_YV0o(OY+Yg2xhi}2+N~vqsLj<|Wz$vHWRgfT zB>-5Ea4G+-MWw5}T>NBji0oLf$S)tOS>D4CC1%OqiR#_8v?TEmS2;1PCme(@ZWOl-EgFFhgwALzT-GLg*0A9px)R+2Zw(2P%yo zzHF9F)#$3pQ#sYB9_@~zDQZK48cV>kgiOZvCQO+jkrQBG_8ghe;l=y!xH@N^FcG%K z`yP1`R<;%+Mr)CiuT-nLgp})xv_?E;uGdm#(FGy;z}joIdzVr#QnY&Z%dWR9ZB9sQ zHbeuza!lDWbNL2wIc}R9$~P${--I5)QPP*uxmvI>Mg>t4q5RgWR5@BZGn{Fac02N+ z6V>823nHpMQ#x2(^uGsd&r0k`255FA23gFLyf`P-B8H4}+V!y(|3D=tAgmhnQ%Xf6 z_GN!J*2ul^*Z%5XmBOBD`&{%Ibbxk&N~yqhLe!48no2L+iq;rstWqVj_D7@0$Ogd? zHaPsUJ^fqtlh4eq9!4H2Bf}7yJV8Pz?XKEU>^~?pE_v4FU%Mt8`KwQ(nZKq+IgQwfuKlkC zb&T#sidfV|t6)aS0n4@i_$NMo@xsMl|H!ZZ*+27VKlq^!{-GcFLx1Tn{^fu6&;I!* zKly2a1Iq$XPS!%b0AD|010j1~9#N^9XUWc!or6>v=0U^FlYHja;0u3md};5f85-lz z4_5iL1`ehTy9t`y0e)#1udJJb_bFSqFyXW(<;RsrubhM!HIA)ncyntrMo$QrFJF>;FyJ)Ldk8+pB)vN1Sc1c)j7p6m zVSklQ*jKJzK}6;Kfs#$EYeaO`$(|@->ORd$o?YK8tFW7;S8AVrslwTNCQFRGy1tt6 z77>YJUaUX>meDX%1QT6t7X)rLw|f6wsWKeUj?(@ zOPu%D=w*b^CMYH@J4^y0z4kBwIiN~LfAzY4hujMkccRfkHIIxjvLz{gAVq~fOx|9G z8VVd)1bX-b72QPhJpx2|vm=!1M!6fcAi`SLYVbVNH!T=-W-c2gcLKlnr1V-AZN^E*IcEP zXr??gY9&W~WqnMqH~|_YJ-sRuCI^Is5s-;wBxe(F+A_@rv--ug=YM_U_%E(5{`~6P z&o7UE;qvL<+5GeuRzGvbom&}fuA6bg%n6fE$b^Pbn@u89mq0aWELxM_l?pF!X=1B0 z^%C>nu6J>lCkGiy!8K_@k6k~4EIU;2z}HBoV#=KwE`$el)piNnwR@M;m%sM4uYL8a zU;VQm{#k*){lriF#D_op;pd)x4glH&@vdD0);44`Fqu*;DW{ut%}e)?uU3#v6=!U+ zFey93n6ssj5<#>CZs0cS2uEP5SeB_$zba$7&Is+kfeUGr4c?JtO#Ohn4zklg}` zF=i_9&`-K54yVU-)A2IKc&!faTBY=8!%G^YJjB}v#JN9So<;}UxmOHx8QZ63t|jiH zEFpx<{*hf|L#wMRmoHt?RoHJ3m-5P3TG}OkJOgw{Cl#Xy1{RdBhI5t1QdM|M_ai{Z zLHnf%b-lvdX8rr{3mGOajw07LK6(+sKGfuz_I?bobIhZ3-m}g{PSOm>M;~HTMH{16 zf_b9E7#MMOxHz=UE&JneaD`0@wEx1D{gsB-W=Kz4yhm z2L!FRsj^HW>I_LGs?segoF`W-hct@6C_Ur<&;RrP_|&I9g#eQE$m(1JGa_6)nEZo$^_l90GxNunhs*0U zUJp&ODIzD4FbQTMBuFt+5UG2P7RhR-t9~7&egh>8u1-KU0{WM{q}YwsUn~*2vN?S{ zixl*7pbBB(Juo?xD7%#g*fYt=l2~kFxk`ts(`Qag99V)iIrNL#Q-ql{`j!2nh)7FW zIu~D0%!_)ucmtMkg$dq7uU;51TL4SwC_zTGL7=cfTWi(U`t9Qb-+u7OcOSu9$zQBy zHxA5h?%g{+xcj-qwWn5HFvz8bc>A>eG;$EsqX6|f27^foJBEN=S7l|j0{}84=TP|& zV~nRyo&M67zqGc#X01g4lXFB!R7!+7C6bvEQ|CQvplB3rf}DX)3K>AT06vSTe98X_ zEt*`R>}RY?-hMMPst7=_4gGg$YAo7E_o+^KYc*Sn`hR5LA}{J;r)h@R=_)w9MqUC( z4IwJ`UKwVpH+{(r5$Rkvvlm`?UcK$9a5}I&SPOakfddDb5laIV0H;7$zibBph7i=S zlJjP*6<&osxlfBkRIF|Jc*VjM)Pvj~Akx9T)Jfeg*j21#TehkqWpRn7px9>*AyT9+AS* zSeOkI8VLYRBekp(G8j#e>z!B{##m!3H$elGR)Hc4S1h%8n5Ed+F-y+$`RAX1{>Ogw z$Nu3z_=h0`Sr2-BJD_f1^8odE^|GQdNTkUTV=W^lt<^$S+d`G1F6Hc6x>~+mWt@w~ z04J036);zB-}}ftw>>&PczkK@?5_D2MmC1rHg~3;F`0YY$EFFRm>LJhBIdL?=pr>p z22gj>F5C@RN-6u?O}bQB+euH0njM8;XBr3scryeqUmeLSaH%;$YpiZQ*4b9eWI&b7 zCEOzVTRceFuj;HvLJY@`9skN#zH;j1DbXGBh;>#CELkTZhQ>Ea4WwlY!tQ?0z4u5& zSxXknMSYRal@xfHhfaEAb_n>Q?)?}78w21hSW0LuZqaCcxOMA$@4fZA?jC+{Y3;tz zvRij?Hhv)<`yY;uer@yI|8U~?-+adTAtNcdW7^)X+TQI#R?N3y1|+mnzno#gSwHyDgHJvERM#x7M+4TS2vdp@(##e?X|!A%?q1qdq^-tTTWbTL z8+Uv@($5C1wE{|)B7_ipcLS43nafeinPq>ks!IHLv2Eovrj*(~Smuj&-?dfa*b>;PZg|htmG?EcV29Pr?69t=GFVw#Ij4>K(I^XtQRAEp zO)%=J)I$L7J|q^|W?887KDETuq>C|ypo$4(sQ$LD(xjwb0i}8&D%|OoQ2tp!)crZB z=2O?R^a_hnvNLkIt+A@b;rD~+_0_5Y5#M;lxQT0}dxGfmm|{7TYFElmq(tj_ccd&u zLuet(RGV#N);&s;zqY;jrC<7`@BYAd3!9!2E~S)2VW=;T*947#x+>SCo_d#ANeJ2v zA^S5*#}8_L_GlPL9S{d*#$y7AWGv)nnQna7{*T;u@S&kOhh`>j-sS8bvS=_3lBqak ze0-*JNlZBI-|CMmoqciedg zFi0w0)R@u8=Zi^BXb?g{ASfJ0h9=b#zjzQlkqJa20}U~vt^H!;*Nn}3($&|UKX=cW zky(qTNeQ=}gYmC!nn$Y553kRBX=d^KQivvK*^TnSFy(y-F7_+09MU?dVdh2$t ziL9>bwb{&gmPv!Qra{zV*&^3BK!X>P;xxfF&ePW^1GN3S6`nO6CHW8fF{coAnQB@# zw8tNNT&_SzBx&@wGwP?3djG|RUDBGxkj)NUd&JUjql4v0{6xTtvNOBb$0a=UW47KXqs&CM-A9psY&B3KY zry5fNP?ezf)^uaFl3vx%H%$WAsdG7o&`yvvc2$Lxwz40}pp_sIiEL&P*C=|y${RGg zYb%IJ@pQT~szWKkc4N9IE5h#s(PE^;T0TC`mi;J;V)T^FM(ZsVC!2wOIp9}0%`0(t zj&wprI;Cz(Qd!|t#{R{>@E894pa1i6x@zYJbuC^XFl*Q68*dI}t+FnWN!+gFkotQI z<&jNgT|)8|QGrR`k*^FQZ`I^$vo@$U5}2!_JGasSFaxpxZa~J?NHb_HxCSuf&!*{Z zlMP>W(|hfqdVEDUmU2$|Qu<$%K#ArUa9Xxe*~N|j>ZI@$ioYTLiKuX8_tV!E*rOy3 zrHH(>>S7coh6@)j$RbhY0tjBKXG7HffiXq>jOq&BddscWSOIxS(T5gfQfKJw%)y;N z2bLy=IoU<|h{Y4jwFQP$L*USu5x}Lv>hk>Z-tRj&_nt*_k6q=JDj0&n zp3(l@&+i(4dSlR-d8+4V#--Li9YkvwH9Jx`HuZR;J+|PNOlEih zL~Y`o*G1{cs{a=Rr;6^Rz2LytP&lPB3h?G8-&&ItV_`|YctK+lDur3y8n?KxWR1P; z*4t7{#WFUC8e>rtTeGK|t=+T%3>uxRs#>y8Z+OES#8Q)pyFAB-pw9OM*50o{?y(l= zkEVADRcQb(pIoo_GRXOeV95-s97weajdaW`Q8?uWmfKs;vsF$)gEK=nGpt*S-qz!g zJfpGo?6A7^(1p2~O+aR{(ax-I-Fans@A?`9KO(jUZRyXQl?SR>q`cN89jTvfs^4Du z;OfNp%Mbf8umqslpVk*|g7>k#7e=F;4?^#KtIm zmZGpqB=Ee6r!)ScDbdj>326QimE)) zCpbcc6jMQakTL)LfA`=0;xGQ9HD+Oco`~cH6-cXUpx-%2C*{B5|LYYm1Pn#f7ZMre z@KM#N>C70w!q8G}j6-M9Ipc<|s&?8Y)zJoiG)#22vsQt zmGjRKLP@1lpGyR%Q>wZ<7G&{tbwI2^yWIUfChi2Y(DZ;;RFwW@HjDfLvVaAaCA(G# zLB91(YvD0)ib+Gc&A7=?-dM1!ax6qo3Y?T*G1lxqupbe{Vv~@SwixP|C_x?38xLS* zH|Y{A1PH3VLG`ya?a=^m!kAEB4)qE#Vnp1syu5pp-c}92W#-UN9KO78d9xmYr2);< zesKM#w=Tt6`IVA%aGDcMP~Am97$Got1kCP#tq~cr#%fJR+5A(~GdXSNDbU1rJpLI{lmc^7E397*FSoGh_zYnfrOC~}o!gVW zE>1EjJ{7d>BG{@Yd< zd9q{Zm2hp%)j$z~&KU)!)s+jmjgPccnsF5-7Rf+OmqKGR`3o4QaoNOXZe}>Qu(5E| zUAj6%vJ4@@;fq&2ri()w0o$ykwEr*~Myg!oD{y#n6WR@mXUi@J@e{gRKIIDe&7AomQcm^k?=O5GZ(u6*Bz z(1|vfDe9qo0$ri{%BqND{}B>)8g5m=HFaTL;5cYc5k0 zI95afz%xeD>w#1-THNggGMF_pj@_C=-SSEqxn7W7GE660)2vI4eP$O4Ij>RREIX0I z@C_Eic4p+xE1@kf91dk7^*G*pZH^~uy8tROIfth(=}2qHXq-L8OznqUV$s^(n+!?N zUP73n$fY@jTw=sYTiXDtsdGVq1!&un{0ivY=Fva#>7<1*E!zSa`)KLQcbb3wk z#Ze1H2rR1X2)h_j+kqDHlEFcRq!TT_7d}@;A4K%BVV4LnA~AURgc*#Ss1?8r{GJrESv$x?b=@cw zcauqn3Y{>GGXiV8RAb!j|M_nSNuwDh+r%Xe-;MH99cm``%{fk~%nS9n4(ROk-pH?^ zo_mVSNee14*PvSq*3w5m`mv{@y5_Z7OzqB?lc`DxR^0e<6Jkm7b+}M1tU7+| z1<4XyS1GXqcLe!OjvtPFBXj84OgXb|)N{>MZK%Z`!W|^};FzK&UV20y@RG2c_+p}3 zYFm1*LiJxB??OHkZL9^WA&V;Y{zB4MuvyeEpAg7zr(eqbJ_UNEEY=uEsWeZGG5(`} z^fRK%#X*r054D9-()gCXLeiFz*P&umL9%{uOQtf$8Pf*pofH0Ri)f9_wH2H_wg8#O zQtdw>pADfw#H@azvo)bXz{*q>8l;$#z}%0F+Uq=TczM1)JqXcaWt;``exIa!t#maJTK`?(_f+ z{g(L}aZyIBX51}_5Or0kT%RG;2Q%;Cbi!UAmvU-hHuc^wuPn>U#uO)X9UdWzyxWT0b`nh0Z?M%CIzhZ02072yJ#uBSQd+#${Kc^AMC7sHmL2mpGL^vAJ+Uv#eU+EpFazx80f}Pg%Lk zAWR%X2ohx%lp2wBt|GKCFp{lYZO{S`13PEcot2|*FNA2`_Z{!eWjrPufUJc#UUg@e zb&b(8_j9SKWK!iAG#8T9lJ5M4oKls6L6r__6r5cRTG(O*(f;Q?bX~|%cB{B9|td@ z#K7{O3~6Q}2=>M|d5mL>CP#FdoPT!C7$Vs(1fcQU^H2CNcV%U1oVJMPQn1a)6N57w z5Isjm#1zIMKug9JeGth6^?sa!*9)pG*GiMnl2d0ylh;?r@|``*vWPJs%h2GC?i73RtDOqQw1N3)&*LQJZ zLuT50dgX=7|9q`n-z!DeL*Z8!(K}RcPGtZsrN+J9>{dpVP@6k!Fw`B^W`DN z|K)%EU;ppF^?yrfN3BT8A{V>>Zi*%onextyr%QmE{vgDvjcQgxqN(gLCj0+D>dmQt zZ1hv(WDbC;ToYvaw#bcVOuVqMF(1+(VKg*$M#j0y)MOkWqxEP^Zn;9G%sgxB35j(H zJ9o6?tT$3jF?EHzA?wGWr9XKdRoQbC@iA&eQ0hJ$W4eHCLmbNa00&bi}GD2+>XQCMfP zPm&5xD``%(L@o3-02sr zH>Zq`>mi5Y$&cI0dp_rktfB@&g;xe$lX{YmpY}O@k|L2`4B`;kDDeY z2FxZ4v+BRh)*nYA@=2TV>C+cB*3KC`ZQuk%PP~-I{bDhD81~PN*T*HAmUKRD36eX9zIvsL`mXe*R~Ej zym!a4t~MEIDSR$X_bJBlsD*zYJb2*MuX**MgNLNrP11zIZg%m~#T=xG@bwaPiONu$ zMTZi(Ft+RcYo376iws{HtU=T`^6`5*0{O|w0zxVS$|MT+7 zlB1P(!LB-V%Fx;Qj@At#>%w*fW}jn#ob9vR&xDh1H9*>O0uePgnG?1_+XVO+nh?f* z+=SSKt;EaLT!a)1Snm(4Z{FFU379}#FK~paLx_e^#vcm^rMoGqE$<7umu8x;1#Zy$OgBN|W^8aXbL~9YVI-l5f+pn?IBND)Eu8Shug-u8_ zM$zT!XcfROyaY)yICqk@%r@7K6Jd78BM=~4mq^BXwXwWwZSV(Y_I~K_uJ1auQEfKl zBR0kuXX<&sh@az?e|yoLs-+eBU_9eOpqn$4dFN8-e9)kvHqg=eU{LSfx0et!6q;BU zX7o)Xq@zb}IV=pwRpqn~kcqx1Jp#I>IA!tIs?a;bX{@?3_4>CMCarNfiC@0C6*7IQeNF9vjm_I>XuPTV7IHP z>?5FxlHM5#w?j5jZ3dmHlv;B|CrX9R<;z#Bb-nBZ0p!LHRdv^0cUf!0dO&~~H@N+d z+fSc4ImsKPV2tVSdYmS#VNLE^XG|qq>+;pByZ7vhF(@G<^-|$61f8oPpg&WaE8{7s z6osc4uM4Ijqlivk3~$iCDY=imD>G0k0wLbcz!bJbZcvF@NHL01IC1i1%l0BimPOKuq)`aoqX#E+(TM*{h0pJj6p^3QBTpU*G0Bb2X_z8KNR_HpR zVipS1?KD^>vC0$%V)`bW(hPd~y0UW5iLJ9J^Z?EkE`Pd~F~_Z}jnIjyf78_X0rs~k##TYx47fBJX+&fhJB)rgonYjFzD!JKwR&8SbWr!mSit$RJNCO*4TT}UsKarJ*({dL=DBgeB$cjF6*HSf|iur zb}14JsLP~J0ubroq#aS0)95-!yy%I%W?n<-yC4`<5a>~76 zEu)e(MM$80gUD<-*zw3Uhrju7x{I&Y%S0h1G*}^92Amnsn5$KMA;KfLx7ib#1eOd@ z3?o%QFA6nc{eN1`j26u1ukKD+hbGV%Z^+JaN&yWTXSDB-(nvcu38xKeZNsg@l~hXGRed<4tt6EQ z6OlmUw_OC?hoGym^iFLuG^GiR@@8~F*`On(c%v$m5^Ym?QRak{ZS4NwzD(P>IhQ;Y zE4c3M%G;(S_~eTc41{BQsJ|1Q3ooL<>h zv_MoPrgW2aE(I?l(#6#{#FWF-EMpSHnXt4ME;-J-PY8L-(p_tui+WN_$_@}iQ&%Hv zFCquX)T^T~x4HGICc2QufF4EIVgc7@b*$|1F~7(3&DpD@DZT#kw>=(4W{s|XjmmuR z#!}9qDqUR_3dI8M@k#Ry_ZI!>wxWR$pM&-VmeG0q{E|AFC(MpHa=;WQMheNqn6IZb z){`I2Y=zgszVAP@a`*b>;T1qMffTHO!7Pk-@4md}$}gYW{Pfz)cn)H4!~~(?twc5B z&dOY)o0JW-G8FQN)KLkPWACa)Yb4Tss2(^o;iw2H#m*Zvz#wJ)Z+zn$-}BAi{LSzA z=J&t~xGM6(^Dl&uh)C~8A_HKYtDUX( z?A|M9;ww<`;mRsbgy@QM~oj(sc)YPT?_}u|+H^alGa$tBcbc4FeS$xQ6!dX+9OqSH|NKxwSRXt-DwM@XN4`n7d#d_uPmq=ZyWv`sl{oY)~2r4K4 zCg~!S^_2l0e)yq3^QZsx-~QWwM<{7zSCPG?X}oq;)rDF*o$vhGQ;gCwiCKkjjoSP{ z*3P~Oo&gF_RCANQ@uP9u_-!NeY_ugA6WnjmM&l4;MJ6>H^Rru051e?tiR&Sn_0@Z~ z#xsr2Od_etxQviu!yG9yz?;(Qv*0wd6c!_qf=euUv=~z-k-M}Aywa_3rwDwUb(4PV zos{TQ46(Fzc}ZaS?XOne?sAX4Mn;$3>hyZj%pUj6p8kMqC8mJf)EFo=?6{%ec^u-1 zhPZCW_BHjPAKPDjYqh$6ZL9JDO+y?Aho*J`HeXowzv5r``J=NVYi$VFc!I_x0IX6K zDcpofQR>}wunx$A+6`OdF$8)wC7orR6)$*xVb&13mS3;ZIz}y2&MQByt}a^xLJ@xC z@PWfe4&HX#k;6w0?A<5KdyBi4=HKx8*J;Mq8mnnyZT3hmOH~cT<<80PLFFn$Qb?~n zAUBw~Ry3PlY&g}l{eB78s?<0|o2~|#uF`&=_o;@GD*B4LH|CM_5gjsxua`_|cV>9% zsi!kZNTuLs%5_JX(H-aJ=R~@{G|Gk|_Ru}|+@tY)V{FFQVn*k_O~B{{$Vb|B6Mx&0+J6U z;LNJ3G85`JrYL*jnRDlkpFDAOc?AeV;t$FN z7HwFAyLO2Uv}nl;t4njkbG6%;5ofTTv9{i9?%o*P6=5lvD&ZI)0;99CTxY6k*18!& zr)P7jf3pT`dEz8>AG+)XF&216Uy?r5E4hv#$X_X%Pfa-loD``yO`H7BrJNbTUKQHT z!hyKC)v{HK!jO>rm%sd_`|i8%)?06p+~M-_)r=l#3M}IlZzt6U6mymsVw)h(vMFDq zt*#(qlJ8VzR<%I~y>8^1BL|gNqIxc*_OqWndGc@kjlcQpzy9k!c&US`>Pici^s4kA zGCKzVN(Ew}sDhX!O?Y`*QEX7i7ajZFr%3L^-!_g>Kh%em)JylFopaXC$)Ok=r$SuK zErrmh!N%4t8>87#;~SqEKk`9?jqL$|yTs!ZiFclL;Snv7&?j`Y5+y`5?e%^w`l*zV zk{W8;biajHp4TgHm9ag~A+xct0XZV5B9{Z+oP%zxNR<*9tSMLmJEpi*hqe71xBti; z^Y2-_GFXi%LV$`Yht`qvaXcGpd@91Hnyu&71~~MI*ja*`f ziE|*mt~04qzTRc%y;F2m=9KU)(k=5`=XWil#`QJQS*F@QLo@b;(OqS_<<$*?8id!a2fNs@ zRt2bkre2FE41P=XQOuu6cj1Ea0|d(R66}j1XtHiwrd{3Qb)m>^ zD*z=86*y;wP(I@|<^b9IM%CVx<>f0^uNvc|bCv{joOM2gvuDpg{=`#0Mlx1L&X(F3 zQ!{Szas)AbZoB;!>EVCy@L{2>ADCuw_JX4;gi%?q8s4)$Iy?@y04-*k9h0juZA&dz z%YT(~b;sah082U)Qg@7;RAgQr+yOP2vMBj{(=?*_q&ilXw_XYA;uA90{HuKS;C;sa zn~rR>Yqo8y_g*xj7z9r~`P8rd=U9S<98J}dz`T2AOy77i z#%(Et#yPbxspNgCESf&k(gwZpU)et_Q;ux?^}qhtg%T07$R?%Ue~5w0<=ZY&T|{x? zJ0#{JPn6@v)@D}#mh>02J7TNCvqh%vyQa-qgNsoEjJjwN$cUr5I*YuP0YTA&*&5%u zIbPaoVjJKXPuPci6Ivo{8QD%M<{Dgw1&@>bImGtZr`o(uULFTjDGydDt!y>CRMpk? zBy^BR2ZDOJ1r`Weuc)!x;3G%KeQWI$EfNCUWXPQpG)*M57EL0*={EdaIQ)IL-SWM6 zEbqO#K3r#Kfhj^@4&-@$JiGVG?#<6`tbTfVurXLLb1vD+3^_R@6AJG;uuX(Ftw%~> z1!b8k9xSAgTD~v4sF3GWRh6rpuuw^r1gO$kAaLo@qyBw+?AXulzyE%nSZfQ=hg{X> z!k3mLj=mtfOeR>i+4Ie5?@Z{Z#g1hJkx4t2@g%D#lDXuxNNEZ{tD(86g4e{#j2*ht zpgwQTRNzd{gpQX6V&^ipBXOT%g}Vvw9E(O5^p^OPT_baX+yG2bL*h~|F78SUA>+AY z((*qm%~(Xqk+F)2=-*wvIR3<>N-@grugt~;HLbF3z>Qil1s}V<(Tco+QfjZ|o;k~+ zYg@T2a^-54D^~=;TxuB#Lo9SsAUP@1o(NZ+EEHFXUp_Alc<8>ih4x@2>ra_U~R? z*tfX0Yi^lfH6-sLHC&D2fsL)(6Yq0we%LlA5DcAjxw2SEW(&EJ=3JT(d>%1%#Xlu3 z1iW(}{d^j=WGkcgGqOFmEf{eDV|U3HT^s7;sZFf4Amx>d6)PgS;gcs$NC)Vj`+t7! zpZ|-0F2DlynDu3K&wFLj>>)(aR>If3)~<=xgh+lEnQ1OET zDL8iQm=9j>tgdxEl#tkBB1!0aY;_2yuUivpH>pF(fscT4QPKeeTs$wwHdbXxVu3 z=oy;|D!A55DMbVL(mijL$+v_$6 zOdou4bsiz5wC>lgnyc%3Hx}Q$blZ>KwQ>9Sti7;d)*^dMM2?WS_SN3?-IxFK+4H}6 z%0Jx9ZOu`j7=ts;1TxX2L{Juh3^uCUUy5+w@hfwksOL;X;=KsBt6mZ!RLu>&WD-uu zR}vYtt@q;8VRX(SX=o#5Z8DURx45YH0?oB$!E?GV=3;gyUkK_#M{PHvJ7JL!yt*uU zGw4mIxDwsr2(b(V@Y#0{85E~?AE{^={zRGOVu&kTITuoT(~-6A@ZlpYqSP@eUFf67v}0ok##&J!njOJw zS>KRw3YU$=%sx2sNpcy1Kk9#QdUy zbB^C$A8J#l9J6Fsrjfv_sB`8hu^3~taek}n#6-AwN#yb+X(y9kba`d<%GG6=B}P-# zS60^K8y}-+a?$h&Fyu8OdjH6g!+Ulw9XxpGzI*Pw|Gs+<9NN3IFt<3fzBqe!P+vgA zL=ccXFKvx)@#z*ads+f-RX2{vFkoU1Q>8Lm|E-2;NFu7#OWPlw!U<0KP34tRCgCc~ z9_2>u0l`SA%@p*hX``tV7_#WSEq9>Uf{%UWv48uEzxXHq#Gm-hk9|yRVd~l(TE{DN8{S(qvn2o2KN3;@JI7U!AsoQOue&hWHo%?4Jp=BB$z7 z3?WysW(Kz+%-bURw*6^gSk}v0kdWFFuZ1*b@0%g_)RAcnK1+&8gJgPxW!ejE=V4%? z{eVo~;1R6ZSeW(B#0qDe83H&?hnWvELUwhU;G10X7n&ye_B)?pN`X@>i;GKyG8VnA z4g8a$f>oWv6heAuO1wQ_bA{Mc{K%nV$n-Y6|bL2E&&lubMDqlBIR)Svp3`}gk| zH=Au%v33B-7!0w|*3wO*leR-`2wrmS;(kAS^x1P~&x<3LPaP_%h>*JG^eJ|I>9s0J z-7ks%xXR^-aVQil3RBk{s>_Y^Z@cZ5g@w7}CtiqQeAivK8-vhx{5&r$jiqZ(GY*%p zEGN(Mrn#5pFuQ%OHBH7|B0xX#Js*&^|D(-~%a<-(ICpk+Wmz^w>YNx7-Gd+7FG`K{q=c!-X-rWksYEX&P^#(^1b9O zD>^aXD>*-!fmO=Jl?A!;JYqp&Wf4=_gGhJ=6ksq4vJLRj90DOqw(5+vUm_r$yzZRe^3jgW4V3zh~d>T`fnUwaGVI zo9mL6Oerc;kZQG*w3%MWlruztxg1vuOi1arw)|^Pop9}$)Cij@wsCwdWfupVv_a-{P@KBy!+>it`56SGe~a+q8+ z&RiENE+QaB!e}^`<;FN>@NC)Gne}=N4#6$&zIA0`V?0Pr3Wf+na*jNQD%HEg()jeo z#gANoG1S4Kw`{3G>ymLuTR194Jx>=cL;qAH-QssD4k#Bv*#)Q+WGa)ltK6=|#anMV zeB|(ysULJ5huIrZ~fM9KmYu3iL}<$Kz$Rd_F_mr z>v9>aKZq&aphj2EH=4ZdDDO@T$rxqOoFsw!zhaE-m+I;SCgul_vwh2vOIi8Ljyke- z2;WI~hi@qZ%8E1B87`nXi1X(!XjITpm2U}~Sz2vMsd82DL5tM8P8+%!;I*%P?WaHe zDXpxG+SxZ>{XTR;{|-^163&0*(Z~M4ANY13y|E7RDo=2I$x49;v1s(CpLu$Hbsc~d zwkDc2cZXx|L;fWB%4#k$``i+*NgP>MaDoEbndjM*$QmA_mY_d#Ce zl`}q!4W3(=KQZ38HBthC6kUX+jnVzXc{4L}#d6G~Pzs(&WjpJbFBQVBr9K=ruz4N# zLzhVEQmno3CPV791;zw1dc=-CHoIDYx*wt%270mk)CVaed&h3a?~`9#7;Ig z*8i9P<$w8sANYZ{zy0lkMUY)x^lM=k=NPAZyWYUK)~&&32Rw(Dy}-0JM%xAOP;E5@ zUv|yzz*$!qJ>iv;OiG`yOGaoS!B{I@8-M7BfB3@r^Ga-NsD))nwyrep;~u1rI|puO zV?t*t*H?4Kltx12u(~QeD6KIHfdfSAD#)k>?JQL&@NzSI{mV&%KPl;M?hz=)=PF|> zJmQ%XB?b(+?4fEIw;GcI2jG;0MS zx~c?uZUE;ru#;R%bD&@kng1-pVS$=<~6T9dh}_%k@cjdeASi2r|aKfv_$)hU;NTr-}>fV zyB9S%o}qT0r>v_iF+@a)v2C#`e}LrgLkJ3evet5%XmMr`)e9YBPC0i0u=M0X+&RUK-FMzGKP%x=^cImyizCLP3ZKM*?rMh~mUftu_Mzq?hYIE!E(Qvdl7m3#Z zqGB=hUP!4>v_jH}vf*lavd5#M(&-PFBE$vN!~kmGmhv?PA|j_rF9$T)gYWocdb!*( zb}07MwJjFXGtV5Al5iFn%E}g{><%08jX$Qs$SF^ zHA`t*p2?rc=o~luJuRSLXfkm@wwmr?Z5h0{z}`wxoHeh2vMZ)%W{8r zEs16Zbt&^#mg^Dpr3Y#W5d&ZW7G=1iSe+}Y>&{qH8(<9r1_0e~Eg@QC0(l~W1eriM zO9)lnei_np=nz&1?&>Bj1Mf|#0r2DT%m&`&@cfVf4S^w^bb3e-y-mg>qrEXxS6(5b z0Qfs#M-Hu~SPIQcgSbhqz2|usAnnw)ylov?X=Qf3f89T$iF-Ej*H{>m+TEl?sabua z^63yUO+FuKXDlV9Nx=|+jT>eZ=K*eoL+`zPZFY4Xml14?IH7?=sAxE|J{%w4I{xXS z#@j)thd4-)(I6O1m>@+mCL|9AzB)nOs7v;T6com4E$cp@&5@N3xz6o*BTkx@Xo9wcz^$?U z;jDhJh;G9#9d*;lU;Ju*UE?&GSFt_zwTeY5RyCwWCM?t?e8L?QP zyeTEUNZes2r@QWFQQt*gP0(8s-Vu;{MGA?1QOYW1o>ENt zsBSrTHDC-cS&I85^KxQEmw)n;pZqsJ_iz5@-~5~Z`rrKP=bn337s!jy8Y=f=zM7My z%cPEcWnYf-KMtmExwChXA&{lyNe+6AfjhE}POcQ6PZ|HkY9rk|s5)-2F&4T=|nk zr!=IRh6LDgc&9~LYYdd>mORK zAr$HTKo4-8(Wa}xS|i-y3R#6L6muBTAgUoC!(>8Vtv9vS8OkfOH}r4Su2brCwzS*1 z^j36+D2}qHWZfs?bGkA1wF7o`bSY0yS&Bgpzw5%Ff0rg%wQXP11Vpp4ytjX`- z=!y}=y=U)U84?Cq+O+P-;LE53*5n1J$@^R71@zFCGo)T>oTJ?PW=U30B9x^>@q z=bh?fLl#n)9A+tXAu(?vs#*$IOV?Cr0jSzfMPy5ktqRZNUh=&naYEivw3ID$(-^ff zWGoMKYLZJOPk$nUSm;pnZl7+PtV|bE?MdibF+{lINY_fA$3}}=v~ia1hB+MVI3;JT zY@PydNt~1~91D91;9Ym!vwz(=qU!ciyvS&%PLWd3nX> zAb(aa)(|JajHe&z8eBBODGUAy38mp)t0 zn5EY^cet+F4C%uB%%Ygi^&q1YOh^y{c;7KnW+|9<1}>bbd4(BeFV=P~l-s12J>vJJ zaG4Z?G!m%hvMFHj0e~yxY8n8zNE}Q=f*Ghb?D}f8xw#m3|M0=3KeTV=8}@EcQ`@0w zh&)$mSizj*g}IFb>;HUp<=QF-A&xVhV&H&C`THrm8Femog<4&4`s7c8dGGbm!<-tmFdP zMwYHnmLZ|j%4c0q#aJMuLLDcf)jmoFDGFQEL+td3zL6oS+X$X)yfu*tx%ajrY5R<0 zoKo35x1~T)ouNmSlx6CXDd57C3V*4K-B{ZnQ@2Z1<={m2ZK}4=d2T^!19t76Us!zZ z+2>fV*PnH5exuPSPi88y3C zR&Q_8FlCs9vRmi$PEuHTJGi%Fb~bkDC#{X)3;a!um2J&)eFb%7r)cwaQff|A`nO;o zW~_WH#aq!u&Dkg{zO1Y|NwCRvlepY-&pr3g|Jgq~apEK*HseulOqbera$9OcugS5= z60>NHJusJ2^4vkcmXj|lL3~aC{Ce)-8fOrorsz4~=mM1{k7N>UI)iD9uK7?Fq{{T7s3GB8w)&OUE9XWWa`uS|x)F-p_h?J>K@?caLsQD|V$Zqhxs0L~Ck> zW+n{wtsQ8-;4l8lIkRHsn^~7^VBet6J=Eo zBj;025W03MWorX0q2`SGPNUod)py=^X?2=oNFr(+jQT@Wc8Njts@p?( zur%l{NrhKLo#V9wu4_V2SHg}rJE+@IX>rG8A}F(&nYo7^dKi$3Q=^eFg_6m$nx;u9 zP1UR`Lj)nkl3`kd(SHJkBFR!j`pfP|HVnS*sn#utJSMl8J zj8vi@*neR6uKC?dGmCRq_bjg0W@HSY08;quy{&GDXbz|5&RQRJEvjj3DJsU0ON zULv|BL&-akXfmoxr!SRyWXw|r<%>EddRYtGzcJK{5a=PvQFXjBdkAFaz<~oNPMrAY zM}I>+@ElGVNkf|z$@HwQXhuupG1`(fOQY?O^%Y91B&CKi#v*+EM43svZ$dAmV1O4eONJwSD>Xw2Y~8slw`_W6J#E7tIPQUK&95vddSO#T4>BK#%LAOHAaE zIR~}fzvk3u<+h(|HT&#vPV8hch397C;_P|buF0ICG-e!kkH&kAJz(rCaB$XC&dJ76 z+1eVbCSPH(%orn|N6QnepT1<%jG@XYNXa5l$$`I|7HZp2`>`I%DbjCuX81s!SQj!d ztHh$?_@-5S0Fpp$ztN`57<}@GXvij&5Qs5R+N?HLc5mJPhhMY%n-82HUiMW)#+hMF z2FW1-&hv2gTz%^2o{68|oH!RwA!+LcnK>{gAXny&=E^&L5j*39XH*Q14~V)w93yzoYSK*z1XCf=1XU_RcOd&<>q>f0xrx72tUdnZQv#Gj>#~s}4_4|I zRke6Dl0k2y2Qq{J&XSv(X%6l4wYdmsU7it>PXKFMGnbcdm1b*A@F7jy)6j*_V`*DH z)f_Kn;cHp9whNdSm`lm{U4Q1w^hR2RvlP}2C1KQzEI^-lwhyjP#u$mOhz{Acd-qdM zi##Rt>H=f*-nWfvvXQNCmAer(Vz!0oa~e`(#kO_Ia}Tr(HY6oMK*TRr*LRc7AO_uo$QRn>pFmt3_uwM(G>oG#Jt0%Jh=%0b<+%qjRM66QcA|>5ACRO!3LCJ{K#$|e9x^%{_veA=g)1{n<Q< zjIw-_A?<`&eBPE>+E~tlfJJdChhpOu3fGb@q1w4!3j__k>R#39@348Tge;}!l^V$E z#pJnD-Cf$N7txr;S7BZiG1m%VPqbPL4JXJZjrC24DI&my3l~zFTm#^wC5O8BopsWE zPT}H+IQ?Gv%xIIr_kGK^N<(yA>jeZ?7$3CQuSY>(B)#>wz$ixsOT`R|h7GSp| zdB+%&qWxn6W1Lt&xpLiLho3WK1W_dPMKJ`?M)FK!9g>Xc^m3XZIodtd+*K;oSmzx`Qh=} ztT=QQ4Ur3B@A~>|;sJtHmS6(Nzm*76$5%UXp$h8Q6vjFDpwd=YV#uu2riX*rtpvE5o; z*jT@R^Uj~XfBoL^Wx6`1=ovil7{7EqFVzd1^F%g!Ajo=@iGnq; z_DL(&BVQjWFCU#>l6S5d^deAv)w_MlA(hI zM__73o)cHD(wkWSbiFGS`t6)mn?(%-`Np+_DrbQ~lf>2;Ni}7aZ77SSe3uwD77PJ( zBcB(5eAJO3=6sy8(kAUV%bbGuoC@J{5>=-C*)--alQ@HyU+w3s!k!_o$u#I%3wTi=>E zed&u|Vg_+S2@M(b%x$jX1KmC--`=?ttvY+=%&oWHCNkkJjXvh;;#@M2@?-p&&wMU~ zwAtd&##&sLVrnZ4a@v&(36Kb4l?AiWAZ{EYw7HcSsW6gf<0{j4J3!2tS}ze?y{J)B ze<5_eaos2*@043ri)iJO?rj+j=gyu#FEL_C)vLP`86@C;@!};h3?zz)NOC^2;W&ss zT0_=SV%Qpq@#kaEdd6mHaS%rvo9n~I4?J5&8V4FRbBs*pGC~6!LWG#IPsnzhnsRNbm;ptm8GIB@ayN+mQKGOiU12pUsR4ynYc z5I9@s5ZZ>v#*o-bYc1K|viP-aQHrq|NLS;Nvwa|!+xs9#$pj5^(L_$l)UvKHxAQSX z%8dd5(fdhp8gq|oIU%C%!&WP!6z36RaSVW2Co(kEt@IX};mcJCPPeKF+oN;pwWwbl zViX*Qn8Kg`+~*{bFBTFa|f`fgJ=y`FVdXnLoK?t3qzL$3lC->6V$Xt9pA zM9TGLV9AhrOdUeiwD&V0gS;xZCwquD3q(kRCa{{$GKs8 zOg?fmjvQjrjxQReY=R%lB=ICklvtT}WNj16%IE+aH4;J^-;<0fszB|i8E zjtpNnzv5QFv0;t|C*@^;i?WC=&7AqvsjWvhXTv;?So@t!2&!46knWVm({e1`pYG~Bey4j{Qx)s-k_&lv4P4QurE0dBWR(+hYt#kgmyF1z;#gsDp;D6PCeM!kRsMO zQr5!WMO8lbyc?Jhy!0_@iMPMwyT2U?^9E`a2?E$%QOq8;Zzc96OeE$=eX;WKn#O3H zt%a-U z=tk8AIi0gPM(-vyS}y-RHKI{MK?G7()BNg2!GK6$NSjTW5WThND*N!mk9_Hi4=HL9 zktXUN4Fd=*{u|%$#>7zHB@3UrHL2`NFvmXuN7o zv%WfP!fb%bb4&;^E^=zDyMl0)fkH@$W9Mgb9t2*HNcVEZLa< zi+RXYojLtI0KHx%q1KCw<;hexs+42tl1WG@HNNRbF?Esa4KLkpa{8u`2+HM4mtu^! z-F7Qt%L1fTiyg*wY^@Q_{HF1D+;NAp$XIJij5@2Ur2cW%Mn>iu)XnFiu&DB83zT0M z?)~%U&YnGY?!@t9=g-UZoU{OV{<-I*7o0Q!c<`ZzB=7S%kU#9qXT>hmSfCub zgq;j5`n;UPv`v$5E@zu>465HDlc2gu)m@JHSwyT{!IP724IR@l+fK1}K&Q$Y%tj9& zC9-aFYj+ctB7-rI&;XOArXHM595Ug*Pu%zzx5lyY!8fCz^sX^!=u&YW8e_}70V~Wv zmZtrsG|vAi76}kEm|CjIw-?wc(yku_xO|H`&s)v*F?LlX`oHqH6}7E*>ka)_=oJ5? zv4K95Eh2|R=r~d)JA;jCJsje}>t~O=|CWu#^)0vQ!LuTejB~*(gjqiB*B@HG`a8>T z9tPvecm!v=)-+fs3i8dC`X3#Oh21aWR-)PbKpEEw6wwq+@usKPnTkf&ur@GPb#>st z{#%Yn5mW9$sZLbakPH~ekZz|cF!dLd*D{lB992jLsg6_qnQwNM=F2U1TW=7uhM5ba zOUhAn&Z0G}Qz_>@aZrlBb*duA81+r37KG_S!HVS9vR%_r#Te$wpfgZes;v>}z(asg zdQ9~_C)O3Gd^&m=6$8i8IpdA(_M8&JKgRmcdoblNY+@>b3{1s3U#Dkp*T z8DmJcSImAZT-(neX1!QdwrQfP>&A~Y9pBrkSa*0WS{u#|-}kNW`^8`Qw}%cN>h+93 zRWix}r#eWKF(EQI>2UJkmmhl1d*0RF^FV+~VT@uQgpkB<9%VWaV<7}0 zS6+4#W&>4hif+rmA19Nfn7G6_24YbAPH4~v!G|ctQO;U@PHB1}vydXhNLh@v6oR7j zB+M=j`k8ZQ$KI16&Z3xzYS8|*PdxdQ0gP{X(|vc}&cQFv&E(XUi6SB8?7&uNLXa+nDVUr30(``RY|6_CIv+ps4n$uD3SZD*1vDi7CNLm%{0* z$Cp$`=VMyi+N>&T2xClNARe-VA7`xY!sLV|jwl<(2&8@%wdtP^L zZh3Wf^CX;eoUEy0h-h#t#l_K}$HAl*V3W@;AA*wy>GmS3|KSRQyJIRW?!4f>mlqkqM2fZavw4j zhdyzVw~@_11aDKybRRK?sk2)ZIfd>wlS~jSIlM-l=QUJ550n0JA+JBZABvQ^QtA+2 zmMsBtidy4E90Hs~F;Zv319DQGNd%gN*I4m{q1qa) z$J5ow+0f?DQ^{)iG82I6DlNWO1!%~Uf!wXO5}$($i5*bcR;;yi^D|^H)3ZQ`$lTQn zW`9&8*m~zk_;hxD_Q;VVY90Y1XCZ<@%$fB+6JUq|a!(r3rb4@a|Eum1Y+0^;X(&e* zB!Z_MBLw9pZS7MGz?ip=kW$n_CPm>jKC~(%Lz1`#-{@aPh+NW5*6IggkBEgJDmkSj z**M6>;z(GzIuoU}#T{)ftg42Yg~mEZ-A#!|x}1tLWDuiB4nJ&dY^|-g{dpx3gG7=$ zkk5Yf=+PIB9eenphs17B<8tEST!VE$xK@e>hQ$T{szjG>Y|jlol_q9o{o@)Nqp`j~eu8 z1PN2p*gJ<53hYq^k#&j@%D0aep?Duk5Q0&kT24R-h32nP?!#XVy~}pYQ8@K2=`#MR zsN6FyH3UMNur@BF&^WS4oMNQ7Rj-)uq38CUA~aQsz~Ir)$PQ@WlT0ywKAeB*M7T5> z!Yra8&iN@<2edA#iLsOZeR(`N+b7hqr`F4vQ`eUW6O-IZd-m>;$`oTMr*c5nyf!%M z_1ZQikI%sUvyLUA&|&Sc(;bv2s?N*xuc}IrSh5LF2pT?z;8Q5={h4)J(It}l((UD? z9!?2OHH4nF3)EyB78byd$x?n@Q|d<5Q5Pj|50me#HX+Tac8j3ekql|(fDnz+?;)Iw7-RPuZ!-lv27Bl_FltotxDTDo<66(U84(;nK%H_Q^~X zIMCF99IL9Wj+0$p8ktKEX~9AtKYsl5>C+PDJaO`*jMHb%hzBM+_-5|3rrA>@Z0U+J ztEK9x)B`Q%G)p7;TZ#|0IZ7r6odpD~M98&pYGWpOK=pLpN|k$>SAq(x>Pj3(Q9@B0 zU0`k~!fep!36bxfd#|}Zsd23n){ms0hrNc^4-oaXDZxzeHI8q#`XhQH}GZDwN@u-hr51SpZ7y! zDtS^$FtTxJ78e#pGW(b-C|S-j?h4ACb$XMYzi>fX-b(A+XP;0J&32Y=v$AN=5V ze&=_*=e_TJ$J^iW`Zv7c)zX^&zWeUF`|dlXt=?_7-;%pT$x()UiO4I+kM6nW-uv&r z|BY{Y<2Szh-GYPr;UD>t@BY9Ce)LCw^v8bu$N!uE_P_nm2R|s!6u60XuAHH-b*c1J zkCv38goxTDE?kD=oF@WI8hOzYL@K(hXtq*@0t8T7*&iARcodG_$ErF|7|*w%)RF;J>+LcyMkjZKNut%AuP>>w<~4p(7Xf z#h+bS|Kep@g^FwA(IHXi*a4C!OfLhqc{AK8S+b7dN&z!|#11$tNhtm3bfkF2({I(Xg6w+vje4Z5r9a}3eI+1w4H9mYCU zc%8u*47se!P4(`b-eule8$RfEpXB8S-u(t+T?% zE((~L+u8wy9U|4%9Uxe);iG>UBv-wX`Em$t+l@KvaMwz_fT9PEs)iZq1BDbxt7C6 zUL89<+xk+>>_eb@K15ZCgMQ}hIdK8?6-?&3(m;*|22zT-?b}#PjmwuVOH%=XbIZ4) zjifq0cVyXUaxh_Y-0rx(Nli2IX|%oxqw$fH11*U$Cd62iIcKOLhzMzNBTT~Rtlg%I zD?|A!^Cb{>%e8-prykKs)Mgr`F-CFuyS_L*2F{MDx3jACrPOED`^GwJ$mkBP*Jao4 zU3>TLZ7EHxl~t#ap~MLR^{UmCi!lkNMwF$XWTpN&#wba2>6?D~%&A<-o$?J-OSW5{ z5MyZB`$JILI9VTBt)8pE)4@XrckkXMW~%t{cinl{t6udgQOu%+<&DI)kfNG{Qt~h3 z&>?wuS(#-+(Izzgo)B0Z3;pV0K60EdD&v`M1Kp9VH4=uDHxkqD>XoZ<3jnb9K~I`` z>Z(~-ZU)QZnw9~levz)aVAZ2y>=n*S;==j!^UW$^)7M9>#|_&UrE}J!rIROa5+$ zlYm)@dfvH2t&fM}saL+92>ya54==0l*Ru(0*W+QygGE`R32-mS$dS=BF&tV0)(IM>ctFaV_1diiTh?nc9$ zJ1!f9n^5P|9k+YsY57~!3KQoX16yO}7v^ri{nmT$6PC=~-Z!PaP`20g6{rNNOG)_@ za1n|hU`Tyb{hh*gT2kv-?~t)p;-JDhCF=aWdPl_QwNx}^ivqBOTN5y;rHE)0-ku-U zp*>+r>v0y*{Jh>~iWkf1n@ItEj1hqig2|}w%Gj>lT6J*ol$cC1RO!cRM^4!m7sqz~ zd*{JZzu`M21o76rBt7RT>3?bg1T4hP!jme{y)2_dE{dymJ zeJN**BCwP+P+wdD5HaSP*Kb&39(nj7cHD)Bd_3kVJv*(^v!6~&qqRg+x$jb>y)Lmk zKa#LPvZ(i@IJ9Or_PMmpjTKy%--9L`-7F0H0Cp>>s%Qey*pL z>IeWINy<9#gF|5@GP+ z>8GD&MISDA@rmc8b*u=U>X_*#%d51|O!SlbbEQ+(1Vg)idVgs`qc;})Pb4KFLY)fH zn=U~%Qv3q~c>rSS!1(RGH0_V5U@F)qqXoP|bTi{_j2-4i$gh*u-n8f=s)>z~!z*=v z%G6EcRF0z-J7pjp#ps?pL0yYBEEbQ4S*$D^lvF1D;m50(o0^Qyof4`a5Ny{y+&Ka0 z{gGE4^eJ?C4NrdIzR|}wwwHINc2X`D?<|@DHS4fCyxqhXyPa>{UcR-oiYtO-oe8u^ zqeDP>RL@JW3zTZrtbA!5esNj+TzUcjwC;R?1I`f6&TqYqP^n)I&Yr#hp$G5hyj1%v-;F|)W7J?^>yk?3C`MLD!33e1Ty5P+@xF%RwhPEM%+>&R(dZsy4f-zE9JjF_1Zm%XgGWVcweHAMB8fCWyf*x{Wzb^5Dc z`x@qKWRjsm{}xY8G-#~)OWQP-AiehL8z20@``6c35kVmWD4iQFZyK=Nn0E`M81{@> zxs_AcYHftmcj z(rEX*F&GssiyId%OuDIJ5A7UhRJ+kRqe2RN6F_E`o`2y*OX=so@Hu|N?8r00q!*U* zj1f~Jgk*B02%WVzynE544-yPPUO1ym{lmGro&8N~&}b&Dvot1J(;BT)&Gig4w$<$C z9zI}ktPN40tfOfod zn=zF(F6H!VzxHddzWNGty5y9=C@u$bRy73KrT^f~7{j={rFPIwyFm!kz9;hNkqD(G ziL@|DuV;dSi(*XPDqeJVW$DV+&I5*)0GdozMmO#wyx{CrK;$K37gHp18a!%os4!Cv zN1|DPj7WpK;r>&%B!#I*T%8 z?^14Y_*6T1Z1vXRF}4u^8{@%x$hqmlO5A+sYZr#^I6rAt+?sPa#yxOtHma`%$>t2$ zWba7@RM5<8!S4~Z{Wxy7pVDeZuJMT^IS4fKFHHBr!7)e4EL++YNJ`R_Qpq0V?O3x= zLXnle+JPp0ZDfn-hCWoEDbF_V%vItL!?4}S0i z!3=kUw$Z%2wn&d2J=(UdXv*!r8+TDBMXjO)yiFK6h+`HxF3xawTTzO7T-AfZq z`*KD~Z*v*8kD^ZMnz^tIRn{Qy3_#Zv-%|^N?A2v|2yl;Ao-?cU%@!9l=JTX zp0)`{NNlnNvZT4bBK+%4(qNAFIVY9vANYMNEWp287;23vLq2^MF-633;-E=r0C$~# z(e_6yoj@FtU@VCa5gr4&0_LWSs@K79=YwCIEs?bjBma2J6jJ?xeuDb}St&;;bx_}f zu|hYbJna&j=unXBg!CY_N-D~?bs}PqG8SXU%p3zdyW2N!T)%kXBDc(Q&ir5_dGl6b zHQVNMZF=PJk)wy$yK{ohmQs?z7{^E)#Kh+S4~enY2SVjf)0#FX^xWL&`gr}?&8@Ay z6DLk_c|bsOMLLK}@iHg!4~ik&0600;Ap~YS{^Tb=`NE4Yo69$~23^{iBP{u>8Tk_Zu zj$D6ox)rhmDmBE3f_am$t|I%Vyb^7f%Kp zqH}(TiLB|-ItAP0A~yP^JnZ(a6*zKsAXxHN(Zjtd1c6|lQx)9z{#k?Y9z*E zqD>f>;t{j*O2UE#AwHpEWi4l*11L{cR(MN>kit+>Y9+HJl!kU?#WOM&?X)$eK1}P_ zm~2hWH8G!O-}^b5ebE;f!99x#cPAn zyhvG-Gb2nm%%#Szu^kM2a3HZ^Jvf}~zVE50Vodx5#3J8mFd6Ah5*4Q?Le%f)YIW3QD6&!mz;|f?p3xGnI=|%1 zRZ(G|RT7(~4Qy>A8;t>zl_yTB>I+hn?@jiicf+3^woOo9`CcHw1KF*i`rD+@Dq@~D zeS>7qB+c);+jJOD{o?WIW*j&D&R{oEY>LBZMrpX#t-Sqr-?(*UFv3;uARs~}3(jJ3 zRWW0^geg0+WB_F@B^!+(tR+i2SM^ia?+G`jra#v9xA(4T8`hv^ya|^}L8`zD98G0) z$Mm4%?S*t-$wlg0TbN(3(AmoWs(x|C0aXdmrOU|)07w7c3Sm})%%*Bg!Fxrxh-$U! zs#ycsTB~Ko8J9cE$!W8WVL~z4#o1&+u%J#>!_Y>Zw|+QpY$*AC0N?$3Q;hQ!hiF(&ddrg^_fwK$W^K<^)HLxt-~I${Fs$o1&!hCmhqLwU<2 zVv0u&ALTB%bCzMi;tr$0j$F>!%ufZFwG8fnPPD!eRBig+cfa%VU-|;Sy}p~KjH2Tl zRUb!~_?nb5>)^d}?w#w`ud%Wt32RzRi81GzAV_~0vhb*BCx$zD{5E*5$XbKhI59#I zkI9kgTtixOlnjY983(w2>!VHVM#op*5 z&;FQY!K=5=pa0-9A9(b!$3hdhhJ4}D#mRnWiL9hZNYgACl674>yg<|Yps&f21^J~y zXeeXfaWaidMK^Voy(t&=yS`^Ve$~>L-+$)5rOGo@lh0B|_0(7CwBOuOQVpH-imnRg z8IyHhxaZs_KJ|(3Kl^<~>2pZY_mSVfGcNa8NtE9m+AcEhf~-kjxsG)GIPP(4-F#*h zwGb#JbAv=21v8Vf3=~)^k7#qy$WWjJ)}V7jgmR;yC~+#vSn36Xrzwp@eYFw6+7sSh z8#I?ajDu~R_k%LU(3Y2UR?O+CruxxU4_eNly3-^O)BuYXq>C;5?hNO0@QYshfT|$f znceF%)W<99)_i8f7+yP{DH-X@8tJTQ4A3`S^T5*R;ic)>ZkHy|ghbhcAErSVw{$7J z{gpSu*tR*K4y9X(s*THpX7-n|w#=307iaIQj(}FRH2s6sNdNQ4vd~vN%}?5JFs3ri zY41*Cw^}YT@ipkYt>`heT4$|u@MSS%)U2-Uodbt#HAU6M+=abv;Xx#j=}Ic@oIuDc zV0WZ*2&(1_MK4iP%+-0ymRgx>v1tH7r-o7tFx-9 zPt=y*Df2ng9#ipG2sA9*CTnE}#=dPEFsh5?kW45!ePO8N49|u})Mzrh1l}a;`qD&n zn;V;><&|*(=62S5h5giHm9;=-OrOzYu%@;Zw6Ek+-yUx4;vy>V48YJHNCn~7TWU`kd<2m8X#JDuDsIau4)%NvB-K`T&dm1Pex z$*Iem`-tT{5%Id6m|_z=^Y0%$a+F8I-?{Kk*B6Nd-t(McrQZX*b|9rT77nP6BV{FiuohzJ6XT?ta0K}WfAJ4K|Kf|k z^;=(7;b7T^ay<$-{?3U5@vN9DG~__({6J|7fewhXDd1G~<>nmV%SPS#d>j z=I1$}I8)B01DI2m2WCv#5_TZWK^s+$rGB<|>88{$jPBY(CRwr|^$$cz`m?Is%-xO_ zsA|?;vv33fMa`Y2P_UA4PV`Zcwmqdu)7!Id?Mp|tnp=BzQl68{5-zXd@`b6(*EQfD-PiD}VQ_=)E=e-ov}!L4x~UO*h>ivv&Ag zJCY&gj7sL3SO~sy70&09GzG1+V6-p*BbQDcP^$x9cbZNT>Z1oZf@+qlwReS|yU%?7 z(@5CG4lx@dJ&Ti^SX`7-&U4J<)O$)M(RH0p>xz=cSm~WL_u&nhJ8K-9nGJOhhQ2NN zt!qN@mex{vjtiP_2k&b)NruXFEZS>+>g1syH0}y7QqQeQhRXhC)u)r``y$P*An5&K z?9|44oSznBaCFCu%Dn2>l>w&!bs0pLa=-PeS9)3RGeY~#H{QB+ zYs7 z=Qu?xz<8XU5S4dXHh~wTYsFZ~bNa5k@62gExA^|fVCFYpe}g$Xc+Gb4(nXz=K*BmB zDL%~;L5gK0Mhou%rU?z#>IX~1Nze4F`vh*#F0CxDdgn!FytL23dRwS?SG;QzQICnN zjLY}QfjxZqC~J6iF%pnPurlQIJ3)C3PjL-s-L;O3mT zT+IARtYXl%17qDZPMi(G*=Ia>N6v%^+R(=}$g5;Cxa?rS+oPp7+rUo)XH9TJ9~7_0 zc7V)PbsDf<#TC#_WF$4uvm5TgYh95L2Ycvx-RkY04=Z;Z_$X^*sp?dkYV!M)>#53M zcYP_qOZIP+O_|SPJ#%stoPYBvPK3OlnT(Yy>PYYlzwq-P{pd#-6cfBJk6><^ zhDX78Hy+y91fnR2$k2q0s24)VMdtn8oa1y_+!#~IE-jDLB}lyvjGlzvX_ix1 z+dHQS>dvmq+&SDK0R$)qGB55ldiNk22wD9ilg6SRsL|<9khLY_!SdQ^ZH;(s2*II6 zAmi-*@?`aoo}mxWBqU>710IcC?pNB^-IYIoZte0~=$ep983vJzJy?Lbw_pC5_kfJp zy&g9jyw0oJ>ghs}Jv@H=C=dEF@Yl;^`C@9W$3wTN4zJG4@lqeCf2$Vg)g0S=qSA^P zG2PH&w!+T!|4Y?Zn71=!5CXD@X{^0u026{B;N%x;kZ!G2(S|>2R@vd=B3+5>7D3J^Doci#cMF8r1&RIliTkaOG2!dxI zr1t^9sA`VN^m6jVl~w)~YbgtYz3S2OmPQX;jpuuowT35yS;-RqP8bnvLaH0vZyCFyl5J}NaQNd&^a6}vg3igTsH((xd^IKn@(fX zH0-P{T(~GC5?194)&14D+tlopv_E3z)5zoyy${Byk17A10NC>#DYP$#rD8_T&Mstj z#(cVd@B7cb^zzH!{`R;3*Z=GPBoU+ow5apCKGol{ z*?^ZO6bb=ug4`Mxp-+xr9bgQw1ZV%`V>g$!$Qeu6lJh%*{olE<_2LEByM~%6bggMk zCSxd3^3cG4Z|uEk;4A^vx$n@FZ_F~n{0y2;Y9yuJTwg>3uGu!gqLViIJ7lWqsjl1l ztSWY56(CkmL_=1#Dmhh^jqoyi290gIa^E*8rW|`y5}J^6x%{{>K%}ezq(Vu9L5VX7 zN%e@VoB*2nNS3Hht~@}Pbvn_4_a*CYWKbsu=k%nl7(I!d(47N zAE1^Ou+Jrkp=>czihym|51}#1bO9z^j|8DDg$!-^Wn~#LbF9Dx z`H2+ILugl4J=e)N9OSe2Kl+dU6P8P1eC3l*KE$>oeXl%m*V4lZxpyrHAjF(x1>UI~Lx5hT3hv&$`PPKo2hf*@teS~$)Yg&yWT zuOzs?DO=208pgc7+BO584f*H)`G5Ye{k6aT#Ta{k+I zFHe@HZ|^Oek+j{tw*g3dzS%nu|GhUO2DAG>xgG~?yDqHkT4UE5Gn*#pH3qH8!`%h&PlxRR@y@F*u`4ZK7PRnu+=kje+`ho%Kcx5o1aqrmg@gZ&89|4Q2#m zVp0c>lnX4l?~+o@W0uCyoN-Aq46CkDgw$I7{N*YVq}I;P9w)@xTfEvOqP~;c2N^5R z31KE|XRX!SrRckWj({U(=UOL)YfdjxOuEkrNQU^0lAdmC6wWVJyHc4v_SQM4X}8Zg z(Ce?i1^`dJ?+74}|NgTqRfUAyD^;ku9;v?YxRD~U6uje{DMe|pDfPE*-ne@0 zDr2UEvodR5q%!l)JDr-S4PkX;SV`xNRTcRlluuXw2-ECboaR0=U@fg@AA$%wW-D$02owdZH-7O|q6=EH^MzBHH)76QMB(=N z+vmG=S|OuZPtpjBelDPV1BX{pFteo4b4C>8?u`##c8Iu4&7t>kfDQ z8BXuL-A8H+B&|@O^ewIK5xvr2zAYXDi;=7#Wt2xq>~6V`x?Z}2T1z=45*1sVIXUR9 z>s`72XtY3QwUD5_ThgkAfvJd!D&UdNMm}vx+VjlE?woB4dXD;j%4Y(1h&cCcyk-0c z_ldS|Z!yA-r!sQN=hJy+mSxAuzo_?~Q9I&|oRWrO$}z`l0I*V7$vLYR;K(4RsN3q0 zlodx8|E%;gGGREF4DJK_>j zSYska6KuP+ef?I5WCY9;ru{}oM@_s)Imd`Gqe|{-Q#>lRr(k>%IO@@WnC_?rK37MS z;m28Rfge;YRdxhj-A(`8k_t;}AHBw`Dsp0a(7lFQ)0#R0Q{HV}9YSMa&3@qj`j0=q zap_9Fy7s_ebm*`-->=?Yo}Qb${jJxUWGu!d81xu}YaLpHMq+(Uetd>>=K;clZGd}5 zW(PmZ&zdDc=`1z#_Rfh1Y&kw=!CxiwZUm(wVV`($(k`MbR93n{^=kxzUCGkM==&zSvR&Pnel+CoI#VLF@-1)~yK40lfr>I|0;hAy%4v={%fB3p zrGm&RfS~E9>j(0=Z@=h&m)clN$7ed+fVEf#{NZCC-FOYx&o>nw5T z=e=!8j#6B5$%YBdoPj4e6H~{1M;=m&qLOJX$cVpBnPhz2nmUP~7o(Uuu`1oBjQ~#d zWct9NA@%{e?`@`~A;00(&HMKbT&KlFl zed~hw)a(0uhme*CT0@=;P4;Qj;2>;C8l1t*ikzedvck%0V-P^w!U?lPhZr+fmFz{D zhkC~(F+`mE30*+TGfvKP)j52(>>|EPPpJ|=X|7u@`05ms68FT&J6wlhw9(7w7B}!V zHa7VrbhZfU^CK_5@ceIo^{bqkbBq1L#fw+3T;YSlW{ly{1`aVxSt~~AB?q}Krkwp_ z&Oyw}DTSDo8HrWb&z*a_^oFiqWk|`bTQ@jv;5d@!-5JYyi-XEy*Li~j2zJAKZgV|g zZ%?jJ0ojNQe`%QSa1hPk%GEpR1kn;>mcV60dc6ykIvR1|vB)LeAt!)E4yNHZ)VNhysOI)1eS&yaVHO9MH*9RZ= zrw>Kr4LD53`W8*^;ZjP>a#%WoT}-_6%I27IDra{>Q8!lwUbXk?8JoGmdsrr{XQ*6l zS%0d&+}vrFmx=|Mv!_`wjv$l=C`rdzb zy>pSkFYaRikw9+0ChpKS1p>w5#jE9JKJs&AFS%AKy`enQphGT5e|1C zCPBJW(29d#Ebxy_VKHpH3o;?@%={K*^^-eS=PWDfka!>xWm4)>KP!h;5^cE+C)Jcp zJ!I5gzV%)*1D)nTMc8@OQ3U~-`Z=V9!UaR%S8xe#W}0v$pywYf#C zWSVp4{M}mZd00enE+CrN6Q`0qHN+{n&;XU=&8nbFOM{KgWkw{GDd4qrtECGk^+`ue zr~1P4Ke~AF9UgD^+!wy^_~VbMEG+jsnf!}yj)yl_Oz}y`ug1YjaMlmoawDc3y!O%Z zWW2k*vsD=1x~X_e#FPMY&HHppUv;{a4?sPbSiP>DmH}j zabr@%-a_vw8aV(lm0S#{_Yg;Ih|a}Kldc=AENgVvr{v2iWJ>)+cq{LHrHMvBNCY-C zJRJST+vlGB;SayG`PtC;oI6Ct^95_XwNqmg8A)G2$bS%m%coDgeg3lV;zJoMnkMJ_ zxZljYk>Ibm`3Yufl?t`FMHV0-A=Sw=$S4clq4!Mlo4eLG@|>|jO|zbPh^@s^k}RE^ zyUSFJ9E18`l?kjk7hBV^nnWs=FpD|o`jj*|-rDBVV3+f6_9(;ApzDb{FW>v_cey>y z=lO8Z?zkPT6y}_n=A9QW6w}rRL<%9O3=DhyqL|mVI{rTUD}A3)6;6wjW)ICjC|*@T zpBf-8LUpwAt_nuHlF_@RwjI>Qy2$p%oH0p0C}~5vLS@3OsL1iv^yyE3nq%Bw|Mg!d zBEBM&9YL!*h^TU0KSn$QEU~?dF4kBLo-z{NDdMJ2p9OX~p>bruc%02iX*E$=4^Bqo zTw91>oRU8p*IE-YfGxgnYcxE+w|m06QOeQSurqmlseQGdTex4bkg&C5ce zIxz+$I?)zgPBHEAhuPiIvrQVGs1+Oa4Z2~(>d*n8nZwW&l3=xKpmi7JX`c^c+X#l7 z&*kWsVj`xzX9j!Cx;6bU?Y9xVNeQEELZ59!w9a^Ag^?q!HjPr|X2SBaAlTiR54$J1 zN6x}G9=#7_U~6~xx4-_4M<03cp$G3vIax936!k?@2u^i0od>Mt-)b?d8yfm z@leD8m}To|(yva_eZ#P2t&j{9(~&cy{#5U5C=lY5kr(B<<8`KD2M|Vx^R!;S-Ca!a z4tUEP`EvKM*EvLyDlM~`JgNc2e3Ct9b^D_CP$U~%uA!iLl!me1l zMPBIXl!>;u%3P2loq6R|PMbHGB)~bI4dZjKXuvd0jAiVbUxBS{i$7LMM|R6R|E3YP z6UbhgMq@l?s)Yr`X3Pg?plL)jL2MvZJDI0fFp8dNfMnFk%&#mE?0w|)osgK(o!`}O z{^oD;RJyP;p-RuC6q(P-I`@;xcrRMT;44{m#g}WdC1*3w#uK963Ur9mTJm}=q0wv2 zddCZ*Xo6Um6Z(*2O3s+Zr={T=VShDa`B+GhVzae7G_lEPLdI*MJ61@CyxdT3 z4Yhuf`>ikm!k)6Veqj7kc59t^`!9YczC8KJKkwuVR)>P(v*{0K66eA1K}@&88BDP zB0ag;NWn5GmzDDt2~*1YG$mQI^N?gv!vD}V#iP$kX60owJG-vyISXfgF|G)nJO56h zCBMPB#ZF4)59uLc#5AwXJW!HFD-b0((4jk(NChz8{N}eg8sL57Y%2n+OT)n$p*wZ* z4D(Ju_V^>G&zyMVk^3Ki{Gp@A4sq>Gu6?jh8I(Yh)uRqDu`#T%qLZIxDLHU>Pm|N;zrxs2mhB z^$xC%Kp03l>7Jc46{x_RQ?L@RnVE~fsm@!>MehW~mn`$7S{umv9k+6Q{gM6qKeqDJ zry^51jrT{;dyuRGK{AVo8PzXt9zD80nesz9t2@`cuz1j%VkIT1@NPAw3a%U!IrT!# z#oL)P&h^!mZaN{znff^az9|TzF6LNT!kEizwJmt(`{br^Lk4S86WSOj>&v^rM`NfK zYt^I7Ib(`1&j{+pXKSri0btc-(cfXqxif6nA%b802xa6xeU_vz3ua3$#Q=Rei;_RhSB8WXGQGx(-+&#{7v1FQZE3J zjntS6vUp{Ah0E+kSV6kw&TEZb&xQGQJI@H6l`YUOy~eBhlhLQ>ro2Gin2nzq>l9+D z&*GmdpSav2lsv&#j@em{_*Z`QSJ;cQ^A!&#YJCm6;UW8GEvhS|-byg4@5jx%O8O2A zkoSrfm&bu*+j(ca*Tm3ifm+!Tsz$it1xjaB{|n`kDBcLwd-Ec(4=8&l3XQKarAwUD z$gp@D6HdDb#&IW(yLHTYdF9IW^XD(V^%nc_3;bi(X~_`E?6UEt6ffK_7QF5ph3d^2 zSoOnLADo`|TwUQd-Z#JTZ6e2D0Bc$R-!?0l+d;efz=Nm%@qgk^-*?~I#>UEU)Cg&5 z)MQI;SW($aQcBo5QxUWEmUoNDc=tq6 zb}AA=>?d;b!#*Yw9uI3AnJwqd*4D`RB{J4G18ZSr(6`MlKoXan0j>Duto5LT6vdr% zrKu@U>pC$83o`+-R;Nl;^M7teO&-$NP({_6HWZ&~G$A}l%UMa87r^0iX)GweRDRit zXw;p@ppenhGP~YUNymx%&b-%^J4|O9wSFL}Vb*gzrg9XTRtQb^_ccI7VIfqV!?o2F zZUAj=th3Hz&dGU~F>|iWDgbZ3@rFV%#UE#*tae!QMx*hD`XNyuM45t&S<>7-Mj)zb zghrQo2o~?EF{Tohl~iI7Q)V&s`|p2%mDjlsaO3)ooU_s|4;nyQs}C0dA9uyEiFSdd_x-fK+E+_~IyGSB>! z8Z+vAYY2BIWxA1K(k!XtvMV=ELkK#}QT~Y+uV9x-Xr}K#Yohx4HDA<4XUWS_o7YCI zw$*3uTJ!b=1iO0NIc~E&LsM*TOp#wQ|L(u{?;C3pM5VLV{6jf}HRM-{LmAtlAd0*U zS205WA}_A^EaSb3#1Z$&M3z+b`miZJ$=?|r+k=NoR|Lwhu0?6hhd9}YF-nD9;YEb5d`>BIv*M<-fy73l0X6kcr(?mP23h z>XoZgp@vm(P~Z1DY}U)nz4Rh*cf4z@Z=}cJT@zF0AV45^S)wgvnhY8Z1|P&`vZwoT z((g}AhhgBB53Q~@!)bH)^4U+k{o#Lv{dySKjW%{KJiGqpi^1$t+Fwc(%g5XgnD(xn z8_=}}pM2`}_I~OUh){SxowD9(j>#e!?DwW!ACU>{1|je9iZTB5aCJ()J5k1S)3h7&L~uvVUhZ?oD7dg`7fYuA=h?7aP0~|GnhynN zcD{g9(`#;#sc9x+tqOrTX?X^-{$icItOzVO!)B>32leHZ=6x>TQlkqcp5xPlyEDVK zVRxQlx_I%zD=gC@s4+c0oh?oMObp@cu^#dnn z)Z}x|dst||GW29~eUq=0lP6Ac6J2DyIn+5|?GIELKlzBg)UShp zWs{|Z5e>T5Hz_(}QwfD35fra#4H}3Z;OOe%r|!Q-I~$Lk+8QEx1WG~XERB<%NJ_!^ zl+huq;b?j4FFp7A^xREGow_j%!8;xIbCwKL!#W?Ut`UNz#tZE_8A^tF%WE{?9Pt9q z#BWOocQTs9z!~?) z{@5Q2O(jU0-EOSR5~UcOwK4$O=st0C1r*VM@=f_9t+ht`uTr=z8!9L6y_O1;Xz1Xf zs*6UTwT4MZ>c7j+b94uoN(JNfrxdeLzI42>w#bz$*Is}94W@lABRV`mo|2A=>L7$G z;iJyPwq-4BbsD~C1ESVBm8nOu22E&K5S&w3R*7cV+;4y7w?k-oG4d;zy>~0?Ysde{ zANz%4$2T=(tJ2wpX=^;@H^W7KcBMII&Y~W;|A9vyd1QTK-OFxVbmw^v-4D`fzjFDa zP{xK7)Bc#h_H#-oaeV3eON`~_{R_fe6}h#omkE@%*874)OtH8i1oqi~?a6vZ#9UZqrQOA zwz}3u`^ERD&FaljpGtZ+nf-1ZOafa>DOBfqQ5~x^Sw9;uPSRZUtTAOIV{I^ybMCBh zWPQSo{pqmlhkb8jiiG=y_Q2dw03cDy6f@*ZIuG_^SYT8px#oYuKByD)8u4jXj#JmC z@&-`!d85lRc4~ccwril@bZHIqgUk2->CX?|cPyPAx}(Ds&<8s!=wR0Trl`N8Tl34! zR^He$7ytURx4-gYdS`36Z$@?q2-%oym9?1dZUjD6t<_}Y#Zsb-lnwGG*|IJhl^^9j z8YTBGq0^76y&K(}`|Oz=c!$O;roWPTyF$gWR1l_1d`Zme&t{gI8!0`uP2;7T#>Oj& zlI^^yt~X=5Xm|ePY-4dTb9L?csLYNG8G|}n z5zj6!4d7x-Tyu+k+812gwX4_Pc;l__eeZX^^PTVV2pP*mBg$~HQGJ%in#Q}<@?snL zF-XSZ1$m+63J=EU`_SuLfr~;pdHBeYLnlt2;AHyg_dorKpZkQ)zbe~=0Ks{?6oI+w zE(3iYs6dU_g}-y*+{H_!TW^eE){aLXee8)Ro_y@l$9TJ7hG+6XYDpPj&446FC`j z%n1U3?ExZxO>e^a-#N0DR`QME#h2E0uf=W;f}hy1W!r6RCT_GJmUejU*Z1t|epuhK ztGC@o-h6QF@lPE7(9bWw?{lN4zqs^)KQQ>f?{^>g{rwYPOi%v2eew%e+EX_M$8R+o zTVZKx9hKwelM?`8adm;f?%dve=k1H<-oC(<2@c)ZXLWrlDEdA}l}@x^Ed*zVtt-B$ zz%-dA_V&4WuXRqQ^6f2r?Lb2+}yqLz@S`1JZ=6$m?T3TB#O^wNTy1!Q-8k0#;bz|1pFMQz( zT=W*8Vy^`@9nqP$_CXhGY+bayfEsJgs~S477W=6DbT#7Pa?#rQ+OcEDA9#R^J5TXg zJooaMQ;#cctikj4xne}{zW2S4X>JwYUP&|#n3XSGDtFp}ou3ya#7Q0z(=K01IhB=! z8uO!`HELG!^qeUpl!xkd49+-Jb4eKm#~2Mv220nizeZW+x`~$~F&>}Fpj!DtZKG!` z>=XPL)0VR?xKLfUR2ENVTbR028-zB?l+X#h*)o&uc7J@d8~yTAr~jc(9r=epyYvfB zUmJ{XHj_z{raoaqK+(!P8yc6v2O6wThwinV>woPBH~!-H&;8e5^Y4t8V>?O>OtIS? zJA?*Aoz$Q;a5pzuf2{MMWr6yhD}mELc+)fC-Ky}_m+B)CgX(`#%3CR-gX-)}e=Y4nI8Moc{0wJEJ4petio@6Th77sLOtPXYa=K>EnEQ73 z`aX*5WlIJi7U>!n9C@MP2NPG8E60XyS=O>F#-N%^&sH_+7jIq7X#Gb$y7OK={ejFvBZI|KWYseMu}Q`O6IH|sORz9Z zOtS;-?J=cH(**s~r0-lzy_KE=Y%-bB`q`VbDb4vA!N!<4OD+Zclz9xDC(~j|9N?bi zKK9wOA~g}z3zk12FRhD~*Q)7>sef>upkdz?S3Y-=#6K8gnUI6I7Vf+6><2&i!BeMB zry|7d-UU$@jQ`aCv7bG#+MEwA~ zPTJDWn2Oh~E_?3O)tAr7zH|>)rXd+0H@pDX8a(nZ{K3tC{EPi#tGCzF?Y5gV zvB#b)}7dA(N5X1W~)`7^PT)!stR zX^x;XlGNqE8$l8g@ALxK_n|Evg}G`!{vIlI?8phJP782iv&x+#W;~CXFQs; z#&7Z(5u0X^5;_~4ZF1K8kydVkmf3CjFTXg;tGlK~JWVLhUnqXKrZVK?$DW(Heg-AQ z3)U&;30Y@;^!#(`FK4O03x*sQ)Hxqw(hQC&ws$X`JbCEMnX`NZQrV~(*m2AHGZL=4Ig?A+zujt%4y^{lH zdm+0;q?C{Z{H(DH9n|H91#ZH!&JKFx3I+nAwVpR7kdJ@l1Jkn`aeO(w{=yUEx0}6b zdf^2$W@4JWd^FM8%A=362iVJ@afdAU9wQR=NGbQhkfkjBxJ+nuCeVQEp_#Y_EecaX z^hb^iPJRe-G!zHWjka%^z1zzsn*FUCZ@iXpnx`i1b<}oyF|99;)}6}2LHSnmi6BWAM`OdYxY)?F#H>o4fHN-cLcd27%o)&Cc6wJf_4cDA<}bH1`t zX2A4j#4)crCk3&pN|>MxO%xGXX|B5p>Ollyg3EJfZ)1$y8{%ug`GUc`di6SAdhApA z?#6z7dwZ9QWP)#}zPyt=7{03+E0KaN7dfnl|A&gYE5`>yMoVlBrBr_Y>W)dM2n zbes$9To_0x4@7*d>k3!W&6_uwefHH?UMWg(ZA*maJ!!VdLir*!m{SF4X}Y=xEjofF zt0b@UNXr^&TDkHAnBti;>W(K{o^RNMfKs4uS%aYZ(UV^3#tPvQg53?xb+8vQp7OrQ zu|--Z_UPtZc?;6)R=z?b%f0=SCqc5!@%NcGEC337qk;&EcSjspgtYpRM@DB4#{rIy zjnL8CWOUX{eGS6LneGUNkEYkZj2^ zH#akncrZ`5vXC-le;FgI%EB)){Pbs@ z{=f$x@A})1JaXS-k3Y;|0D#dBg7kFpfS#_eTJ%6E7j7?}7-q>A-WD3Q{X&g3owmUl zfOpPc=(>JqYfH+12?W-p{SNPZ#w^0^d67QCvq_6sIo_35N2Ug{wlVb#(4;AdF?*iU zhG_8770uMLE{)&*LHFX< z`!}CIa{BB5JA+ZC{hFB3U^&3v5K!)oQ)re}4y0j#a-E=RWC!cO`7s4*H}dj{o#FBQ z%?HE7Kj$9(xHe1QVa(RoW%r0`fN3LaYOSFIpnvrc2Z~HK- zV;N(l0@RDLS+Se9Zt|LkJW-e=qChOWqTL{^borQ~uzq;7R3c!m&vOV{v|$b(=0SG8 zthj8>G6d`E8$4*v(RpD^8!ZW))PVVA1ynQ?Cc9N8Zsd%d85LP@J;uayC=9#f>iSsN z;#wh!k1_HitTXib>#ws056F1l99OWYs8$#7!SmXdi=|n-_h~um&X#MfQYlD6@pT#( z-!Vt2PpBc*Vun;F8p>jQ!puuXXRO)h?jaAAj=B1C!jQ?NeUs$09g;o$LZlFKeD>~iIYpe_@R9NdfI3wOAb?4nsWex)U{xJPpOA& zgG(uS^!`S4uWffjX9y!sKS5>g4}8K zT&*#w8WFum72N#fF~Na?*S$OG*4nBf4q|$gt(Y(F!1EbdNLyL_YDs;$uUz0}?pg_; zzEh>=QgdQ@IjhsRbE`BlwP0RNPP%y=n}4kH!}=o5&Cr_iVEqX4v-a@IN>lO@gQ$>- zD0h|9BlT%EuwkVvtWk&MF9R014!$5=Y#U#ExkLk2Fc{f6J$Ujr7lJiq4a{f==Vf*z z9fPj7IqM8iC8MyVQ{E19#@(&k<;uQ#O%)-X5oFe|QHL~x?utIUQI$R8gc`zw@r0y8 z>4fU!oDOAKYlLidg=^sJ>#K)1*SYKOtO=pOZoRj1u_+i%mAV^3^ufLH#%ui7MTn*G ze$|=*Kg_MZKlKm&>V5YeHU^EblvIGeew=$4;*13)C(~n^?DkqFNn*R*IE29Ob9eWu zw#;W|FhWjg(6kYHnP#xyJXwNB2uAO=S{7@E@x_-N%_jzQ-l58TRklk9KN}I^Vs1{ zh?mDbk9AEseCqr1w-He;mU)vw$xVvgz1wZ)wm8|c2sEQb&%A(>Sa`mgsdguAoIZ8I zVW>yRv`8yk-m#Q_uUx&#rD=Ak(rOtf1&+0vvnkLU%Yz`Z-2v-;maydd98Gcqd9QnvNUshrBj@9~IKCL)CH; z7Ls`sEDpcI```b5E{6HgT)BMZ)z@CXb@O%+WtKqz{&RY>;}x^Xax~A0dkIry=thE@ z_atxEdY&Xlq|jXzRkdiz>aJU$OalTr`ubLDrbWCchoBWuxj|u32GLzp2d1hmS=}p$ zMTrKK{MtdVfZpu$C$RRqF-HL#qL%U*Fe?B%U=qwauucmE2tB;FIZI$Y8q?)G5Gvyy z`hAzC0pPy12S4-i-I19Lz%{f5Q)A^A7_tL1&As+HLo=XECi_(gN7As}i7)((uTHiT z?BWtNE6}J8yLA>2z4Fp8gqBA9iWah*=ztuk$>_&5!gJ^Ay=P*oxNJ)3#=Px{vN z;Odx@6OntXC29e?joQ$tS6)z|1<=WsD#}@j`R+)RRg=PK?Hxe%&t$oip;;eY9BS1U z(FZF{j3(W+O?Tj*spN4p7S!M?v{k`%`lQO#s7eWo1d}`it$)utJ14}EYek@z603s7 zJL&`%uQDu_sZRcg>HHfQ;EhZanno2-IWy(B{MuXZFhP3hm+$Qvsm->{$Xd(8@raa_ z*TZ=O!qaKzI~GduoVTN;a{ytc+Ja$Z)wa$`>(feq(BoBjb{~6QYt^dEi+2;{ zJu|5b&M^>U>-NjqI6|4VRsJ34O*Wnb%@> z_2&lTO5>&}5@cvb{fVYLUD6OITg^FILx;l+SpA@ z%m~(XH*dW0gDINi!_uL{>!YJ+xyG@~5@6$$`?9xv&N;}O9}#I=J2(g4lut3^8q0_! zn}9IP)^&1LOQ&2!S}nEhk%^hQ{hL1R4rpTX&H&>Orh_yI7DNBmsm;mxt4~hSsLLyM zyxe-f*LMX{*HJ>3%#3SPZSfH5b#aFqt|KGb(h{3R=d#obUwsL0>2S80GlbMjQrknk zxj^bgwKu4+2IWpR#-j9As@$7Sui3dMLza3BGyW>~6Lej+E|kb7VJ5xJ7*hO}jsx<7 zymr6BQ^bA=LM?#j!qQlf@BOt$VytLNh3MA3N4WqDKjRM_59Ep z7#Od<49eg2s$$&tnG)r08oM3BS2MH-hl~k^4nf(tWnc_Id5)v{vGZ_z&lo6ADdLd*@b0<`R^;Yw5S?ofqNPW42+qL5hKYLSWb#Ewpt#zS} zFL>`3W>2gVn{raFTHbapKD+3!$*Q}BxvQm$vs4C!8vHF>*dS|N>;br|J&4+rMQ;nb zt&6(<`U?7jwKu2U+zCgDn2wT3=~-{C!ubiISR?mX&%u_8-f%IHQ*h?Q;4vPCHt@F2c8i`ml~dSR72UAj zsM<79$&W=VqPMnTor#MV&;9TJ5C2;q9Gf)X+tfEigSJ^cd*5R`vpd^ks7MrqpU^aG zVUv1J89x(?u`p?s0$Iir$B%Oc!!ZqW`Z(uE;{_tU(d#{3>44E-@P;kLVhVk@gBwcA z>)r^Ykrs)94_H#o%9MCS<3<=Aedc4=jBjG1w_bC%uG*9{+DsqP5_G2Bx2OH_JXskS|jVRFA}yJ49rXJWcrVRC&5Q;y?y?TXnt zHrX*~PwXTY?C##=8aosV9*s-TDe{=@ZldP8S;J>rO$EMX?es_I%f@`5b>3ws-On}5 ztrA7DEKq>yMM7G>l(S6(hdYuVF+!{W`z+#hDQ7-!1=l&y&{-gXCJ8D_{1h34lu!s4 zle38kq~qRb&0nRDaxN-o(`g|x;C8jKCdIUQ=rAkXUA%aiOXXZe*BNmDZ1``LqDnH> zaAK{L&N|4-VkAUHsE~YQ>wDGVRk??ow{E}m(o5VU=k^)Px-j+feP`~Qc10U0#ki{m5<|2!fUdk39Q;~I1!2%;jwXi{V&*ZGJ zg4j_R9&}*Tk10yciH2Mt5jxO>$69@*`pP{58gE@#S{Xrh-rCspeYb1e>&84tX|tRL z*a98~a~YsFGnHOcUgmpBrO^};2pSERVdbeu9(v}n+ilu{?v{s~yTPD=n1Y;30c-{v zT$3pelW)Kg2eZk){`KFv{?>Kq{VKF8of+B{RZ*LEy=?=ag!+=-Bmi~iR)f$3i6-h^ z|5;eQ#PIG=h`UPB5Riro_ZCx8S4%|NEcQZv(6TkMYMRQ*0y=)7MgLkBt7GeC?jYIj z?6XxWsJd3G*u;veF;=(dP4W4yL{G%p4VT4KS(7@UVb!P0kF!F%tQFj@m$2tvDIvL9 zVUTabwyljJ4OH|#rD!)L)YSU6_f9(PQ3X6mFNK`v&Dtc|i>P~FJ46~l1Yc6dlru-? zGLCY2XJ=RH=g!$M8Wi75rT^WB;6fN0>%dx_nwMa~2q&D^x9MGJ9&j7DQ1Pv-aTb2$ z$mR++Ll|;DEZnmKd21xat+W$KBr`LCNDyZwT#T3#6lK-cnudFXXYW7tsZV|4E5f6W zS3S(U+!OhH%&RKR3c&~{>FuhY0t$3 zmZ}m_JJ2KVtW{L5W_DS&y|wCzqq52f<*E{62p5x4;t@h}(saMOFIQ_fY#v&kMCmEN z?|nCi!wj&Tvw7+JE3tP7fJr)FDGAI@WfTCNvAhgR0wA4!D;=iE-fr+g4!@IHD`7Wn z2-hPkn@;=jbbRecfOe8;u)1m2j(2`IMe@z^=-7!6Mr2!{kV<(0EG84PmD&$|RLnmz_33Yy|ui^Y=8Sfz|zpPb9irCz-3 z(sGeBEd6F7Y&OQFgp3r4{7tYU;`Lj`pYp<uEJC;|RG>g~>!Ar7q^2Qfx+u%}RdCp{S| z0g?ergowV(b64IYwG^N;Cs|A= zoJfZ|l%F;0%$aN`rA`P9JF~uzZ@u*@O{bfVlIY)BQrfh7%i==uRMJJ@!f7BoaZQ% zWK8EG(7I;8nu3116Z=F!F-|h3obz;lA`P4tt;gwp?uvdS_QDflJrtPA(t}Sv-VED5 ztc?Ad8LnWn98Ey$Lo@VNc%g*}z?KhfWf5r|po~r!>&E~##XiF)-uPOC$?lPV`HeOI z`u2t2ad{WOzN zXC8j|fkOrLwq(G(@WP9)6nmBBi1uZ3>M5eTj?u!5AYviNNHh0?56rmov)z#+I{Ph9; zjX=+XHxZ~!&Zv5%3uqx>7M5iyJolbpCBRxZ{K==AQ$uVGwho=)CrgZI1>dSu(9$(Z zw#Aip+W5VA{@LgA#hXi$JRoPt>XyGixY`HI&iAUn|rwH$^<@eyF*keqTfa>F&)r zYo%SCL!IX)l79SxNrb9)u*;yn>^(c;RJZh%vpOmLa?a(Hh11MS)wAc=uFN4Xl`j?G zS6{9Xp_XSASGt&LYfYVunqFbr9amMo@*<7MlxXu>+t^l28Ja{D&8oJDejTXi1>fj% zD@7YyosKc2frM;pVPMV%4c4;ridvw|p*OhPhbbU3yg^+9L`Eu=gxBPFKN zC88`$%L#ZJ6CipADWw1qa5^v}0L&>HB7@0W+fR0x$+gcE3{Lj)k_w$nAQg`)mB3}$=y%e zuc87hjKV1?OED;^t=_m$AqeFMtAml&7k19lS|Wn1+~}kPD7?0$9bcoBDy+#RQH)VH zE0WF&&!DCq-i4T?1{5PF#p0Yo-zf{ajOEC=nsV~qcYVjj@SKUSH7dXBnU8^gm8aA= zHD?NU4x@8Ius+I(Y>m9xlg z9*TX>dg*=F^PTDBiQ~q=H@@+;=brnasF4PaT=h;TJM^G0H{xmPJ(2$$zqb5}ch&>s z>YsG4)oUCU!14M3k|tAH{v%MWNF%M*fzag*3wJl82{>tBx>_a~@z!UJOfkolI99i& z6a%Mwx8HjE+zvMgg~Qbw3J)f<#gtm6<=B^AwkD5h6%n{lAc zPFq!1oKeLv{gc%Itmfq^(>?dY^0TtHIfd|PY@i@GZRE>EYOS8Ncd%U5!hvl0K}!17fl&80%BuOPT~3<4tW~>P#KBYIJ~(bZMLA=-h9xUvtT6Zq$ITMS;I7O z>U~N{hr4vw@asq$rCE#?D;~p#w}_Zz zlswCt2nDaSn_{1)VJR#VFBfIBbzXmIrk zR|32v??TFvD3iK#K66dZ5EKYQr`CE5G3B9G&K(LEKDTpy#Z>yrxaT^ zYQ5dxzQuET&Uw*eAkfnub7P$$YD36rY{z?pygh6}<86>xkpw>4;j|e=a(vk)%mvo7 zve~R`4jtGqNZ=wzj$5}{f0T}H9<%!&UwQTVTMwn9%Ue^6+3njYHGYRW1Jek-H{Kc# zko+*@jb-PGt1|>6Ts!%54~J+18QbO8zV}>A#@S|Q29sNRjRlX;7-O+-tjA6w3*JBh z7-;@sEs19Ub>P|zvr0%k!_7JCRe7OwprtWeS>p6AEaM#IwXu$lP(5c+pF6w$7f7iz zZ{hE)a%Bj)TPb}9rz#^p^Mip;1!rwc#ocSJ!_W<8bP1t3e*C!J0l59dV{BbFW#2~A zK4-LZz5F@DeGO!ZpTpN6uemS&5B)>`5PR|e}#AoWN;f&=b8`^Q;xih!xRp+!-vm2@X_~ewYXy^ z>wGjE=ln3dLLsL6Yu<(^r&Rm_4Z@xER^2VeqU`-S8q?I160FnlBXQnr3$cOu@jKAWIrHYf;{*Vwjj>S7d#xh-+McMxuU6M;cZlR0 zqX?0zw6EMRMMRt(-EMJCBqNAg{MVaN6Plb04}zRc31fAeqst*?FU>z6KG2C!|r z#22YGffoQTV(P)U*84%qru--!bX$|XuHx`44lYwIga_KcnC-1lAN-* z*0QdIn#zpLY4UIX_E%KoQRiO}Es!svg9p__QrP*OP-vWv`B%$MVwXJL+l^h9`o4@t zm6_UUKkfLD921ISYjNZS>Z{C;#U^vBSp-xK4n)nzp*ncU%TaVG;GiwWC>po9Ml^za zfpj{cJn1;%8t2#((j<(!vk$$syfQV80M{q`JI{W9sUNr2W}+_kQUoB(8i>ebqoF?M z9!q1Jhv+%SjeY8RgcK7**7^5Vh z5OXZAt;GeuzVpVBn=c=|{`~s6Z!W$5 z+k+SXy7|s;n6LlWgYW*?wP*j!$=CnW(XE%4y6N%D^wxj=cW?f=Z`}U!^M~`=MqFK^ zQCm($+XG@_$pacpC6?nr=$+}8duPC}eON5Q8M$PwBM9wJ0z0dp4ggF>d=oRKzxfVNzFk1}0Osu1hJ+ zM_wJs45;!h-@JK)Ib;ApbfuQ~+G(2N;I$2@XTCDFs%n8=I|QV}?>yx8PyN&X6#pX6 zo&L?g^*2*Y)>=NXIV@m4yWqq2_7-p7-r8E{Ykgyri}`=^Z~jg0sq0uu-*s>H6-C?Fo`~1c9+ZN5EF+WH!2mpN=PiTL~PsW?(>>vB=p+E7d z{OPkVj<&A0dogs@V+fWEIb$Kwunc&FVQe<~(e3Y^zx>yqyZ)Qs#lQOUp(}oEGV)W` z*ulUwCZR?yTD`DDj?fXAe}F!h4vv%mWM=L(eXVNnV@>+rq6OOWIeF~pv1gun=F^}0 z^oKt9p+_Emr0^IvK~JGt0HEnDs-G}0aIqJZX8r&s||H2l`jI) zYg@f62ieucbVIkwVq}52;&S!V+Iyc{{p();PW9aC#Pfnol46NxT*YF>$Zc2CaOZTm zoW#5@_iJ{XEG~Zjop-KYy>|2F*0d`uLe4eL2Lo0HZPEokq^i2ujrFPaxIIsiZ?WRj0kF5NA2BQ4O*Nq zn2obqnJE(v%8Cor7ZmfP>{74^?d|)|u6^(s^2;&BFrdr7_040uJA^%unWmoo0ASSc z!ps!bg&){DLMW&VV{Dp&fadxX0~j*WZU%3&v6LxAle1DT1q+RJ$C&rN3}aF5lT~nv z?8pq{Eg&Qy6ETI-Np}Pkb5aCAxxMCS$&l#Cjg3vtr?PXWWV)V;V`C@5^Nz#9DiD{a ze|d20+vO~J>#v=;$hxy`lKZPKeZ5Ix^&`j9VO&3RD6ft7VpMvL=*W<9S$v$KWor}I z4l_!wOdez2Yn#v>_gAJJd1sD~mf!zjA8CMLdhzz;>h2(U%68P7{Yy7&hn~=z%-_h^ zguU)Jr;wPLXzjrHAOpg-AxJp`$Vs6-TgJw-HRuq)S|n>sn)~v(3rFpgoB4eP=J#|( z163TKF~pucXY8ogU|qD6#9Z08ywCUwbgn2Uvb*IgNNaeu~`eoZg5nngBgZ&yfWR+;_nYhU}Cbmgs% zu#0?RWp=xlS?hH6eTIga>sbFZR`u`+EGQc+H@y^g(l#NtVcJJKo}`?-)KXIFFeS)k zp%}C6h~jv!V^Js$ZI_#1u_K$vGz36-$HEowcWC&SX-<2y!NvK>zFrE-H+8(L(){Dv+UET3F;>HfW^XwaOnpcu34HUaFcE*|VH-e0e_e99s za$i!y3N%3f;M3^;*3GEn;~0(|dE2&+Jo?Bl|I#n>c8u|jH{Upa?mRa)QSNSrOqGYJ z-2N#gvjEbskhbc2wfSwW5g((yvxNqK#kN-y*Sjdqrfyu8jN6E(kHZ15(PS zrron4(i(^y=sviArzw@CF-*@uV5d$Xcgj>$SN`{=0 zGYELPyMO!Et+Fwl>Y+(eMdugnyAGuBOe*u9lhqS5%ZW$Cg-5=l@!U}og6oVbCk8?Z zAipAH8hUC82q38@o962}1~D%lLe3O(Hc~lJLM|7a;0!FK)Rp}gTi2#!ZZ*xy=YM{C zWv$QDSi64x^6vM(wbJcdehwvrK*}J4S#_aP$_jK+AwQ<-j0stNPW610i&V$reOavX zw#1yt+AN%dg(hq`+PZc7o%8RQL<-l}{a@$4^tkSPnGr3|RV2gQBG6v@~g zi78^buD``}|6Lp`uR$2>_S4?q`oo_)(Y}54*h>DLD_c9+LpCj8Fn;g)&h*V&^v-nm zdvD^m-x_uP^v1E}&Kgkxh}dNt$(cSy(TE8a9HlHoga#8f(s1EjTDnirk74AEo|>y4X5?o6eBl&nHKd>Zbv`#*l-_`mos{EI}yzrv|Glddyp z#?DKIF(wYLxr3(Cy_*{we9T^W;RSBkmukN;^`=>i4fpmO!Z0x;A`UgWzI>&Wh~Ayc z9b`DUgOyLYlNZ{eDJO8YP+&UG>rsL6m+p`3%m$MJfzzzxPTUciUV7&eU;9Q5lkhXT zOeSVe)^~1s^zi4B`LG#2WH$$go}^nxUO)Av_xXp`w*9_syata7?!%N1ht*?w`GLH- z_uY$=Z(U#nXZPy0cxA`;WHJQfG~P)$X=X))M$i?`8cjUG)+znF7(iVPiU2L{>jmBu zb$53xl|{6Ey<3rm?zDxOF5dXb(s%iOpwg~ED&OCWI>un&z5n>fKMry$u%;A&xXhC? zYS)bBOlNm8*69NWUsn~tg#Og)T~5+SsQ#MQDxV=4d~l0Y&*k_zr#Zd)R(rs~fYply zYPt_K&z23Rk1NB4PMK@vtZX)ozPMgWwJA{4pY$ava}675{xzp_(yKJ*telHhb`4+N z3MgX_#o9+aKYE#A>bGt&-dfNw3`yQ_-XmE<*1JZ1c1|E&rvPNg0z^f$yM^GBFwOoMiE`e?g;xKC&yk@xBO7gwhf0?d-&TW}dvo4J@F zgT^Q$kRtkwbzNcJ0q{bXB?Rhnnt~zKy(Q~CLF;j}UPX+n!{Q$u1O>c*l-9Pe2AG6)AwRu3D z%uEk$BxAC-c0_*34)gWiqO~~K|IUTipM4tuH$U)%AB6Q2%i;J^0zYvSL4-JfTo~{= zfQ8iC*4u(hnt}vq0Ip+s{#halWBOUp|ldgMW#Wk1TI!|cF+x_-CHT*g+o1tj9pTIM0l+Cw9(p_WZ^hZ?M1Q4P%r#DJ!3i^G?eu zDJAC|U(3Jri@)T(=e+##mCFFY&8M1kv(FBtSwCP@jo|H(ht?P{e^WvP_R5H90q$fg zQbZqmx1Z3Wj;j7k9Er-Rd!SfVWzj1dT15@&3+gQf4QPFggvuz#es5*ogKmNIU?bA3F8Ve-rUFircINs!`{UA6#d zbC213UrWR~U9;e&7iRi&>!&oWS}rD-i!l%){$88!^b`7W{pJ?_tE?KCA`eXou(;C0 zRUgK_<&;$$Q<^VXr*l(I8s^qUfNaoR|Dw8Kr@Hr&NM!GnpF)EeXJ0`MzjJP?Yd4cFfOWd zwEoH~uf6g5TY@knYaQPu%ZGL?3Qk`ua^AOy;3TN=(zrFo^1f!u7oO1+@4I~e{bzaJ z6bab{mir5)VIhPe0IemG)E+^PM`TO<#QmIl;V^G}@CT=mnO z#Kq61*b-+fpZ(m^|M)-gEBD>s8jr?V%w=>O33iKe>n(QYlimHv zt=rtL=OO`OW`4Jg&2`oAaK>WB18<~CNn*x&OTv`ZqgNMx$6O7`1}Rm3b>KATc_{CH zenUsW1VKv0A2=UCO;wyS5x6*LuYtSo=f89ryumzjiFUWPUwq+6N)b$&Gg8y+065Y& zA!iN&PWzq@s_{Oij9~i=fG9UrB2cum)p>DV51i$n%Pav?1q_Fm7zQ<+cpr2!1PSH5 zB?pF=1^v63IG5GnRo%I;d1)M|R2B?qyJ;91a0x0)yEiK0}JRV_q$A)63*|8IGJ z>()($Qg#I??e$oU%G4G6t)S5`??&ewLs^-S6%2&Xq?qTbm*|Ysu{72D+1T7*GWIj~ zong2A+H0?Ies8SdJW09hbre{KV~bvDj2!r;lyt2!5HV&F`>_r~3lQqI``A0{7UWNV zyvOa&QIK)^-V%bDfcl7q?mG!q6XQIc^@TudyA!t+T0Am zBKYA$KljDXt$Ap6e49&MYz0;ikM7&tr}OLG+mGIQ>D8^b51lyF^`S|$0zc!7CSPE|qR4gfo7TJXC9vRPv_ zn>gU`^nn9SklCoT82l{EioKWKj!a#axKPFtAb9`Pum1M0{_3yBQs5~wQ2bvUk76$j zrsU>mI6(*2`pjaOBabdBn7LvG2vUxSS=;;Cw5l!@^hG3=svx@R$bWj9zXPRi)f8X4 z`-}RQ@|^n58U>~5jz_9e9(qW?NS{?6uqmY=dInL9k*Hii1Bbk>Q7U8+U;P|m)M~)u7|A7ZMm>P&m5+}FT@r}OmDNcvOG_24D_Jf<8V(A=Tp&56hOBe?l~ck=MPbex^;7RyP84z~H@Nln%~K~&{Pkv3EEU@@W2?{Nk4_SW9k*0mcqZ*g{h?&X)CfBt#y8a(mD6FL$b z%KXg4z};|-QfXJ6#)63xj~;~$rYb2`t14>scPms<6WcjD2~p~ghv%?h_938V>G)?~ea~5D~l0C6*SHcAM^U2l0!^g@K1+Ndq zsZ+viy-i5y0}yzNWGD&ak8*RQR4CFSpQp?H?Y0^>N}&} zbUjFDjji{oD~vVht+9{q(mV;y5vuU-dl3e}o-E@$L13TvE< znKVQurOa^*FAOym@LDOkGf7;|$Tj$!vP`jO?>vF2-n4vTDCEkIJn{(hvG4Bee*f9; zbHtB`-h1}kdNb`~k4Vl1WvZBn2zp9Ugbb8nntmEzFdwX~)8s#m88PK@mud=WYNZl- zfMmg@KH1hy$9>A<-ZhD`v6yr3tT#YCLJzL9qv_K6#4XX_p#hGEfSz{`}U}+-|4QiNlc0{S>lw9p-)<+d;d% zGp39-;J}1oGYnp8Ulzx4zc265&F-`y)2Fm}hafZ0(~}|8ZTRWkY*ocyumu3&f_UA6 zc+F3F5Ps7CsHGG&^=?jGST0qHtCz2A-MYEDzShUc{aMaGd1NM~R8D?Nh>LMXsQ3{3TL#vP)}tg=*wSN*9P>GIRpE2`K^)kduwVx}y0yRMzY7Ve+@XaA{1 zV$0f2vDPXiUT@Pn?Y_OuvG%Kf_wW9lXP^E4`Sa&AnznY}{0K~AZG#9&AcO>1O-V)`+!~qv~N*LCD{P+>>j<@Zger{(S>KUd?!iMzDRj=Hi9K7+D|MFk`i+|xS zv1a){_s{*apZU~hKK}8ad-92=jxlcX*kPu`Sl<}Lw4YMX?HS%JOjP;y+i#yg_s)wi zzVPg`&wlmqf91Eo{AFgTvZ2Bzf`?{ma2 zRTHD7cGaR=`Bo`4YWrMHO-;~9Wu^v!yrhvb2ye65a(@5pnVm-- z98>5s`rL{*H0VHo+Lv~OeFv*}FcyDve`|V~MSD`=b>|>kLN0zVP zq_L}HVSIbrgH4zxm%ZL)TR{d5pvw6H_NV(6n<+cdU1zGch9A0}LGEz*L zf3*5cAC4S7_TU2#Ics$Ql4aYvuHV|)<`aG@RIJjD7lNj_a-fxRF=ORE`q7WFQ_wu@1G;lR7O$nhSXudG z`b-grO62E~^?MQa!S7H=VK9u>j5ob&r|nu^KfN(IeXn5??=aC zGwOX4O-n?w7oQxPn_oUTj%S7^Uw`@X9yTa% zp$!9PTrigU#0(UDH|1a}<+yiy_twp={r!n?K4qYkDJM5$s_V5&r6>bkj9xS|u2ynL zhV)@`_x(b5-Qn8EH-+FF_p?) z#yKIo6;4`E2+TM&FQ=cVV?Z(8PX`0Kg)!Uku!YfmY zn*8WA%Z3^WL0!oXSd{0NZL2S-$XF$C)rPtJ30~_1R!o1;HJdfo{Zs$MKO$fy;I)<@ za_r^3%+=9D(PB8Xtz%jjS7bH^|6FHSt%0!qKP* z&+%l-=~Jg3eDHxMpM3lSPe1*{laHT1b&@AIy>~?D9gK!e@K%U`(OZkccA9!#O_?H* zU0azwiz#@2>f}k5G-cYDRn}k}4k{azn%0?=01bFeSPztL=xHZEYN)2l2ReLP);b)Z z6Z2=!-uKauedOaG|HzReN18T(!9GpFCf`sOxA*w|x?7~CZ*4J(|N09rKL5>cee;!9 zUV84iA8~c@;<=KAW&Qkiqfv8NmX(NI=!qTFq>;`sX5OZ%;xOgVHJ z@9Y-X9LoFAGgmnmH4@E)G0kf62&7CjS+!WK&UQJ~sv$C=6?!`YAIfmSBqwIVFyt`d zFi;|xKKcZG@S_tyYV5%JwASsu^_TwQDr0$4pD=YP$qS*u9w>*nY9Rc;&}V^&5Q4xPca77E)h9Zl0?@k z=380Mctgxv&nt~r1RORy&{>pLCozxvzDqF!q8*ZLI@rO{{-=N6aZJ`t&;HI|e&xgK zqkw)ZtiO0=yYs`0&KSxnaFUgsaJHPZl{p`_Sdc6I>k#pbu&RSjqGERpbw7)s)=h+&Z z*Or~$E#_cg(BW)lI4=lx?_=R5?BtFTjJ2yPYkbIrsv%Chj)zVe&35s^#gsBX%`C|0 zqr{kc)pIuana_TPgWd}lE^wEfr$RWbk16tr!8cZ|mMI*^Sy#2&+2-wktc6gv3I#bZ zYi__SF6G9jAAJ7&MPcIF9@TB(Yprh1=z}Rn#uzF3+uzBn=2QmtHy3m;ri5pTjmzb{-m2Eyv^Ubah{Bm(CzkJLPF;Z zuX9S%LJJ)Q16haY?Sdf}N#!q;=)VA@+ja0i%83@PP!E$UV|e??c#(F|t6 z?v;gVgX6v2dHqR$)W)_@z_ z6?~+H=lTZfyrp!(hNHm`A_t$o{``{ZFW8^#6x4!*N!D8G{)>{X5 zW2NxT3WyB*>4b_c5EPrT&f?C?6)QvNeYts-MqHW`*JL5dn|H}o5Q3tNnd^zItZ;h0 z>Ul(2gMi}NQ9Fy)d2x>^<6hSdn!RB&D$3}Nc0)5ceCmc@wkANr5oCY!hP%1tWA32` zAPdf9u!4cJ*6X>YJsOp*C_}izA#=Fe;u28rF)2$)YMvJk2KI!!9zJeRUTLBrJx!if(wc*|xbYtmgd;h=k%eVeN-&~H(-1Qkf=k=5Z zGRht|$B)WNTA($P(qBZP);G+`~X=81jGBTkXv$At$*_Fmv`AT90RIB2`@`UpeCC>A5?HB00IL&+gB%3vX zJgB{4Yl@>vk3`jrtL!Mvt#%VZO!pd}oNZ8kB!q012TLbT-*@x&*3}y~(T7N(x9xEA zXlI)vXCEG%d?328+YTqA<={so&<+Zw&#_C%l}ml%Ft=n{ygj~hA?{qi`0@`Ob{Te; zA-VE=(>f0=BzvP@^HaC7g44$iHRtyFZh6&Hxq$Zj2&(;D+>dwQ1wE29C7yQU>J(}A zIb1y`i?~R$fK9(+0{_n8EX7EXScT42$eWHLt1Xh^Rv7zFJ-B9|+CAu9Yv^#NHWD2~ zK{}g-6}wqkRz<5HJ@+H7{_1Ekr<9DU-rd`g%qh(?y1PT6_0q2N3Ch&s8{f3T4%-AE zh$&7cHm9tFtreOl69!P#i|zbcM1$5S-)OF%!idXV#N*YXxq9^jnl7>-+tvHeI^s0D zqILK_rdVp~)*Dm4H&Rl#e&ZHjz&t1V)|+oJS(EXF(WPY2@&SOHmg8qK!Q%WiNMYc? zp~D5*cKFa?Zi=5deR?=7zbJF+Xl=Q2bf$$}WpNe4v7J-t6BoMjk_SvNqjk1S%Pg-P zJ#x56MCicu@1iw!5T>#CBZ11w7RE{z^TcR`Xi+UBX z`@6|?MNY~wqw@_jNCDCE$|_TB6tzkK{?swW1>`a1tnE3rmO=jN1_ zvjeIpTuw;_zL7v<0oksgA<8MD@(}spL1&vogC%b57>>jvTPtlCvA<%jn1Q{KeS6|Q za!sP-j2-Omk6(Sg+1(EgrWtu{f!Y2u;Bbhm8#3K80=e@qIX&1E(sga~i zFc)4eXI+^c!t8C}A7>N=TibcsYshW@?*Q-H#e8@Y7cUT zh*emnoa&kMXRR8e7)jHnwk7o*(zXpqwSbLF;wXcWTpZ#{^3vstIp^)IE%x->I~QOo zQk~Eh(_54ByzXr8eE<93C&bc3EA^XlQM1iXQTb9pT)ky4jtngV`YOZ^=wOchQ^Blg z!4>^@R;7GM9*g4};L~rCvV6(gu!JTQ@=+o_^{>vE94{1GBVgA#Axo%C>E+?QJ7T zzLXeU%!&7z8E>!Vecx@L`}Wr%-*yu|V$&7G5Z1>rpfou+|4s=%_xaOk_mdfY=k2Rs zIKBMfMsw!c{#&NAu?I?k*%@%;O}*@u6r=j0iV!4R(3d-4Mjz6(G4I8!s`Zr$xX^Q^ z>Vopdff=j2*5nV48@vZI>rYPS3TAHasjo&*X=nI!6)_=8-t!~{-$EJt5mU0(uPn2z zFzcCjUIxwQaiTfs&JVPuy_k${4tywIg4CV@lo<+FTLv{flZ|&*IPMNts6)l3BHF4d zqnJ{p)c>{W$`4vSDmqTKtk-pn>H76sjB$IJOU5s~a_inZ>H;;toy=>*EXQ3n?xkT-;_uyZC{wBdnkC2Q5k0X-~Esd^EGFblE72hck^bq_CBQu9Xutp>rY{D%5 z(kF;ytRA%) zHT7I9aTVRSLU7$B5mXyvN1nR>|6 zK*pl8-p<~8jO}!ruAjFTU%K+z4`902IO}n2a_{BMW=xin6UnX#W@F*-u_fcSrv1{n zxSCy9rTtGma^(EWxAwb)ra&nuCuMpPg+P^64xvBrDd@NK4 z2+ZtDO-e(!@M=FH5Kgzv0ry^?Kzc&oY2u+>*A+k|-))RB+^l3T_K}Z#Sc}1Y!_k1X z3_dt-2{mz+4`ALcmtK1c?8voiUI?CqY+S=(9j!D~no{e7+Wl5roI$s)cGl~D(jVvl z?PO(ze6B1?_N95cb}Q|oDe7Gf?udA7jJc0^?fQ+s{x|;C|NZ~@|NhtijeqA`-~RsX ztsNf*U>hTgb3?$Q6^rPGgXN|$9*#CP4xK!Cnu%8*dF0U#e(0IceeMgt_G^FWmwx$I zp83#+H#atk#M2Kr4ddsxh}engwauQAhupZYcAf3U4UU_drs1ymQ%^qmfe(D({`>D| z<`?Un!VxRIjs~GWWonLf0fRX*?nQq z?6nB5ZZ!-2hpu?hf>M&AJCZy!r}|PYBVP1K(p*kMFEYKN>Ld^9wxnXBTwa2a5P||J z5XzsJ@VlAp$JpJ#c;)no{bo5?Kg~J#W^=rCiz!{lp0_{X2l_9|bA77zdMyXPAilJO~wQpN#wrw*+t!M_7k zmOy7Lk7hBJJ2XK@M^T0avu5PR>IsFpG%{0^SwLZsumA$$0|VOH@MJ76(o%McE>`U| zu1mPKwSl*tMY4Tr37U*c)(ye>gynT)0w#C8P3UfS`^+Em%}d*V=Qa59r5FFF|LF&} zP7LG5sqyf}pZ$vI#JiQHk{RaOE3LQDDwI@aAm>qIC&B9exO9@rz=bi40Twy3lOK5c z15Mjr6O~22NtRhEr`+!w+ zkj^tGiS+CdtHIsEa;F)LMyYwJ{Ov5g5FpapG#Y~rjCVmOt)gkSoAs--cDXq{`n7-Q z_@DmY41exVZhYhyhxa`Z2TRyAPMU9!V{6E#>5AbENIj-x(*C&Jy>xu{b@;(w-u=pd zvisHla{TgFhb-`)_g7u?BDG^(E8-_<(750l=La1`G*f0kwgv}nbAH_2#>QH|N&O>j z29q*n3)na!NYZE`(q-Yp>Ta()wsP72EIoSdb06@qaPYQMz0~j07LH@hYZnFC-jk5G zT=jV_-I;X~(u#iWi!ZzYMBX_h9F^i=AuI|$Xh6ctdzw8!*zT04fiDey5uNK+t6Z^a zPRz<$&5KnwH+{0J4~p?tsM_VOY_Q40ZgB|Bnmf~UQ=@`AcyRo8zWaS19Dn)cm-qI@ z0Cst0-C3`|6U8ta>r%4pl4aPmWoa6ARNTzwa{5U|rkyy+oXq7imWn!G^-X9vPuD*u zat;Y7Tc>h2S!6(`yw({5&S+T)ZE2Zbpb%r#<~I=OoW3?k4}$(HGbO)C7|8q)g`WQw{5T%O>u?}6vm~!^Z6Si2{Sd1@!sWxB&J7DKd%U1BAdE@ zRHh$7u}sC3-O|ix-NB?j^4*$@)nYpm_Hh#T-BzE5_df`yAD9}Sjq&ZkrGEMR>*4nG zp?4I!-ijEGRcCj{#A=cOYt10pV{?du1`Z!R%8&CWC80MfHJheDNQ{sUB_($CUJ)Ps zPUMbXcC#}^Lr@|#^QMR1p{yZrRdq(8gCGmtseLR@wA3eKTmWnRAl-Ko+Lc}O5%StM zzI=Y@H=S+wnQkvFAM&lmBwFI0W<)5Zp|rZpr}l~lHFQG}ff z@!S9Mzv+MVY_~Q&_VE4rjR~Nyb!a{LkU-uK9k|6RSG-1him=g~n{R^BuOXI@6tW{? zc_W6bvJxuS>O|Bh8*BCC)IzfY^Cf;mbR$y>KD988+FR#Smjl75gJ2CzP)j0V9wU*7BdE^n+$87Anuunf)G(&-1o zDr+(xr_sv9w0PtJIP_p|eX!=pvCt=Cc~eK!<(>%o6ea5#B=mZ<`JyUlcL+A$Y4J+sZQx6_} z{ke0!Y2~zvBEj$GBWFlrcV+p$N51i6p5wryT?kDT?=^RaVFFWYz%}-rV z)wOO2VRlvCLDlrHX?kQUr=sH|ZF^^@Y1=&QnzrFEeR*kF`$uF@-;-cp>|LAp&X>eP zEA3@NQDaR5F&0Sgv`{~2xS`?z70j+4+RP``b*N;q195X7Htfg<>(lc0z z>%Daxs9EPYWnqW^&iV5tFa!`Mnhe-s(;hx@Xlwg+ic=nU^1dXa#%Sm!F3rPiS7|b? zN~~f=DxZB9LC6X!10d0CEM%V0ka$VGkCk;L@e^sL^1_y=>mw)4G2^uBQ$``>Z3*de zrlV)>+oO=Jp_B&}*G<3w!)G^~fz}J(3Q1^VJXvd;3bQKeC}B3p8|4h?V=UxrO<-qm z^VV(NzfD_Y+L&zLi5Y7!Q_5Mz>)1+cG%X;*0)y{+rxP^`kQzFGYFxmbD#lAoUI6-* zNU9NJC?Yy*9r=vr_NTsd-vq80Y<6$DSDza%nG+5im@q+KrXnr0&Ui~Hi}szdqavBL z+Jul|Qt+@09oxB|H0l6VAX!Oc^l(}*Nwkwy>{$rJ2DG>ncD`|L^9v^@c0aH5gPma1@99-UT8GwL zu58r61LVgXQ|+D3`(H`hq$+4@o$v$lH{@3YEZ!92>F zhYrQkQZaqsS?@JUP^-_>n|t-<_v(eqb1fR(k+eX&aNzk81e>{hD*4cMUEem1U~Dm1 zPsU99I3*h?*p;K$ZfrdA)ac~HV>_IHMIjC=C9|9R#$P>q-{~BCXW-=VV}|g0*9D0c zbGP4*w}*}{f9tnldaI2)BNvlFPZ^wT4UQ4}7_If4QZkbz6s$0qjIjv~5^%{j_Hq4C zd-&K!!V6`XGT0Zc?LB?+%#pS`6vszQ+KU}FLrELl{AOp2o>T|??|U$-+|?-((E;wA z>cX|4a}Zi+-_!9TEyx7uId;$t&>b25&&rH^&08mAtPChgLZFO<>{D`rTViLvrsW1&?Vr@&Jslj(Ka*TSU!^sn^y23chf!#XeGw3kXc3UfX+rXQllP zt8--{x2R=!b@1L)#}5m$Y>U-C33H!l6QLC_D7G0ibAfS7fM7a_6fIOpQpc^+nMPOhtU z4=H{9^xXZ%=r>JC4}^^xqotfgIDEg<6cx@UAr%)5Q;HecvW$9TCn{_jX_iDh7VOTH zx4K007ff@ND#Zd=u&nvWyN(Q+4CKsxi90oRIW`(No2TOlTz~%ZSGLjB(F5>D1ZF%PY1| zrZod^M%{S-l^-0=I2nz$1Z$1}lrWhj#A}+Cn3@elab~=^zqQL=XL)VamRCj+gmYp1 z9t^6JQJzBmkXc0P^!C9t0y!opl~7|2w*P7=t8B>#k^0pI;H?8H4o30k8U{to#_WFj z^AEuAsw1#z?Kl6^SB7+yjFo{*A5kYNq-vj{vu(_2#DkB^OHC6fXUfHaIY}a|{?$sN zK{LlLwU1e4C4|6$lX!vX8%<{Rlo6XL^g1lL(5HEcPq*7-BdMk+199SF zt!(V>a*v4vGL{2<{ISP>^rPqYrbQrFIXdo*H{;(GT8K7@*nmF%Ud%5)$(`E@a7|OD zG@HLsR{@I_LXa32XW>@LjWbHfV0`HMJ{vc2OQ$~Y!O3V7k3D&dmiG*dRh!QRB#QsY2OWn(;~Q{NqkTfAe=be)D+{p zJtk*pPPu4jd>?M+bYUL?(NO>2S4$d+h#fDX+sVvHrvWalhFD+N9jj}}OyLa$e9LNLzD9N&~%j?DwI}< zYJ`Bw?9L{v2rDSYI43Ka8YwMvuc#UC9O0aN9LWILdXbjwHZs3pKbZjK>sD5bfVv{PpP3NmvBw_& z?)Sc<@<9IJUE3~T?tsxSyL)?tG;^+qzgM|z0+N-JGZ|7;1Q4bS@a}w+bZEF-J1#^r zdlAjrq3K{1n~jqn_{7jHZJ{ln%C*M$h~%s%%&n2>a?Hz(Pehp0+i$)+y#M3_n@ejj z*|hr)=hwdfqrW$J?M2)7QFwslsC(W_*?CtSKN>?aKMCF>B5T0A=L0MQwj!ATmK zQ7UqYI!xP5AnPeXW17*WDebuB4YPIBbWa``J$s|ubt^p@QQXqyKxCv2scyr)kmNso zC%bBn&HbFKoP)WTwro7T7jLZjT`R4bg**LSYVV3qvI_duVbule*rro?9AAFvr7wQ* zizUPt)DE|adDL0DqN#$a4;0(gm$S{hchwaalN{RSCToc?$sNInDGim_th24<^J3Mh zyPBMP@n23KtlIo)de?cE6O;s^4qy|3xLQY!?CefSL>_<_oq=;p%bZrR16nzJgzf0* z(`O!h@FD&=_S2G|=G3-v+Jt2Q(t(JF+K^JIG-}T(W=Ulva@P4ALdYO1moSJJlJhF*@ zSHG@$ug<%iQBOaO^?6+j;JTp!U||<%O6{1zay*-hnE6EEzqG&tZCL1>*LMCl^mv{X<972cf)X`i;bay5`eS9;zXsTy$`dwt`Ob*_-S z_Nm`I_TWc8emg8D3g~j`;{d0AcYi3q&@2s>Vzobao!IA?ej86r2|@ zF3{Qnc{_6GXzCL$&N(eFE1h@FXpn3vRy9d_89>xn+cA~it=o{27LR1wyp9oRp2~|+ z_##T4Om|R$STI)iP|n%8#NT5-EQ$HvglS4W5azku=&$LotIbe~k2Ps@fT^A*Za6JUs?; z{RYpAP*ydwKFcgH(Dq$9K$%77EaeWpCO@&uu-z!E~ntL+i~5Ak3O0% zZCfSq)O)%$caC={?m^sk&C2KaxC%-))+2$$xn0vV+E_;^Yo9!QW|@IC`+HJxP&y-e z_f2~qizeQjc3DorpHz<2-1(51=Ui64qYi_CoJXc1slOA(#otOXS!cDn;GDZOI2BGl zvU22vUtU|XO}1g|nn@yX!48H7^T0Z!oDrpj75dnF2NtI-#-)Czd-1s!fBWY9f9)4P z^33~urtb0kPi_9nZ|rQp{nqQoKu1I27xAi#-o+%TS);_pV6(9XwdoI8o6wFLZ@|zt zfwz9e(D(~qyx&6KMWM+zc97!b8~e9TonE2bn(>G3Kl;|~cec=ujcX_wKy9HDnD^|F z|IFNZeX&KTRTcX(H9*wwKNG8`z{0R)SqTM#{+-%1mev?T#yPJ3&IyMkby>Nm_k7ZR z;~U@j_$NLYn#Nkob8GFO@L#YC(7%P5(gB=&)tq+94ObTHovdelGMAko*DR1DtP|{H zstBM_&u-`DjM2`xdhxO@+eU}doX-8KN0)8Ah6!is3JRle@tsa`07;Zo#%qDXL>_XF zKKcQsZe#G;p~FX*a*a{tPrdJbpZvrp-v9LbPaHo%q}*!AD$xbZWq_BQV$QnLVvglo zH!Z|FLj01QvzzPd%-#0TLl1JRoqy3;a@HVap$OHY1Xx4r)oi71sspAP?I^}ci6JcU zTDK8PrakQn)AQCAW6l|F&QguMT)%z$=I#!I&>6pSdwcu#?#>qfczcU~EO7J!P~T=J za*Kb1c_kU0&KG~dyGc*K?~_cX^^(aaHbQkOvs;z=9nAoE5|71Otu+jcfBEH?xM7T{ zQkoMXIcJAWU>R@5QZhb(M9U##3Zax+d2!AvHRe3b$|NTuJGt1E`?wHqL{vTL+DVp{ zRmzz73$pOfWMu-+nv^4DUdUx=ph)2?8{-h5ONk&PEbYU+m@XbY6&`tFUm|OyH0-Ct zch2AV+E-TleGkF$m-moRc1G#t&fL63jr82|(*_|M@; zAqdsI0YU6LOvz#aSYN%wySuh|X8PENmOHp*jK}eP-~Z+%4~HDI-onV)WfM;>!?9*U#L7TlA=NEos3H|uTh5ox5HQ|KUV3D8Y`e8)b^p2B0ZY_SsiPOnR0hl1Z&T)- zT4B|37~Zs{Q`qRI;K#fVIwZqlD*XPrqm(e~TZTF=E33*yhw_Vxxtn)@v^!DzCRMtF zw^7D_y|!qbxNo%5J~3M1BO?wI?_N$9UcB<`-(T6igtsrf z@xyPgHgNp#CL>9|{hjYU|NIMk<9!)5@l=dAGZ;)cNuUSLIX$eJPFwj{LWbaV1565G zDP@NkKm7|E==L%-6pudpjjf@#4%61vOOKw~4Agr=&1mI~%eQ;cFm`iY6@Y`Oq`AXD zmjz5iwF3~8s)AanU`Ve#{hCvoRd1wgJ&Q=EaSo1F>tE2-dnNpeY&>94zb)uNF6Q;~ z;$=OdsWumpG$+*8Pz)N6Q|Zp>y8hKyU)|Z=Wv8b2qpt5NtB1Z03LK~|WT=$c8y(8x ze+334pr7)9Hk;JZ_L2cAszy!eVe81coiny7WU7*O@IP&r8+GKxYL$I)XX-0fN+46m zLiE#D(V%+lh|v6rKlv~4jCg4LLt@+@7o^gZKZcMwd*MCIDfS`^Ns8Y_)Mj#xFMoyDnqesZHD(Y<$A1XW`(mEHJcUYrDxDoO%BOKM9q06nYmQWdz~7W zVfCrBhugN^m|C!c)k%;{4c zCA|5@o8SB1cR7^c;GmN-K$0%w`qI(|A9>`=nNufD9(T@4BxHTC;?5iA%Ru%d_GC;G zeCj$N-s#5EtvxO+C{-$G7@?SU1$>p+pEyBCDNBDcQO>$xN|+Nyv>gr@uDilW z&Yj!FX48hoFB919$#}Oh;n)75n}b2JKshzRZ*Fg$`}P0)fqr*&)C|J9YrU~BE<;L8 z8*)_(1pK8{BCxhCtT8J*PR>JnSFc|)#&9j?k;fk6DCx?zt6fTK{HIsf2#kz=nXFv2 z!g?3H0nE2=+$a)WeP@B3QHY%sE3DHT)yb`25hzmWl5u7cf)z}7xl}0U;QeG8w|DlY z{TM6)g!a(wfAn8^I{Ay4GT_=@`t_^Z*Eg^m1RK_t+J@3v-um1Fqeq*qNpE+DC;##f zFXfZ(Zw5ZfA<)`V@mq5Rcftx$7b;zG_==;{i#H2nfhA3U@0g#JQN2MkU~AQdONUJ2 z29$kL3C={p*2<~KrvcYIGNRsGELiL)l-EHlr)6-2w@%&K{L+#AcK=Xbzwlq3U)~)B zYCy=!X7q^~TV6+Pl!`)h9wcW$u8(_hA_i zDS>YQ(|0NRVedy%8l3sar`_7|+qszzS1F7T6B$TIr6@AXwOmZmdDC?hhd8ug;(nX= zntu1vOV6RwD`~dFAjC~8m7&^_2=Ha^4faNlTGher#qj2bn`=p zJmfKV_y64YFTDmubw!jaZ31%O?|e0LkFv*sDs**$YU;wZx2KFWH2|2`ie1^P16g8P zo7946g*P5>=h|F{yIU2As;2Maz-KXcX6{r=1y#r&%U4;=nSDvvkP6EMPnrS%gOm&7 zWa^nP_ah(v@Splqe~LX?nLfUDjpe*K`xGVnO!mM5Dl=S#NUqqb7OO|2f&}6Xt@EoU zI8%(Uo1u)0=mafm$(K`FWvAtPE!4@1|IK4)9X6ipq|dPHR=#TJs=LlPrr7rdnLdNHm2W8}{-#(q_S}8n z>!_=)qv$v5fSiWY+GZ!cqbR6Yh*q?6a|dk1+~vG-;?x+D&$D^bAk4hG`U0=pug9c( zo|HQo3FC7?y7HDNb96*hU(xhHy#a&_WGqpkr;mMdW-8U}nxq0`_2N=i*K0`(d-dPE z$gNunP)Vxv;6}^qoK!6>4}(u}y1$Qo$FQnww?ni1@sI4Uj0_mcDdxE3%x3D|N!`wP z5;FBG`vLu+Wg9Y?4@07qq5);VQ%}&Gvf?oLgjN(%XbP1W|7cCQqI?Ko!HBC!T}(p1 zpHpnC?PJ>AE)EM*^44m@SP}k~3>h^bx#*SaArn~wt3Y8P&rLZ?`w_Vf#*s}IJL%Rq zg#MrWXWpOv^#nvTeDlTj##I`+)-(eP9*m2CyL~i1WHbY762v2G!)uL~8HZ%0`cbjd z8bw*J0WxOs^`yg=vZKiu?R9`Q@lc!np!1r><3?B;qF(hS0la%N`3%_Bf^K`XlT4N1cg?M9%x1(p-*N*=XlfGVfv9 z@~L-fZC+@q-S=gDoWboUj`I!T=v$+=_(vkrYe#RU3M8r%!+LSikDEaj-qi*OEJkG= z%wWMbM8@F0^P$YkVa{fdAs|u09%E;{iI_bF3xg@9{naC*(@##DL(305eao$ou@-WJ zJwn&p5rAuKHW|V2H1$=9tkjp!{QE*voaTIR)y3%c3|dI?Wsyir5!#(k zvTcn%rllZ_2FeO16FnCG^Pl^i%wbPNhd3~xUx%{9b96dvY7Jm6Jd;Yo8vDL!+e2cU zs&dCYgjsZzGm z#>AAG5VFluin3k~Acqy!f|P24AcI`JJPd)yvh6c;GLvK!PuNH5`${HS?~-h(LikF5 zNNU2F#I?!2SX?`af+8a z0YQghM&ccW(jafW;|+G@-1ESkf}rA^Hc&K|K*D+LR!s)&42oqi#>wbywu!QmgYXHG zDP>ir3HzV={2DZ41P^2^j-Wp}3S)1CzSIt#L#d)$3yv}knm`VZZ;UR=X<}!vI+ROM z1wuf3U@EFu&ibxXXQrsnnu=3J+)E&!mv?YpI&}jnD~Mm_#n3ErBwD!dTNNr$!EcUH z=2bdN0pQA zrqA0~&%OAAFy6w+_FkF{a&Mq>i0vRSf$r9Ii%5;rY9dI3)_R$>BQZq?8nR|C(kR2d zzHOR}$b8m0XHNTK?C<@lGe&48U@4{~q>$hsCLs9X4}bXh zYTA!Orj>->CB4=ieeX46GhiC&Uk4`F5dN0WD-Nta+2-2IAHmLvoAC@ERFA4BhjWhmElu0-n!`X=@^Q}O+yG>ko%R_8C4)wCu1Lip z+e|(iBiinfAmuFH4N1nIbeGC!O#GGgzh#l+3bGCcWt_t<==hPt>uXDX(15e2kDojf z(>v|pp~s$j*$h?zw)gi6_t~u*Z~cY8xOwA}an_e%*)&W-{?qr{DHqy1MCaT>Urtt% zm2PkE)F9n?hlqu}bu{!L7;AG%y-?(0AGKx|`?$*~{Pq^*9Hb=$>f3a6r68DdFK(ygCjD| z1ppd4I(2CEd)G0`h2#yW18tf3lbAAlL_NvN+cE>8Wd zxuY$ZGwLb2x4+NGaG9oab;cASJKhXNhAIMB8x7LFcq>D@-9D`tY@pxkiyLZumcygx zutW+56(@6`ez{=vR-(RK(U<`0vH0SO*RJpLFuM1i8S}WxIOk(A2kx|8LtO;gGOZ6(^;pX_ymr6Cga zxnvM1EKkbKtkNCM<4xj|GpZ)A-AAa~@BINNOM#=np|K7jPd|dZ-UJ3j6KY3qD zJveZl4LZs?Yb3zA!OItRK6osoZZZn^#K`;rr`e7u#Z2H_djNg-Gxy*J`tgf2ZKQ^? z8|LrYm*1J(%jy7E%tAJAbyifJyp~f9s_(pO%&3J}y=y70g7<-o&&Q4*f9a){m~ymK z&-p^z-PN%5Kv6(rOYeLmZBb=w(-gSY7@Tu$(-KiC+83T7H!_HAA8eZ4@{6KtDB?mn>#srFo7r-fStx+dRR&SCo}8XYG#j zgIZhfBoVKbcJ}cykJjtWGv{2JM)Ea3@6=2=(psRU3D1GIj0#a5yhDF{PRs=yJU~fZ`3;5cl}Tac4*cDH_qQS>1qSmxZwnk z?#cXo21+7x5<>3wNf3x?>dte{v(@~=Dd>i`1-Y;HY{Ry)JX#(OL(?XtUdF<<$@;So z>~hZ=hQPiqc-xIfJ2$5{uTwvn5`}iy?6z;hbEO=A-Z_MZO*ov1wZ_ z1jIhFBj<5AG9X$yeetwim%C1@%G|_anjJn=kh3Bgh6~=M{Mn5}A za_fjUg+m<(HS09aHV*Uj@uz_Ne#G8bvatS}zwtew(;`V_Q^KZ+ywS%PGVV|Mu-@3> zzi|M`N|2gSeKKjUYkoQz@AaBWdNgK#QGBkuXMMS{Cs9m~m65D{2l|! zG?zRDW_<`Sjl-t4ouz;sk7bg zz^0w+moL2e%BIVs$u?jsakJe)OXsx&QtLUVQOIVJ}&-w$_c!d$qK!r^Ckv2s>m{Qw~Hk!1r<=bAIsZ zt^N0(Ud411`{|<_Ya4XS*wGlQ3y$tQkVNL5a#IH-%xQtH!dkmH-FgS0t#03ms#Dli zbvZv(m|*9pBFSnI!A_K=CruhKEjqKR69k41-!X0{RTEb*g{VEmAJaOVUA0v*s ze(TF$W>^Zdp0sVFljWLy!GfvmiAbY*-cSx1YvvPrDXSVqBMk76F+#5$F(YM(ucZZw*-uq_P*c;gOdNITpiz7B(T~X6CvG4f??YxEIK%%7?qK#b}jD{~9X`eeBrVbt* zdw+c!c(N|`yNrR`+3k_E(mtOlFXyO^@#m~d?)pfCLb+eoyeS0gHpPr-y1Ba2ryL~u zCrA^38>>tEORIY&QZUpshU{p%+nsys^!o6|?Qt(C{^V&Av(G8J;+1~1w z3^tL#g+d_$Tjza}FdsgA#0AGGJBNUzwSqoUD)o}>{c$fWJqirb>hJtsQ9Yb&p<&bE z{$kndEkIBLnNqZv1y^enL@h-sm-586@QZ)wgV|g*0+_pSe!P8S&AaSO=rgw7fpJ>i zn8pO5CE914Ct+?V+T2Y_reu*oQ74LD)tUZS=*NYhJ?F(c-Q1%aTRk+<0lzh?V9#M` zKnGKkit325=gLKC49yE6O8qzsi!Int(6$a7T5^UQ43nch*h5IXCXrqf{ALcOP0*7J ze_HYg+02v5A6M|?h4g&WvVy)t+5b_eW%%ZJUz@hdbAc7)Thu^5qt1}OIpnWe_Z zw0GR}6J6*we)yhdw4FWYVgOM>@Q1TMNx{fSPM6Uc;dJjhv<1r;j6| zo)4Pp>3)!|Rw)W{3HQGH&NfZ+=9_P_+hDB89R<*L4`3TZ1|!@uA>>SLQ_jsSS40R_ zI)wH-j;{30&<|VF2Z*0~@c38G?RS2d2o0EfGP#!3qF|Bs7uDX~>Y%&T)vZ|d=W6;K zDY+i_Ox4W2%i=0Fp(G**2R?`vsLVZw*cPa4^ufE`w=1)ax_dcx?#h)b&ph+thaP;8 z3#FW(f9zu)D-7<#A!>!mzyb4OK_)wbz?SDbfwDviK6u?TsV{kpG)6(G*{Z+L-JVm* zbN6g3g2y737A+L^)S)dq=fui0C>qxbD?5BJeZhHb@(>L77W8u{Q1f2gZe+3@DxR!Z(# zS>l0;rNPJ!Mp+=k(KfeT*njBJy_I!9OMotd_q4IQ*KF_JIJ6w5<8F6MF}0Q=8BEz_ z%JVo$lFQkbo>gtzUSXk3B98XBWxp=DO7W&$BE&xTNnrw7@sT})Iw2kX{+Is1G1uNg-y>R+Pye;Q_(MlWgBd}#-Z)GV zlShn{(S~+w5(ldW_(y`q+7@$f0uWR*vR(oJ(2JCajxCC3UA#q8y$|a6m$BwR(+>$H z{GK<*pmxeYDN8Hg0GB$Zg&eoB)@cOi#4tmN5!=uV8pm6L1E~L-|E;|(>j+~p&5G;nJs2-X3|YoDM06kXjX!QoQ!x=;oTaFm$2&Nr^#yY_Y+wHJZ@vHhPhY)y^($Zb%K7u>ne4e8vRvrAIG zs*93e`H5-S4@|}%^h3W($TeUaJTn?kQlwgtv~wq{7)^8u#h+rO{B^x{R)GiVM(KR{K7BldOZ|T0cSApMIWFTda_EXN*>e z)ea;B2Wu@q2?@XDe&$V{v)bJ@)-eCuQ%^m~x^hoE`NZi{CpZ?bJ9Vx$t%I9-X4XZG z7MBY7(*KV!a%+(1lDSxSku}RMUShi}cJ=C&%a;~ac-;XmG*reTE+o?IXTVXf)7eXjr+Teb0IuCNJ> zbSq-cx$pYe7fZ6uzo*Q3d!xa$Y4@GIO!3zGa69$m$PLhLzvqwFMTNb^sG)$YL^)M| zQlOtK(n2mSPs_GGFfGbj%iu)mXOH{5jrQh|L))X}eX=PN331iwX*_iE*8PV!SJw|Q zgKubC7n~#OX4GT}fa-zdb(WM(XQ>OIVZ6_Nt|?I}74017Zr{3jJXg)hnSMN>4)&hQ-{g* zNZFYI#WfHPa?De2jk8#aDO74Z)<77HZcdW-HpO0w1bO7hRrMsXIp_yvZ+9tYy?iPQ z!MhV0Fn8R0=$@wgRxc1F;{MUT^ffB~l%~8DB&@3O&O7V90qc!a;F7WAq+?7+A3NE* z8BIc_JO?fUQr0W?4)*ASqf>VNhEXHN$jjVP(pRGyccy^9X4myS?cO(Sl7f;Ww19>P zjkC^pQ4jmzFa62=W^+F$cf8#jz!MK0-s~=&oV-1FZ}{MAm!VqQHlmMWb#$|Qn=?Z! z&P5q3XO;Jw?P!HR33yAX)FkCno5k#UH`9BYqM%YP>sU><>ksLU7g6FyOC!c)c z;~)Fz6Hh$0v9ZQdVAg7KSsb`_Dy${vKso7TbQTwvyD1D~ijnW394=hFdX3%oMRv~T z&!0Pgo~s}1!bKUi(7*7*SFRLC&g%;oFT8#3E%xizu3h07K@Kt)dc#ga5qWy3)RZwt zL!tLvz`$J=xMRDr3X$4Dlx{W7%en8;G)>N#LldbPL=w~UOP7j*NI4h8T%m-)QnyaT zOOZ~WbmN`9;iTw^62g#ddu^xN-QVSoLN`r)OtG)ifc?y)$3;{BE&qsDy66t^J}}Gv za5QKwm>9{}{kGlNT;B)V%T%0ie6|KITsRba0NmI(a`?#c!P3Y!A!ekMoj50H2N5r_ z0piGQ)3(;zm?8>4AP*=yYhpjWbn%@_7v8yj^Ty7to7@3TeW!xoPC;U%n%0@H_{BSW z&gz@xd6ja+*74S;>UV-c108+T53A2ZL(7}^5C2o|%XS;BC2$6p|JGmmro}?>W}VZz zhIHkuD`8e>hD)go^2Wvs^CHmtz#CzDbn_uwLXrbFl`?yNw@j8IE`8ly{RNmLS9UInF4#LFv!Fq0 z(MZEg9v;uwW47gvpZz35;6|0n66p$TvV%b2UAlg*Qp(3iG;}X?R7Z-Q#dzcQZdWo~VRAo8!Jaz!a_I>Y>(2!}I z;j6YIIU&l+9Yo^t6zB22uo3H2E)%Zf?yo=l`fc84ww>jo&38Wg!MB;oTdsfVHlnr( zr(Ar-Z-!$8=o?Qhw)^ht%U$)oUGiNWKi<6$0JdddbDdWI`sA`K;y+QBh^cE36`lmPPIjAdczu2F_cw-w+Z*JA0YXkm)e$=C=f*vzifrAEwJ3DohIOgx7+j7( zrD@E-{BEhayMGs)Nq`7*&O^JPF9LbFJlM|kiCD*!u>6<$Butc&_DKniVdTDD0zdWA zjqW{SLSo#c#W3@8R-Wrq`UY)3ABsl2KfithmkS<%5M3Mghsp=lOA z>k!dyBjhWO9q;TGN}3b{OG=NJUD3qdu>^kCyWSfq4%u|N@#gAiMTT3Ew`Y@%4&p$n zGF&AyUBq_a`^zeW`1?>;S*^>^THE$HBN5l%;t%I^UJPkoMw@l}{Dj-Y`)gips07hI zkg20jWNrdS5?nv}G&C0uj`Kmp%LMV})#de9jARE0iP}Pq9!p^%_TAwSkPR*KUXQZC zB9dlR%PmPPljtSyBs5+7{aK(J{ud8+mknypZSCaib*@4|OZ%LZ%o8x0kVrloiK6Pv z#7)x-#XuJbF0y_}%{(J;;RX(@W+_Wf0sup~`}S*h_TIBsuz-BXhdCxnXet3Yp}I)6 zIsu12D6{S(F@c#?XcAOShpj!-zdy2Fm7Oa!oAf1k7dcD5XFuKzPMV8Dly^t{q^V;Z zSbIEparNBqg^zruQK4&pyuR`LQ*v7e7%cQeI}{r4Cxpnvq-Kj4)@ePfHJf{y?J3s6oHK6mF$SMaXq%=_2`Y2m3_CU} zLKPliTsase(hft5$PPIQ%#gWHc?IyTL%F8Q3kVpNjq2sLZ)Kf%cWP}Sf{f=4W})%f z%;^;d;Ra@?s+Emo257H-7pg92`Li%Wa7{gR`L>Gzrv@u)DM`>F#$S~h5LAg znN`@P!Z-%z(=S9++^r6c+&gy;oXHUghrW5vi8(Y)>zwSa)=fp$tSuF?jlxRd&!}Xr z{uimJV)4Zqun@y-y2ib?fW_Y;83`%+X;Q203y+)pL=Z9g(6pwxg8h6pM9t2ruKU?M zZDG0KoKs+k%>H`-pd89{07UHbh5$%qeBK4qTrb&sN#4-j(5CkN1|~Kjz77w2R~H`~ z^?L0whmV<+iE;PmUFtDs>66zrsq7I9qjBG@=OwzcHdQ;98VOHJ6wDMGz3@;e2Cass zNSKqdF}jaIxO8Fv(uFeFM{RTKAfprU{FvCSC53 zqjZ@V@n-(Qvt6*h-)%0xcy00Wt693kquXiKgP=%Gh+ z`cyDGk{Z#;VG5ZVwqz&emdfscOWx7y<)Q!&MEwH{FS zkL+JKx_L82?o0YR&0wqhPv4dphJ|3-_Z^3D@zSNuRlaj)XoU>GMI`iT2ry7F@bQ82 z0MzObE*k@q5eP3vtJ+KaEa)GL^h?Y0jUr1l3*5G(Qf|}f8p^SZ-qAG zwKnOIfBygTN06RmY}gl0hbKB2083@)(a9)=yTsC31P|1G9iaX;rV)# zY|QG`!(4ACe^L>&yr|YnpdVCTOs^MdoeC?j!viopCLF>rG10b*;Mx+!cbeJs+k#@F zzRR(xCAP?|<{N1tOKwOK9qz3kd)K4<2ckeJr*g$uP!mZb>;veh)d=h7@`VUC8BVod z1oGXd1k;*w+ATH!_l9FH)cYoMY5<7=u-ewg#m|uvrR2vvUPh{z*9jI#DAOpI3l#$Y$!U+Ra_y2}n@@jCTx|ZERlr<6GUe zD+HiO01HXLW{qeHu$DBmeA5nraG>~DfX`lp-@4Tq2ZbhC061)s41z$+hK5S!IDd0@ zJR@_(Du`fKJ?q4mTXXSh^-DsZ&KedmRkgr#=-SWx{(R=mV5|FXr`i*>&0FK3 zweaenrpkVcihFwh$ueas$iy+kCJwKUKk>wJcV}pylPbqh_%r%?&wDmcg`>SDID@vuEb_=$@$kDG9NX&i+neXCmQ0Q7T<41UJX zu4Vd0N@H51r9$OlqMCZ1DF|eA49JRyf9@~7Gs|rul-#%Nh2Qwq7y6!AO|)Mwc1?2` zL*=s7rVzr;&Yl2TXacSx5`jg~C>_zIz>(Bkf1qG5J12ldL-W5`9lbJoCZ}VX4q!q; z*E`8vF;5+mR(?^{SuNMmTTv^?dAZzBL&q3LA5s7qr9h?bJXoy(G7q#76ePs3V|%SE zMIoqwLB@oLZCGd`1rZc5U1T0xPKf6Xoui!^W%dBqab!}J{&UJrYzAG#;Tbox+FY>h zYyt87UEWL}sG;W!ewIQYlYYmJ-aLAR*00-gA*2LWQdcHZGLhn~8#JOO5RcViPcNrp zfVw}JaoJ*>wgU6!npts9V09<-DBRrP2-MyzJ8TFPs`>HRW@ov#Sw)Htmb*aIlpUjV z^x4>mjLHsMYVJ+jM9O{s)#qM+=O>=IlyB~Yyiokid!BgtkKTM$=s2Y&09soj2R3I$ z(&XvgM8yv_S}j6@d*fnrIc)^+!`df2nfa(M-5OPRAghl2^ci}TLR8RIIrE5FEc!PEU0eW5!%mz*;`r-qs z^ZDnWf3ft%Hy!a}Lw9`m^3@Hb?UfDe^QD)rzJ7H8wGBSKxOJz2IbL@glX^w~=j)!n z+Rn2ryq?wN|7g8g-R56GfmBSWJr4T2VT4kb{=nS-?Yx!rX9D^yP+ z;KtpHW;!V3=8vLpp}q^%v5p75^mA`s)580Y4D7VQ?C_L%Y0Wq1*lbdiLFcz^8mE8- zgkih$;SqdE5o$L z^~Pp!_s z-YRO$p?FIy`RHQ9V;@4d_F6;geAAyjwB;rsz>z&bipOwZq(ihfQHyFWh@(~R*#Jd1 zbUl6A^lM9qfL72lqoj%q%gsCJelYs>;xR$NKS-c31RR$yUU=s5!JUUULwm5;>B9oJ zF;q2R(dF^c?(LgA3WBLm@DC=Uu@DnGyw2>;!Zx6F&M`trYU=yo{MkGeg>TvP z-MWhT2G6Fhs-JTL#Kg_+)9*Tt3s+wp!RNR!LvrMrhg0AOK&RsVdAZ>PHqj~~(G&aB>hHmK$cPpajCR#4~IM|jB7g3~IW-(Mco46J^Hljdny zb+IZkgv$s}NWs^Rb#I$y_@a&Nq#S5^q6x>3UToiVO?}3GfJTopXh;r_wk#_2+8hyz@gvZ)ZqOz2yD93zrA6 z&tYA8@>*PU+@_3%(Rmvl2cQ>UTpX`(OdeIGz`hFHA;dVw>D2&hBe){e9Q)&(0UphQ z8537wMI;!ROv#@BEz72EmfukGcA6WQd-QSCfzU?l}E1Yb?eyB1h7L+1!DvsNLOQSXix=OQ|j-v|?l*ZpD|9*Wse)IbEVMcuDln<|iM|Wn{;&p_X zQ%-)y9XXu(arkOHXImyJde`MAtFGeZ<~9{3refmuQX2=N`qVko+^l5ajyY{=(R=TD z*L&J_G4u!qRG;+e&1=`R48GH-z>Unodvjr`;UHlyx%lSu`UXwd^*s?Mv|CSKdPCMJ zCuy74pSbk;orAnNJ#b`(DcjgJ_P6a)Y3feh4E>XeNUu^{y)?_AcRZ-p?_p@J^>Xux z$M~Zkxn;&cq?io$`}N+}zW(+%Z($pU`p9|%q)+7pTHp1X#>e4GMEfb^AROaRznc+3 zM008MHnB-X>lX{lP4O~L#R0W|S*vIiXub>$>Z&5{we(pl*M|O(_+L+q1xT!=RT08+ z^{x-@Cb+du2@D$^s63aHo+xaQSb%IMnGgda$EGob828$y9VByNh=$x7W2x4v*@8?q z2-Rbq(rPY~V(!cR>4<@23~do9AfmZ8yW3Vbrvl=%Wap`j+YQTklX6NvWnOrpV+a8z z__-O3TCvkc#XdSG#)PIqXd&{Z-OdXXa(-n*?734+kOk1duRGA>xNV*~Z*PA!dYI)* z741~#K>a8Ct}peu-hKB81RPd3;En9jsT0kRRWzO7${cDYibz{?;gx;C&yb(lTx|Su3L5ZC1Dx9fT$)o>X^CpOSJ&w(*xZ~1VtC3n zx?E-4#7t-=Ovw0a|Xg{0nR z{)x&q+aZ!WA*i4A?q>JOV{1s{bL8YALZx-;isst)>x0AFL*e|@S6}(ox1Jk#U0!>A z$h=<}^71#XU%US1wKq1>u>(KY&=4P9uMIBz)~!-bFLqqa2Y$MB+0FXo^$As&ErW+J zuN>9oXQi&n_E%{#>JoS3$+y|gCkB1wui)=DM_IJ60?1;ybK&A8Q5e?nvxCGZ6Q-$P zVyd23ZJECzweq0jq})d|Owu159j}lOf+kI7*YYamZq*&F(s4?woYt~2?-@@$SVzN6 zmYqcg#n6yBwDH3JZf|gkl%iMc=`5?rKTY~^Covnsc6pT zuK0E4u;CtSmq;|1@AbBl&-JzG+u%8D8804{GirweOYajj|N$!+*5r{*~zEay|~(( zYSbAjDwu3^E}|$#VyI5(AF|0t<^Q-tWXO5Jv4ieipLsW-0=Nth1Ci0$o5YF72jOlB zCCq-<(f&S7I{f3kNwB-nc+HBpzQ!+S2Hx>4pIfm2{?z(x-Oldv(#57kQlXdD5Y@cA z&i+`{f#-86YiOcosh-^9`r6#_uj?viZqrx3e8+ujEJREB79puX;AQF!5$8BGb`3wk z5E^cp-KM=|%jd2iTi9_z-90 zU{G`V@37f?)oXfYb?N*9ECN>62NCg~A6(UtTMq5s!5{giO-KXBg8|Gxa4ot|<%()| ztvozPEx5w4#`0|q`u){r_HFCmk$W~X@w#%?ZPM{qUU_j?13TM`FMaEU7oHy);sf8y zfMOeZ;Di5mfZO2LhnL|CCxjV%xyw7c8z0P(?apF0N^$#UcXGkQ*vX!Pr+IbNQ3k)X zX=b^g>)mmuVpR#T##CL`8$j3hqIT)><=8Z8*q4!d$(bh2D_>BPk4f;~Cm?gF)f-sK z$$|dESsK`NtQQjlppogV-!RA&sIRR0wHGYP^0y|we1plRNpdb|uhHEiHULE2U%Ghp z!v3}0eJM>zGi^y*=??$o4;Smh)U8;hTd)1Hc!c1pbW>8|9}2xbER4)nVBM-s2%(9?8m?jLGKfWFR7jL} z9^c8jHm`J4dKk|MXtr>gS2`=ZnX!Z66r>T@Sitl~z8~Bb$AoY?wyiYczRJ&dZVrZI z2wDn}37{`RRjKP(ZAT%F`<%b`8Sr{0;_fc2E|_&>{fp|L>-DJlYF+d5aDI0FFmpB^ z`}n)tWm3=VwGFgW0~JE2{#5}rbEqKpeO~d-3wLD2y9Eo~u%#=lJc7rfoqu3&X3fms z$2N|9j&$>bYP0L@2QKW5R?jThLkg`vtk4@!U0d0}mU$Z+5q+wtJTCG1=fCx}uYYau zUjrh$vcrL^w)4TfCukW&>D-FhQDnX~Wjmeu1a_W{`;Io5Glxq5U*c(^>M z_L{_cwFD!5F)TtOzynpv!KDjXL+YGUtq+#zwHJ2RN31z(%6;dBB$2#YZA50hCOpoq z#n3iQ=^^UJ!KA?w~j&I{ZYi_ zF|r^iC`yX|;y?GRfgeL;)#}a-AOo1FmG_L%p=LfLO?;S9930UnGP$_hMobKe$wJ_g zG=pX>vgM9^i-Ci`^^-XbOp2oOF^USfswSxpw3HaAZk+(;Z6g4iJRwg!>JtjPq7%Wq zR8Tr$5{!cp0|(;Faz_p`^^UASt9T)+;s3NuP0CV(6MImdSen;~nZ{ku1A(!wtTxxc z*gi10S0xq@h#(M9X$PUA0s{mFpd(QV5zN+a+#oe4P9~i=@7zhx&EPb3SasiZC)ffh zZZ+l}2-Ib8w%yYO5cdj)W|sP%Z28N-^tvEROCoTR~&F)fcH>V}?II+uVQy*QghRO0bZ@sw& zNx9Fd7qB(ST65nG|9f@Vt;_-JqgmxEuhl>?HA0S|iP$u3fN{BN?an$bZ!Z>yO|#ID zk{)-ffsijBt={{_)n!h(@6}|by-J@`r;__3V{e6=Jm<|qu%@_k0MyCq_T?av()tBY z9IJu9RNwDkpR##7cCb@I%jEGT7!FJ7v`M5cb&FljV4wbhi^}MvX=v@?Z32A)3CvDM9k zn1GG*=5nSSp=VXKfb3h8PQ2Cz3e$3Yo-6Xsu8}7|C1W1vzGif>6xcN*Lmc^Gh|2+i zp}%b`uiiX%cTzj$HTtOsfWXKE!6=l_2E?+I%<7RZ{y+-tx=X71_22$IazKnoL~_lF z2##{!k~XpVs%V)S(pRcJU+$<*EPDV{HP)LK=kCqWK_TbKy!Sv|A^hgR3pA*|sx}7| zX;_|HtjtvG7VP}o?|%Itm5&iZqw632$TL@VS~5|vWSYTrYR#PaNoX!pi(8S$beU&1 z735|BI>Wl0)2}XodwcoWZ?0`PeE4*~9#pII-vhqnlb`(LU-`>_`E#H9+@L7tz}O)v zT^G^ncF~3qF6>_z4or3Aics@=-gC6E=n8H%t5NTb*Zk4^6wC|eGXTm~C|GV{hB;7i z_D@~kc9t7nd-b`^gw*i{4kbAcjj>HwQ{>EioMxj^S}5Iy1Aj=mzE`ct{9(;oaO^my zb7nG$dH!A140ktXKGlAJTHTn~twz`4|JUJj^@ML#oVIWi?n&@0ZX~k|h8*ZaAO3)- z41~2C-Vd{bRhKdXu}U&Dhr)S5--k6Ni!;b15k_n{taQa8#wPRvYPteSS%plL)=9f# zg%v>JT<#Q5UG+&Oe*lO{>&`3XmJK2yiMGU6+S>~bU~==R3y;6!nGQJVVb(4k-nx)h zul>E>{p5vG(TJ*0tT<8<5mMJ_mf|g( z?y>CNez~={kn+bEiOKc(0|3;a)zkZ3l`tV9^*MTC@0nnEtO}iXj8Qu~{*V3_KBx3G zL@1J#A@|FF{{Q>@6PG>^W4d$e4pT^}XAY%M(v*^=5b$!jTiyf4rqR>|TM@0-N{tbk zb+GvGlb3$w`RiS?E5xgmfksRk1)^oJHfF#k1d&{Q17blV7W2Mxo#w6MU^S^8MeeI` z5gIWTQu(UKHmSQ*$1|+)m=M~)ETFMn#`Z$ULA#tKcgJbx&INi*Qtp^Tdto6@?bwTy z$cT)M5cqVx*x?RlQW?novUuM_raKMYYgUIfP4s#}vVkUW@J?ju^;Eg6@;lWsWajpa z%@+X_kPui@1(g~IT6RxK3dUF7@vhg=XU&@csU?=IIiN(}WJ;X1d2wQnTA#Do%r#W! z?aAuA4DSD_x8s@VH&wScvkEZt;!XW^+h$~r-q5kQEm>n|04#^stO=q!NSzv*FgsU# zNou^`P0U2FfvXmS9mV;`i=@Yy0jax_9TK__4A+q!Y~;9^S|(OLoL}%hZ(CODI0i@T$v&SYMTa$psM|1v8mNmYrpPc ziAV+A{~(bhNo$eho~P8Cfac0HYB&;Pmjf{%Bn~mF4zKRa3CN$GdEeOweeCW$GPpe^ zIvNf5^f#_uEd%4%uU_4Zo(&Y-K4~_9+^%hk>emP6^~(D)ygH(1SR&$?w`g6arz$gs zaJO~O5KT?z3k>kYP`_5Dd&k_m)|u;%sn>+7omOJ;AZ!kZm{}8J+cX0)OJFt~-)t@w z?52%sI!_U%-2v?cyCoa0wuNwLF|0wqV9<>5AWSEyW;Mqm`FZkJEXFi_(vsOZHr-hQ`m6~|7mMT( zj%X-7p>oU3({XcutfJ!L!LIP*_!yrzo+PbomYusz6ETM87>uhz9k;rBJ}XzdOVxMI z+1aO8jWJ*W^C#)r1^G2b0DoAu}&Xb^XpagROES|FY{a2f=Zf61x zwu*iaina2qmUAA|=%0J;`LxIg(Sj$EMj(OU1^?OML{X6#0tX z^}Rv8msH&))qL;_0k8U%Z?rB8lXHfLF+1sE5yuU9UmhQJpym4@Yb1~G__e#)2H2L*7YNRerk%_{lEv@4c9OI#b?ik zjqA}zA8nh3WH}f>`v-SK5)+8@rn3F3Mx**9scACpRJt3b^WMN*sEQygJ;fex(<}B9yKw1ot#$Wu!*T4MbmtK5f zweC_D1WFUVu4Jh;hwrK>0&?*(bvyIT`ONCp>8+3vYcsA^(fzCQ#m+rJtW=}Cu>c5S zhY-^cp)sSr(B^v`C`{_56H}0%HmiCS=#FyS7?~z3=Q8+IlJ5f37^2to z8P6mouBOIBL&t}SOtR*b3f?|Q*pod&B?Bulp*3P8fMkH=SOG$y?Oc;8TS$4sR&!PV z;2gZl=zcWDX0O=b#`pL42aVw6a;It9*bEj2^S(@-v$vTP(@6>rH>)LlCJIPCA!G*J zwz6n%_kBiinguCR4t}0B3z!aTloP0gT6G9S#ciA4X4~Li3+ITvyHdZ^pO`y)u(>by z%8QuzykgVB`#2qH9{c3Qt z8>#TsLAM$KsknK~2h8js*&SHRfrgGghG7I;`w6Mq|%=&xf62$+qIg?{DhuO#Du zC}3-)$L#Q#3lS`XK*j*Xa2K1x>iR&=kNl8}kq2k)%WLC&TUYu!Y~E15o88l2gc#gs z5z?kEw^$5BXMNXQx^(H??|Ju7cvh?6M{5`D<;$1awyi=z=i9^hIWHG6Q7o>+aD=R= znUhh@*Ms}>&7xOd*}&Cbe|?~0-5}f!4>rlTGqHB-zEIhTPgqrII^Pcb*{zxBY{6S- zrZ!)x-=yGfeF-&mW`H;!AKYf3oZpo9;q1MT(zZ?8wnLR-aO57ri3oEzeZni>Ksl<} zuDQyo799Jk?+#OUL;55m*>5NLCgfzLL45)nhHgY>oKi9i2ni$_>CT0B{_M}LxDm9j zJ36@i=KA2);@TU(@wfigZa0XdHgCT1>Nmgk$3yQwmp!GFFgEZApG5FrO+{So*~_7> z9?KKQX<>3j_y2IhkY-k8b0-qc`5*`l%l)>eSq>fY2}v+dx-dYqjEiLhObJvNqhR{P zmln@_7<0Hy92f&g$NJbW{cB%o!$NaPX;r$qovF=97W@LorWwimRG1*8UKEacfEdP3 zf!Qu*&|Xd3cCn026XLKIg)}A*m0Z=|Z7m#HrEaYQvU7$t?+%W}BTC;ds+V?{T+z`ZMne2n-sKKv4rb zNNt{-SIW-nLAEeZ1Ecl8XMFL(#fz6N4yCCfr`Z`R?2D#tn1d^&dVLZB$?NBp-`hr; zx!K9ep+6p;A1NV@aGGdHaN&{=xdLfcT@ApUoPC@`4O3R1E6FoptuMFgdd_p__weS$ zkiOk~KmZkSg2j~xKLjkiWF!KjSo<>=htdFG+3CWr z+X72cfRj^?;DO&-iTA&E=E*Qt~A`~!|m-P)&MgITP5DX2^msx7;{}`oE@FC zd4OrN8#08DQtvg0s;K;sC(!Q}8q)DQ2X_X@+fYyUM^sho_?A!K_Fb>u(wl7ltenD^ zKZvQ-=zR`PGpKT88~;7zwHvv%!-L~h;d}2ppMUjpQTru$YHnrnvZIJdWv6n{JlHn> z8A~ZUIr*bkt_*5pB64)J={orN$tgQ$_i#{)7GR?fW_BvfvXID14OhhVB|DKrllOn_ z(<%bPQWe4{Kk;E7*GVor?R7=RgVAY!?o5G7D3*I^mh_JI96bJ1v^Y>9-8sA^>!bGI z*4~S+!1Xstaz8MC^s8r|e|BK|5s^O22z~HAMW4F$rVo&(!NT$?^D3avQ^gn&aftGK zfX#PN=M$`JEI!XjLuHEe-2qI{M63&mLx>Kel`N^xo8m&>NfIJbSXnsu%=fQHR+Nu8Ii@AG13Edl|x^d=u^!+sOc zG=|2I$$$YF3DgMCo8MJ=skUNI?D!`ef%6P#)OBF?CUgP!X)Z9*I>1mL8ud(0#D8Ja zwnM`_1WLIV70>Kb>XMX;m27>m=CHt$+O9Qq3ti*pOalT2P9inj_WSd+t7E3cX0E;+ zeffql=>iiE=gIdSBytWrQ`;y{6doA|!TCwhVl|kl{@h#Y!_s1vyT!ba?m|MPPZog$7=E`Yxet25(r19NsHf>y^&j)npJ|&42Yoa1l zK(gc407yzqB0UlR&Tsu8!gBTz3{GO36+ujO%$6W9U+u!{X>p7T0t+TB=|`W~dki{( zD&~8(&0>^oOn{lyS5dzk%`dK>lo=%ij|=D|%Kd@+zIET8cQ@*qx9ZC+UyBztYJ}62 zGLeZtH_a55HF~%xCF&qzNr{UPtT*=VmoT)g0XUYcJ zG;z8$EeST8)gk05p!eDyAo_M%%i7g>y(LX)>Pxn}X^gL&zHPJoDfHLuu6@2v8rUh$ z1-swny1R29EF!t|Zu(+r9KIfNSyS8kdrsNiVz@Krq36@EFu&6YV+dw;;lln|m>!C*Zt&<7fbmvDw|*9jt9yW?l>!x81!B zFM?$E=uWsaly-)h-GTFQ2>U(zsih;2QS3~2Vm6`V)GI(WiB|9HBLOI?MdY|xcFP@N zVgs+#gEyVD!m`W}+0!SfRS=$-s|hNkwXRb}r33Rz zvh)3qh-RG(-?88!tln%y!$(?gbl5vbxj87jP;nQ`_2y8vq(-;Uh7ZpY;Eqs=^{KBF zbyr<;Y}?rA1%tQJYM;xMs796U!qneB`skGbySu-)->1Irzmq{;bA>pSYF+9 z>Ih}96>1GR6ktstb1Gtl^DX6+G$ZqE!DoK_C&K&RPfeQ$C8q{~Z{K?JSAJy|asvhW zi`2wsv9lQJ8;ocsH7oQR@%(;RB}*!bYjN!U>SiG!Y#YuA#pbxnVhE>freEZ;9AcOa zSVVx*<;UsicY|7ICV@+Z1;XLY$8NkKWz%lJOiL>jk^Evhldiwdp@!z4A?4H;sja&+h-! zbeaqq%}-X{6@14jBU@N%{)B)&_bOnc%8gUy#PCr=P^m`qs)mG>ohgZxNGL)YEB)Ka{5jayW+V94`GCU zx0sh1y3#Ulnqf? zq9V1DT??TPZ{%db7(jjD=2f81FIq0&tg|=fXOn%S14~tmPy3Ej}+jo|C?p(Nbwbh=$V$%{wR6wzYd3Uj33={m=>H6*+ z?^NVAJE+SQz&1vDDj=PFISlJ$c61WWQ0yeT2&iWB@k_MO5QL*oeg8X!-ZbnPjlcpf zUU`9j?qB+Y7G&=dfao=Y6&$qW6_k&!7MfZuNS==2RDwjAeo~~jzVE>=>$d4u;l=Cc;tNboQEgaIojt-}VS0L~9C)UFjv=9# z9T~s#FaO2s9C8tE!z`R-U*z|G>6f?wqOo0eSsLPG!X_7%%}(1WV5z-`JHOJYooWA^ ziWA+@%;lJzHV*M_B-IELv1k?J!kL0*IfmL-j?sbeQ!N==)pBuoC+wtmet?Vw(M*p` zR|I>%_V@GpDE4dU*8L$J$?<{X@j7J%4y_Us zTFVwJ1u*}C$tA?WI7DPd9Ov&n6ZK|jB{?6XFsE+yuwuOpR8Fl?2sf9>TqMvhE@BxDTP+)-l7AJCyiadK^R6_Y7d9kG?sMu2>w6Xa zatRhAUdNbW()$Jw$VLWeR4NUDFffJMv>0CMUqSwFU?1Wqs%y)0+c`68UOTUpa}Vx^ z0wK;sft^sD2~3qXmJrkU&|AjSnX&7<4Cd>8GuK)jbypEew{$?QKl98p z1CPp^H{Nt`Yiyd0_Q>@&abgaDQUIqr?2pIOBRx(#hPGpHm^VAUz$ z{JxwAJLkNat(i-}+S@NDlq$~Mn{d9{5f<}aBT-aBECa$(T$`jEs@MSXGdKF@Q}?6#_C~SK}lt@5zjkmUPsN0K}|A zFh#PGA}7rno7^nd)MB$#MU&J7*p=g>ul#QN`fHg8MF)$Ky1W9i%(i^wQeqJ6oyVv$ zVD_n>W}{BiZp>Q;{&|hankIT7vCOS$*22~&0P>zO{G$Aoi z?DqN;5-Kg*rGP0G|E+*ZBgVrUB}k}<2IY#V5ri1CND&g0gQG(@f)a@M13P%Pcg_Uf=bK=nK-qCLJK5RLove8N}u;tZ~Vq@uw_S$aR{ZV zj-d$@BT~?$;14cMHRhQvsQTF}wl#o6?04YyhEyR;RbsS~$5k7-=8<8ts&4Jk9s#P2 zyNMa9ig5%W(-N030h*6BGMbk;>vW?|jC0^N{vP&8M!(aV#Uk~q4(V6E`s@cjer1n3 zl9bkYpLgE3YhMX=Y#?MN5W!124e^2rjIz<_ZO~5|O`D!e@S3KaeSpbNBW%rl0>hbx zRtzd8+Gat|oZ9>xa(h30^Rc=)fdLZ3C`$uqSbw(C6V(XV&_KZBR4eM{L%Z$we)o6& z_>cd1z<2&aLBqBW(SkeV3X=~hT@h2a5W<&DTb z(Pr<weq-Y>ZV;tXV&A3mWRnCVsS_rUS{2 zswNR=kKg^_M+AFSYj}yW$j4V+eXd1~ksHYw4RRsIvDw6=730!S9r~~J*<ut=9OBJk4GNO$wRpKsYs?L*;B(|)b&gH}Ea&W`Qg&j59jY>y zW6M2}CZ<}N2ZbUBBq{Y;pfSfHu-NStbBR5ci23E0a4Za#DNj=Yb%>aN`sQkLc7_Up zAq3neZLMh*s8!55`oYwtpHtF$j$Xl9zNVTy1&+f)AYaa)#}uH#zbBaxQ7|AgQCwwp zu`i>t$&7EeGFAKBaBc9@3BB}CtXBo5jC_oXuU%iM0T=&5lAqayCzgh?>I(BD7_h%% z3haEsG$R3=d``t8SZR)=Bp&L4f$6xkEQ2%GOnt<#F0-w@@ieo#&6jT_b?YXoS(mSQ zS~$+^yJOle9ZYWC>%D!~4`}vZ{gq!CvU5T-wHRaIAfmthTfcK~=ctKoV0JkcqRohh zH&SapO*9Fg*DXxcx6fR5%~|tX{Q;PF+7Z#v6x6@;M@EXft?ZC>O3`1dU%01>JJZNJ zT<~2q^k8t3D1|>w<`9XY#y)_9mW!qLIM>A-a$hMv20N<|HwUTK0lWw92eAe6yc~N) zRX_#u(WXFnB=XUp`Po|^{NPck)+%Vy#K+ysKmV^^xN}?b+IJVRY+$MHhud^_XU`Ni z({_i4HD~gsT`{ZK`hDUkv5apK@u(W2<}<uDm{kjoYvjSRd8JZtvFB>lRouT?g=L~V00Jd*FY%Tu&AtBG62Fp=43*lQNX4N zb$Yhq-=^h;>#n`rL7f5c z52zz_!4I?~0#$@+Zuih}AFFld{E*)X@-?zz-({ESG;WUTf$yCm(R>=$+bx6hyK?19 zQN@g0nhu)|VxQ2-ED==nthTXFE>sgKFSC)42QdrfiB^Klrdlea5lIPnLY?|)^dKVrya%4ztzHy0xZCZ%OuM1$_|03=TWk?I4`?#C;;$bG_Cw&r!K zuYw0R->Zmd^KqIT3EhwW*{3gD>2kiqjH+go`@_e6^B=#!w4q!cU@XJyMx%BvOX~5H zj-cxS(iLO$n+*_E#F-$5A^a?Y95C)EIEgHS$>V#=3(O6-2r-*+Y!tBTdNs(3NvufR zmcM$nnvH3VT{?85v+2ZahJu_DUkriUwr!f$z)~^M@>UTFxlh)Ttn27OP^`p}Rkos7 zv?jl%tP#z8V@}lPMm1Jd9Y*}lW4O+eA*jWHIukZk zGIZ~PF`HASi{#^@c<0XAKwz@@u-x5x_e|WEN<|2ZS8nGn>||^Z1CXtcZ$H)c@7$$5 z;>e965yt}hDE)f?284QDrnYgd3OXdnr*-ZrTq^ST-<3R{ypnczls6`ppZy^skd|d4WvDUps_S_ADgLEc#2jN|IGxg$L1+N)tZwK#sKemfLL^D;UHqg#5{lZrW9sy8SYVZ5r z0Npiak;=j0ABsa5cp;csM7&UH0BsDKrCWDoFxZ>7Z>uYaBkr_K0~vD{LLh{0eeAy* zGyz&Jf8CIhyKI30#2DQZdzl@~Jd{7vom9VApZgm2wM|oKQ(HjnQuKKoqfDPfOljxzUBE+YDPclG#Y6|Cb{ zb5H+YXQ&C_-K}B<-8k^*NE{|inA;WswC}+TnSjZ-y|>^DK{|0m09*c-%O4U@Yc;$;81&(K3;j!fo_|LGLnjl;R| zy~9OKEjCT+(-V(B@%hhvzHQr=UV6!ULtY~qp6B2B?cYg#KlGWfb~J?~~v9558*Lf6qXKrch}7BTjEL z>t4@&x`;TdM%%Pa(*UBW4YLi--wsnp(=Yt2)-$5QPbB8zJ7eA3ZC)OyddaXiZH^D^%fAy2ZUj^X^Tdvr-NhBk(r|JAf{Jtn z<6T*fMr0Js=H_dM-~=`Z>#Ey9m0*e+Yl;#!jUw@tqs9R7jGCDHs_GUB+5U)Q;db@e zFFw;OBx|Q;h-5-H-)P^w)=L6aaU5Stc}jMnN}zZ{mx!F^NmWzMzMZ+BR<*WS?CALs4$%Q;cQ&7@M-fB*%hyLWAoxA%>}y zqK?&@MM{mwNmZMsQ5}`}y-n`Hf4TDN3MF3NuS9G0@nUSEv{88(o6?om@JN&<755O# zK(nY-V9IuISyQ%}I?Q#W5YbbI`dKQFq$)sHJN>10(H{PyZHLhQ&cm-?`;-C^M7m5N)yy>N*8BjHEvtE$~4Q_f#*-(oh zXJGf_^>vz2#BwB}ont2a_NtERA*P|{`ys$RDwNwj3k1RwSp2%?Kt(_}n-a*ty?#+W zUwr!0pMKAK-jh-qghB@)lA+1vtViA^A9D1=qrisd=-Mf-z^vh0vkdwa5gc(C!Tns>pDQJ z&uaZdl}@5&?I#0GoEsH`8U|s39Z$nUh%^_rvdR>O^N*=!>N&cpdEDdfJZs|S_9s7k zrEEeCA~&HWYhQXUtd7W3nh_czFzAzEB4A6&y?#X@Eso8R|$XS@Q~yrwq~|4S@_I%enMH`tsFs?CuT1!N{LwA4z^*|L$LDTo%E z+~DY<{KRdH5XPUOf^zmd;B+V4|Jdx~%p=jW?`NEIrp>oB7-&+}g%0sq>;faB?gW{^ zf@F?{>%d^3M99db!IVVptla;udn%)`ic`jRS#II(H?AKX3*-W64Ma^k`l(MnwTJ6V zZHQ!5ZrIPZpLYL_e|#^!NRg8mUj3Y!sW{7bIsSGS#kX0<;CwqBV$#eWwE9~UbO0C_ z6dr%#ab_Nr#)gReLm&FkCqD6sq5f)S9N5$Jfm>z(gbp}RvswwWdd~a4_p_p=l^CpU z(dLJ>IOmRjt1(qx>OJH1kWFknIj{AGx5Nnk4R3hfI@h*-hKL5haS?UiMMM!DT%gsb zyvD2uGbsZ%s+ZsW)oH8LiT7h{ieQ42%Z`}Ll7V2`e)MBkm-{L11VtniqGxh`{qOzV zi`sXZ1cKj?TyCyFg)|;E$i6-&0XXi~YSxc>&_0=Fd{Wx{eyOSJ9KRu=-=?Eq7g3k) z(dygF=5XqP4Q6%AGgUB5?|9$t;==W;8-y+Z%Lp=?6ggr)?H2s!V;UE&@9DR6&un=b|Y)w5bQQhEYXSN z)TcDS#0GahkSF@=HI-@fn!Hl6Gw-MQah)1K0C$;H+|$Wim&;AFUsQ(zAWTzgj?jrA z075y9(=~%}l^{Pq_xoR4;!e&&Xu`OH?yz4IH#ngoRJWA|PcV3&D)64*LnYo)r>?cA z2g(HM-%H>J7&(N(cSj*S`t&m}43YpI9UPbnW&uSOLjy(VM7;ep4XV$~&+EO+qs9tR z-pVy9pW{Q)p#WAi93z67m>E+jmj;M~OB4`r7#4-Q{ldHFNdhJgA83$n>*6af-R$B% zQ?%l9b|SuQ7vK9xyNfxZjhD|Vx#I+3sLI8JUDpliX-d5T`1jAuo=@Q5{xq9!DH9xL zKvq8Y>~r7x*0%=5ieYabC}kFl#c(i1(maeW8Q4(F0{}cry}sTUvw3Hzf#A27>>{8K z^2}tA{%v>u@V`<3GN zJ_9l5R4@PnO=d^2y&abak3O~viwq>?e_jB1>6d@u%IePWE|&sPV2K>X2Ae@pFa$1s zqR3_dY)JW&%T$RghtBCRzpb_y7GLfp4Y5Q*Rf$?0S*og)P>TrI6>0Hw^D$@5o7W3cfRO<88eAd!NKnj4z*N+&2G5IWZ zB6;+g$9u`X>71=nUp;z#ndRC3^L1~l+!~W@H_q=3gF^NNNcHy)t8^tdy z$VmO|LwN1##l^xq8pCov2DFWp2dNgyr-yC6>|BJgKca5n>)UryryRQD-MIW!*)w$t z{P`dFT;C@V7zMh_@mBVLt|}WCI($SdX>)bOuN;G5^v4KPV(Q+%M+?kMO$<8?69qzM z_ue#@1tRuG)wTTqjHZU<`8CdO*Q~7XI5umZnGEjywbx(UjAGurRV7;nso&T{FPslt zpI`sl*IiC+Y{gdnG}W{2XVbZ+?SokzkH*+U74cvc-2QEMj)14XQw@DnwQW|ox~giN z2l*lr;)cH$$eKm7(NfDBZ$wP6KSsP0xOH(I4(JsRm%knwqvTM2{yu{#Z1vsrI8*UhW-7EzT`E z*YtFN(mhE8PT^VnkA@gRvw4l9{+Jg;hvnl;W^+YdV+JRlDeok!$!ETBh1#2vn=%@< z28pXX`&VBC%{`&2C}EizmttylPj{cigB9Y47=nM;!NANN=l=eMLIjjI{upenwl+-W zbN;jd-7#4(X3bshM0LIH2JWbwbBM7}xwShRU+%P`#dstaomk=KTn#oIjOIskvfJtr z5uujNooLgKE2FTZI#Nl^YZG!(u3^L`V#7ofNr6}>VZQjpMFCMoFX)|}0wUnte7@EY zXXFW6>FnH_*986Cf-BC@V^mkA|8>wl04j0jpgvEo8bx*iq0dxuEK_lLU9{1o!|c@& z6!UdvGpicd88-hTcJ?~8FK-J&pC*zpA8uLaUir|-0N5(oP06z#2*#@@ivCUvL#x?x z-2aWQy?iJP9I^-kwL~Aeva`o&*({kCfg!LVs7rgz&G$}c;ha>{$~xu29+HH$-YRqZ zwo4%Q)N7e`G;mWcFswRP$fFi^C7(okka9TO*ZpL3N@c1vHgpO#G5#;a zk$|&lW88ExRjuoKWV&(Z*0t+zV4$S3&Yhx(sUav>-3>itbMq{!s?^kS;Fk1GMd3~F zZPHh(-#2o6m06!bOmzQk&n!Onu`afv5Rn>9kI4ED|LMOGZr==GPJi87&XAG7?^jjh z5Qsz5E>fSwf2L1!fV59J8(Kxm0954B=>W*roH7I|ga{|#p+m)ps5agvNe%>q`ievx zA~A`jY+cxW_1zzCAs)td3BYZj8?V9N_`m;wrHkbe=$H`;e%?81y(_7vv)q@c$cG?e z?L&{!YD0x>cTWv+PE1@rydnr$Ca*D;9~Ii)HY!$ScJ zG`Il6J|_l_K$%j44$;#HDW|7O2Mo(5QcVJ+ITGKq{<#asVgye4S0%;9*Yk^nGaYaA zg=P6u?`?eaI4FcnB;G_MR6_73NBYr)|smRzyp!D%3c38}WZ; z8xyx%5q?k`7j~aR{v`2=iE_c>VP?(SisnT6pe)>?BODK4LZ_r*fX5 zwZTn|udFc90=X&ioh|g}$3FRi1$0cNVD6@ULXeA91~(ab0JEQ!`KhSsN=+zdc48}a zmi%&DS3UAIZfkR^UwT+{zwQK)W_G6BQN?D7NL4n9A>6ug^Nnk7Xcp(FCL&O6n|2Ue z+uhySD7Cb$zbiAS07+FtK#zXrm3Es&v~Jrv7ruNh!yTT1zYc5BEWoUumiZZ|1+lvB zW~W0_G9*vt>Uu~++`a(dJ{6f`1i$_qoFa`l0N(prp6tKP9nAfBcAM7xuQHf#E(U=M zZEv#-+^E3La_@M(Ry1Sma$2Wucs0gkq6AW&DQ2pT7T1jO!j%_L)}BUv_CGaVq_j4=Ub1JS-shgW~~@9Z4kZgO6AsRKYrz-R;_J!Eld zR0;uz2L~w%s-be$>4hl4pJ|Y;}1l>d@gn}`R;<{ikRCfnN1*A8sVCLdE6cJ)< zhBMhT4HhXgpP%+YBT#oP7(-ibfFNpO$->c}|M$K-?j2=I0v$rc)I9fx$BkUdeNRM9 z6Jlg7CMqQ#8eqGp&%-el~Wfna0xk$ zoM*>>HP)x8hD;T*XI8Du#}^YTOWm@UByAMr_4*HiT@T9Ai=L zLRInR=|B93&ob{5