{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "toCy3v03Dwx7" }, "source": [ "##### Copyright 2021 The TensorFlow Hub Authors.\n", "\n", "Licensed under the Apache License, Version 2.0 (the \"License\");" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:00:54.076079Z", "iopub.status.busy": "2022-12-14T21:00:54.075661Z", "iopub.status.idle": "2022-12-14T21:00:54.079396Z", "shell.execute_reply": "2022-12-14T21:00:54.078836Z" }, "id": "QKe-ubNcDvgv" }, "outputs": [], "source": [ "# Copyright 2021 The TensorFlow Hub Authors. All Rights Reserved.\n", "#\n", "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", "# You may obtain a copy of the License at\n", "#\n", "# http://www.apache.org/licenses/LICENSE-2.0\n", "#\n", "# Unless required by applicable law or agreed to in writing, software\n", "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", "# See the License for the specific language governing permissions and\n", "# limitations under the License.\n", "# ==============================================================================" ] }, { "cell_type": "markdown", "metadata": { "id": "KqtQzBCpIJ7Y" }, "source": [ "# MoveNet:超快且准确的姿态检测模型" ] }, { "cell_type": "markdown", "metadata": { "id": "MCmFOosnSkCd" }, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
在 TensorFlow.org上查看在 Google Colab 中运行 在 GitHub 上查看源代码 下载笔记本 查看 TF Hub 模型 \n", "
" ] }, { "cell_type": "markdown", "metadata": { "id": "6x99e0aEY_d6" }, "source": [ "**[MoveNet](https://t.co/QpfnVL0YYI?amp=1)** 是一个超快且准确的模型,可检测身体的 17 个关键点。该模型在 [TF Hub](https://tfhub.dev/s?q=movenet) 上提供两种变体,分别为 Lightning 和 Thunder。Lightning 用于延迟关键型应用,而 Thunder 用于需要高准确性的应用。在大多数现代台式机、笔记本电脑和手机上,这两种模型的运行速度都快于实时 (30+ FPS),这对于实时的健身、健康和保健应用至关重要。\n", "\n", "\"drawing\"\n", "\n", "*图像下载自 Pexels (https://www.pexels.com/)\n", "\n", "本 Colab 将详细介绍如何加载 MoveNet,并对下面的输入图像和视频运行推断。\n", "\n", "注:请查看[实时演示](https://storage.googleapis.com/tfjs-models/demos/pose-detection/index.html?model=movenet)以了解该模型的工作原理!" ] }, { "cell_type": "markdown", "metadata": { "id": "10_zkgbZBkIE" }, "source": [ "# 使用 MoveNet 进行人体姿态估计" ] }, { "cell_type": "markdown", "metadata": { "id": "9u_VGR6_BmbZ" }, "source": [ "## 可视化库和导入" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:00:54.082882Z", "iopub.status.busy": "2022-12-14T21:00:54.082381Z", "iopub.status.idle": "2022-12-14T21:01:04.599813Z", "shell.execute_reply": "2022-12-14T21:01:04.598656Z" }, "id": "TtcwSIcgbIVN" }, "outputs": [], "source": [ "!pip install -q imageio\n", "!pip install -q opencv-python\n", "!pip install -q git+https://github.com/tensorflow/docs" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:04.604635Z", "iopub.status.busy": "2022-12-14T21:01:04.603891Z", "iopub.status.idle": "2022-12-14T21:01:07.019991Z", "shell.execute_reply": "2022-12-14T21:01:07.019148Z" }, "id": "9BLeJv-pCCld" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:01:05.561349: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n", "2022-12-14 21:01:05.561447: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n", "2022-12-14 21:01:05.561458: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n" ] } ], "source": [ "import tensorflow as tf\n", "import tensorflow_hub as hub\n", "from tensorflow_docs.vis import embed\n", "import numpy as np\n", "import cv2\n", "\n", "# Import matplotlib libraries\n", "from matplotlib import pyplot as plt\n", "from matplotlib.collections import LineCollection\n", "import matplotlib.patches as patches\n", "\n", "# Some modules to display an animation using imageio.\n", "import imageio\n", "from IPython.display import HTML, display" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2022-12-14T21:01:07.024388Z", "iopub.status.busy": "2022-12-14T21:01:07.023945Z", "iopub.status.idle": "2022-12-14T21:01:07.042858Z", "shell.execute_reply": "2022-12-14T21:01:07.042102Z" }, "id": "bEJBMeRb3YUy" }, "outputs": [], "source": [ "#@title Helper functions for visualization\n", "\n", "# Dictionary that maps from joint names to keypoint indices.\n", "KEYPOINT_DICT = {\n", " 'nose': 0,\n", " 'left_eye': 1,\n", " 'right_eye': 2,\n", " 'left_ear': 3,\n", " 'right_ear': 4,\n", " 'left_shoulder': 5,\n", " 'right_shoulder': 6,\n", " 'left_elbow': 7,\n", " 'right_elbow': 8,\n", " 'left_wrist': 9,\n", " 'right_wrist': 10,\n", " 'left_hip': 11,\n", " 'right_hip': 12,\n", " 'left_knee': 13,\n", " 'right_knee': 14,\n", " 'left_ankle': 15,\n", " 'right_ankle': 16\n", "}\n", "\n", "# Maps bones to a matplotlib color name.\n", "KEYPOINT_EDGE_INDS_TO_COLOR = {\n", " (0, 1): 'm',\n", " (0, 2): 'c',\n", " (1, 3): 'm',\n", " (2, 4): 'c',\n", " (0, 5): 'm',\n", " (0, 6): 'c',\n", " (5, 7): 'm',\n", " (7, 9): 'm',\n", " (6, 8): 'c',\n", " (8, 10): 'c',\n", " (5, 6): 'y',\n", " (5, 11): 'm',\n", " (6, 12): 'c',\n", " (11, 12): 'y',\n", " (11, 13): 'm',\n", " (13, 15): 'm',\n", " (12, 14): 'c',\n", " (14, 16): 'c'\n", "}\n", "\n", "def _keypoints_and_edges_for_display(keypoints_with_scores,\n", " height,\n", " width,\n", " keypoint_threshold=0.11):\n", " \"\"\"Returns high confidence keypoints and edges for visualization.\n", "\n", " Args:\n", " keypoints_with_scores: A numpy array with shape [1, 1, 17, 3] representing\n", " the keypoint coordinates and scores returned from the MoveNet model.\n", " height: height of the image in pixels.\n", " width: width of the image in pixels.\n", " keypoint_threshold: minimum confidence score for a keypoint to be\n", " visualized.\n", "\n", " Returns:\n", " A (keypoints_xy, edges_xy, edge_colors) containing:\n", " * the coordinates of all keypoints of all detected entities;\n", " * the coordinates of all skeleton edges of all detected entities;\n", " * the colors in which the edges should be plotted.\n", " \"\"\"\n", " keypoints_all = []\n", " keypoint_edges_all = []\n", " edge_colors = []\n", " num_instances, _, _, _ = keypoints_with_scores.shape\n", " for idx in range(num_instances):\n", " kpts_x = keypoints_with_scores[0, idx, :, 1]\n", " kpts_y = keypoints_with_scores[0, idx, :, 0]\n", " kpts_scores = keypoints_with_scores[0, idx, :, 2]\n", " kpts_absolute_xy = np.stack(\n", " [width * np.array(kpts_x), height * np.array(kpts_y)], axis=-1)\n", " kpts_above_thresh_absolute = kpts_absolute_xy[\n", " kpts_scores > keypoint_threshold, :]\n", " keypoints_all.append(kpts_above_thresh_absolute)\n", "\n", " for edge_pair, color in KEYPOINT_EDGE_INDS_TO_COLOR.items():\n", " if (kpts_scores[edge_pair[0]] > keypoint_threshold and\n", " kpts_scores[edge_pair[1]] > keypoint_threshold):\n", " x_start = kpts_absolute_xy[edge_pair[0], 0]\n", " y_start = kpts_absolute_xy[edge_pair[0], 1]\n", " x_end = kpts_absolute_xy[edge_pair[1], 0]\n", " y_end = kpts_absolute_xy[edge_pair[1], 1]\n", " line_seg = np.array([[x_start, y_start], [x_end, y_end]])\n", " keypoint_edges_all.append(line_seg)\n", " edge_colors.append(color)\n", " if keypoints_all:\n", " keypoints_xy = np.concatenate(keypoints_all, axis=0)\n", " else:\n", " keypoints_xy = np.zeros((0, 17, 2))\n", "\n", " if keypoint_edges_all:\n", " edges_xy = np.stack(keypoint_edges_all, axis=0)\n", " else:\n", " edges_xy = np.zeros((0, 2, 2))\n", " return keypoints_xy, edges_xy, edge_colors\n", "\n", "\n", "def draw_prediction_on_image(\n", " image, keypoints_with_scores, crop_region=None, close_figure=False,\n", " output_image_height=None):\n", " \"\"\"Draws the keypoint predictions on image.\n", "\n", " Args:\n", " image: A numpy array with shape [height, width, channel] representing the\n", " pixel values of the input image.\n", " keypoints_with_scores: A numpy array with shape [1, 1, 17, 3] representing\n", " the keypoint coordinates and scores returned from the MoveNet model.\n", " crop_region: A dictionary that defines the coordinates of the bounding box\n", " of the crop region in normalized coordinates (see the init_crop_region\n", " function below for more detail). If provided, this function will also\n", " draw the bounding box on the image.\n", " output_image_height: An integer indicating the height of the output image.\n", " Note that the image aspect ratio will be the same as the input image.\n", "\n", " Returns:\n", " A numpy array with shape [out_height, out_width, channel] representing the\n", " image overlaid with keypoint predictions.\n", " \"\"\"\n", " height, width, channel = image.shape\n", " aspect_ratio = float(width) / height\n", " fig, ax = plt.subplots(figsize=(12 * aspect_ratio, 12))\n", " # To remove the huge white borders\n", " fig.tight_layout(pad=0)\n", " ax.margins(0)\n", " ax.set_yticklabels([])\n", " ax.set_xticklabels([])\n", " plt.axis('off')\n", "\n", " im = ax.imshow(image)\n", " line_segments = LineCollection([], linewidths=(4), linestyle='solid')\n", " ax.add_collection(line_segments)\n", " # Turn off tick labels\n", " scat = ax.scatter([], [], s=60, color='#FF1493', zorder=3)\n", "\n", " (keypoint_locs, keypoint_edges,\n", " edge_colors) = _keypoints_and_edges_for_display(\n", " keypoints_with_scores, height, width)\n", "\n", " line_segments.set_segments(keypoint_edges)\n", " line_segments.set_color(edge_colors)\n", " if keypoint_edges.shape[0]:\n", " line_segments.set_segments(keypoint_edges)\n", " line_segments.set_color(edge_colors)\n", " if keypoint_locs.shape[0]:\n", " scat.set_offsets(keypoint_locs)\n", "\n", " if crop_region is not None:\n", " xmin = max(crop_region['x_min'] * width, 0.0)\n", " ymin = max(crop_region['y_min'] * height, 0.0)\n", " rec_width = min(crop_region['x_max'], 0.99) * width - xmin\n", " rec_height = min(crop_region['y_max'], 0.99) * height - ymin\n", " rect = patches.Rectangle(\n", " (xmin,ymin),rec_width,rec_height,\n", " linewidth=1,edgecolor='b',facecolor='none')\n", " ax.add_patch(rect)\n", "\n", " fig.canvas.draw()\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n", " image_from_plot = image_from_plot.reshape(\n", " fig.canvas.get_width_height()[::-1] + (3,))\n", " plt.close(fig)\n", " if output_image_height is not None:\n", " output_image_width = int(output_image_height / height * width)\n", " image_from_plot = cv2.resize(\n", " image_from_plot, dsize=(output_image_width, output_image_height),\n", " interpolation=cv2.INTER_CUBIC)\n", " return image_from_plot\n", "\n", "def to_gif(images, fps):\n", " \"\"\"Converts image sequence (4D numpy array) to gif.\"\"\"\n", " imageio.mimsave('./animation.gif', images, fps=fps)\n", " return embed.embed_file('./animation.gif')\n", "\n", "def progress(value, max=100):\n", " return HTML(\"\"\"\n", " \n", " {value}\n", " \n", " \"\"\".format(value=value, max=max))" ] }, { "cell_type": "markdown", "metadata": { "id": "UvrN0iQiOxhR" }, "source": [ "## 从 TF hub 加载模型" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:07.046513Z", "iopub.status.busy": "2022-12-14T21:01:07.046056Z", "iopub.status.idle": "2022-12-14T21:01:22.059034Z", "shell.execute_reply": "2022-12-14T21:01:22.058235Z" }, "id": "zeGHgANcT7a1" }, "outputs": [], "source": [ "model_name = \"movenet_lightning\" #@param [\"movenet_lightning\", \"movenet_thunder\", \"movenet_lightning_f16.tflite\", \"movenet_thunder_f16.tflite\", \"movenet_lightning_int8.tflite\", \"movenet_thunder_int8.tflite\"]\n", "\n", "if \"tflite\" in model_name:\n", " if \"movenet_lightning_f16\" in model_name:\n", " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/lightning/tflite/float16/4?lite-format=tflite\n", " input_size = 192\n", " elif \"movenet_thunder_f16\" in model_name:\n", " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/thunder/tflite/float16/4?lite-format=tflite\n", " input_size = 256\n", " elif \"movenet_lightning_int8\" in model_name:\n", " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/lightning/tflite/int8/4?lite-format=tflite\n", " input_size = 192\n", " elif \"movenet_thunder_int8\" in model_name:\n", " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/thunder/tflite/int8/4?lite-format=tflite\n", " input_size = 256\n", " else:\n", " raise ValueError(\"Unsupported model name: %s\" % model_name)\n", "\n", " # Initialize the TFLite interpreter\n", " interpreter = tf.lite.Interpreter(model_path=\"model.tflite\")\n", " interpreter.allocate_tensors()\n", "\n", " def movenet(input_image):\n", " \"\"\"Runs detection on an input image.\n", "\n", " Args:\n", " input_image: A [1, height, width, 3] tensor represents the input image\n", " pixels. Note that the height/width should already be resized and match the\n", " expected input resolution of the model before passing into this function.\n", "\n", " Returns:\n", " A [1, 1, 17, 3] float numpy array representing the predicted keypoint\n", " coordinates and scores.\n", " \"\"\"\n", " # TF Lite format expects tensor type of uint8.\n", " input_image = tf.cast(input_image, dtype=tf.uint8)\n", " input_details = interpreter.get_input_details()\n", " output_details = interpreter.get_output_details()\n", " interpreter.set_tensor(input_details[0]['index'], input_image.numpy())\n", " # Invoke inference.\n", " interpreter.invoke()\n", " # Get the model prediction.\n", " keypoints_with_scores = interpreter.get_tensor(output_details[0]['index'])\n", " return keypoints_with_scores\n", "\n", "else:\n", " if \"movenet_lightning\" in model_name:\n", " module = hub.load(\"https://tfhub.dev/google/movenet/singlepose/lightning/4\")\n", " input_size = 192\n", " elif \"movenet_thunder\" in model_name:\n", " module = hub.load(\"https://tfhub.dev/google/movenet/singlepose/thunder/4\")\n", " input_size = 256\n", " else:\n", " raise ValueError(\"Unsupported model name: %s\" % model_name)\n", "\n", " def movenet(input_image):\n", " \"\"\"Runs detection on an input image.\n", "\n", " Args:\n", " input_image: A [1, height, width, 3] tensor represents the input image\n", " pixels. Note that the height/width should already be resized and match the\n", " expected input resolution of the model before passing into this function.\n", "\n", " Returns:\n", " A [1, 1, 17, 3] float numpy array representing the predicted keypoint\n", " coordinates and scores.\n", " \"\"\"\n", " model = module.signatures['serving_default']\n", "\n", " # SavedModel format expects tensor type of int32.\n", " input_image = tf.cast(input_image, dtype=tf.int32)\n", " # Run model inference.\n", " outputs = model(input_image)\n", " # Output is a [1, 1, 17, 3] tensor.\n", " keypoints_with_scores = outputs['output_0'].numpy()\n", " return keypoints_with_scores" ] }, { "cell_type": "markdown", "metadata": { "id": "-h1qHYaqD9ap" }, "source": [ "## 单个图像示例" ] }, { "cell_type": "markdown", "metadata": { "id": "ymTVR2I9x22I" }, "source": [ "本节演示对**单个图像**运行模型以预测 17 个人体关键点的最小工作示例。" ] }, { "cell_type": "markdown", "metadata": { "id": "5I3xBq80E3N_" }, "source": [ "### 加载输入图像" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:22.063903Z", "iopub.status.busy": "2022-12-14T21:01:22.063375Z", "iopub.status.idle": "2022-12-14T21:01:22.697701Z", "shell.execute_reply": "2022-12-14T21:01:22.696596Z" }, "id": "GMO4B-wx5psP" }, "outputs": [], "source": [ "!curl -o input_image.jpeg https://images.pexels.com/photos/4384679/pexels-photo-4384679.jpeg --silent" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:22.702467Z", "iopub.status.busy": "2022-12-14T21:01:22.701754Z", "iopub.status.idle": "2022-12-14T21:01:22.859440Z", "shell.execute_reply": "2022-12-14T21:01:22.858751Z" }, "id": "lJZYQ8KYFQ6x" }, "outputs": [], "source": [ "# Load the input image.\n", "image_path = 'input_image.jpeg'\n", "image = tf.io.read_file(image_path)\n", "image = tf.image.decode_jpeg(image)" ] }, { "cell_type": "markdown", "metadata": { "id": "S_UWRdQxE6WN" }, "source": [ "### 运行推断" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:22.863684Z", "iopub.status.busy": "2022-12-14T21:01:22.863188Z", "iopub.status.idle": "2022-12-14T21:01:25.392721Z", "shell.execute_reply": "2022-12-14T21:01:25.391830Z" }, "id": "VHmTwACwFW-v" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Resize and pad the image to keep the aspect ratio and fit the expected size.\n", "input_image = tf.expand_dims(image, axis=0)\n", "input_image = tf.image.resize_with_pad(input_image, input_size, input_size)\n", "\n", "# Run model inference.\n", "keypoints_with_scores = movenet(input_image)\n", "\n", "# Visualize the predictions with image.\n", "display_image = tf.expand_dims(image, axis=0)\n", "display_image = tf.cast(tf.image.resize_with_pad(\n", " display_image, 1280, 1280), dtype=tf.int32)\n", "output_overlay = draw_prediction_on_image(\n", " np.squeeze(display_image.numpy(), axis=0), keypoints_with_scores)\n", "\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(output_overlay)\n", "_ = plt.axis('off')" ] }, { "cell_type": "markdown", "metadata": { "id": "rKm-B0eMYeg8" }, "source": [ "## 视频(图像序列)示例" ] }, { "cell_type": "markdown", "metadata": { "id": "gdPFXabLyiKv" }, "source": [ "本节演示当输入为帧序列时,如何根据前一帧的检测结果应用智能裁剪。这样模型可以将注意力和资源投入到主要主题上,从而在不牺牲速度的情况下获得更好的预测质量。\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2022-12-14T21:01:25.398829Z", "iopub.status.busy": "2022-12-14T21:01:25.398557Z", "iopub.status.idle": "2022-12-14T21:01:25.416696Z", "shell.execute_reply": "2022-12-14T21:01:25.415872Z" }, "id": "SYFdK-JHYhrv" }, "outputs": [], "source": [ "#@title Cropping Algorithm\n", "\n", "# Confidence score to determine whether a keypoint prediction is reliable.\n", "MIN_CROP_KEYPOINT_SCORE = 0.2\n", "\n", "def init_crop_region(image_height, image_width):\n", " \"\"\"Defines the default crop region.\n", "\n", " The function provides the initial crop region (pads the full image from both\n", " sides to make it a square image) when the algorithm cannot reliably determine\n", " the crop region from the previous frame.\n", " \"\"\"\n", " if image_width > image_height:\n", " box_height = image_width / image_height\n", " box_width = 1.0\n", " y_min = (image_height / 2 - image_width / 2) / image_height\n", " x_min = 0.0\n", " else:\n", " box_height = 1.0\n", " box_width = image_height / image_width\n", " y_min = 0.0\n", " x_min = (image_width / 2 - image_height / 2) / image_width\n", "\n", " return {\n", " 'y_min': y_min,\n", " 'x_min': x_min,\n", " 'y_max': y_min + box_height,\n", " 'x_max': x_min + box_width,\n", " 'height': box_height,\n", " 'width': box_width\n", " }\n", "\n", "def torso_visible(keypoints):\n", " \"\"\"Checks whether there are enough torso keypoints.\n", "\n", " This function checks whether the model is confident at predicting one of the\n", " shoulders/hips which is required to determine a good crop region.\n", " \"\"\"\n", " return ((keypoints[0, 0, KEYPOINT_DICT['left_hip'], 2] >\n", " MIN_CROP_KEYPOINT_SCORE or\n", " keypoints[0, 0, KEYPOINT_DICT['right_hip'], 2] >\n", " MIN_CROP_KEYPOINT_SCORE) and\n", " (keypoints[0, 0, KEYPOINT_DICT['left_shoulder'], 2] >\n", " MIN_CROP_KEYPOINT_SCORE or\n", " keypoints[0, 0, KEYPOINT_DICT['right_shoulder'], 2] >\n", " MIN_CROP_KEYPOINT_SCORE))\n", "\n", "def determine_torso_and_body_range(\n", " keypoints, target_keypoints, center_y, center_x):\n", " \"\"\"Calculates the maximum distance from each keypoints to the center location.\n", "\n", " The function returns the maximum distances from the two sets of keypoints:\n", " full 17 keypoints and 4 torso keypoints. The returned information will be\n", " used to determine the crop size. See determineCropRegion for more detail.\n", " \"\"\"\n", " torso_joints = ['left_shoulder', 'right_shoulder', 'left_hip', 'right_hip']\n", " max_torso_yrange = 0.0\n", " max_torso_xrange = 0.0\n", " for joint in torso_joints:\n", " dist_y = abs(center_y - target_keypoints[joint][0])\n", " dist_x = abs(center_x - target_keypoints[joint][1])\n", " if dist_y > max_torso_yrange:\n", " max_torso_yrange = dist_y\n", " if dist_x > max_torso_xrange:\n", " max_torso_xrange = dist_x\n", "\n", " max_body_yrange = 0.0\n", " max_body_xrange = 0.0\n", " for joint in KEYPOINT_DICT.keys():\n", " if keypoints[0, 0, KEYPOINT_DICT[joint], 2] < MIN_CROP_KEYPOINT_SCORE:\n", " continue\n", " dist_y = abs(center_y - target_keypoints[joint][0]);\n", " dist_x = abs(center_x - target_keypoints[joint][1]);\n", " if dist_y > max_body_yrange:\n", " max_body_yrange = dist_y\n", "\n", " if dist_x > max_body_xrange:\n", " max_body_xrange = dist_x\n", "\n", " return [max_torso_yrange, max_torso_xrange, max_body_yrange, max_body_xrange]\n", "\n", "def determine_crop_region(\n", " keypoints, image_height,\n", " image_width):\n", " \"\"\"Determines the region to crop the image for the model to run inference on.\n", "\n", " The algorithm uses the detected joints from the previous frame to estimate\n", " the square region that encloses the full body of the target person and\n", " centers at the midpoint of two hip joints. The crop size is determined by\n", " the distances between each joints and the center point.\n", " When the model is not confident with the four torso joint predictions, the\n", " function returns a default crop which is the full image padded to square.\n", " \"\"\"\n", " target_keypoints = {}\n", " for joint in KEYPOINT_DICT.keys():\n", " target_keypoints[joint] = [\n", " keypoints[0, 0, KEYPOINT_DICT[joint], 0] * image_height,\n", " keypoints[0, 0, KEYPOINT_DICT[joint], 1] * image_width\n", " ]\n", "\n", " if torso_visible(keypoints):\n", " center_y = (target_keypoints['left_hip'][0] +\n", " target_keypoints['right_hip'][0]) / 2;\n", " center_x = (target_keypoints['left_hip'][1] +\n", " target_keypoints['right_hip'][1]) / 2;\n", "\n", " (max_torso_yrange, max_torso_xrange,\n", " max_body_yrange, max_body_xrange) = determine_torso_and_body_range(\n", " keypoints, target_keypoints, center_y, center_x)\n", "\n", " crop_length_half = np.amax(\n", " [max_torso_xrange * 1.9, max_torso_yrange * 1.9,\n", " max_body_yrange * 1.2, max_body_xrange * 1.2])\n", "\n", " tmp = np.array(\n", " [center_x, image_width - center_x, center_y, image_height - center_y])\n", " crop_length_half = np.amin(\n", " [crop_length_half, np.amax(tmp)]);\n", "\n", " crop_corner = [center_y - crop_length_half, center_x - crop_length_half];\n", "\n", " if crop_length_half > max(image_width, image_height) / 2:\n", " return init_crop_region(image_height, image_width)\n", " else:\n", " crop_length = crop_length_half * 2;\n", " return {\n", " 'y_min': crop_corner[0] / image_height,\n", " 'x_min': crop_corner[1] / image_width,\n", " 'y_max': (crop_corner[0] + crop_length) / image_height,\n", " 'x_max': (crop_corner[1] + crop_length) / image_width,\n", " 'height': (crop_corner[0] + crop_length) / image_height -\n", " crop_corner[0] / image_height,\n", " 'width': (crop_corner[1] + crop_length) / image_width -\n", " crop_corner[1] / image_width\n", " }\n", " else:\n", " return init_crop_region(image_height, image_width)\n", "\n", "def crop_and_resize(image, crop_region, crop_size):\n", " \"\"\"Crops and resize the image to prepare for the model input.\"\"\"\n", " boxes=[[crop_region['y_min'], crop_region['x_min'],\n", " crop_region['y_max'], crop_region['x_max']]]\n", " output_image = tf.image.crop_and_resize(\n", " image, box_indices=[0], boxes=boxes, crop_size=crop_size)\n", " return output_image\n", "\n", "def run_inference(movenet, image, crop_region, crop_size):\n", " \"\"\"Runs model inferece on the cropped region.\n", "\n", " The function runs the model inference on the cropped region and updates the\n", " model output to the original image coordinate system.\n", " \"\"\"\n", " image_height, image_width, _ = image.shape\n", " input_image = crop_and_resize(\n", " tf.expand_dims(image, axis=0), crop_region, crop_size=crop_size)\n", " # Run model inference.\n", " keypoints_with_scores = movenet(input_image)\n", " # Update the coordinates.\n", " for idx in range(17):\n", " keypoints_with_scores[0, 0, idx, 0] = (\n", " crop_region['y_min'] * image_height +\n", " crop_region['height'] * image_height *\n", " keypoints_with_scores[0, 0, idx, 0]) / image_height\n", " keypoints_with_scores[0, 0, idx, 1] = (\n", " crop_region['x_min'] * image_width +\n", " crop_region['width'] * image_width *\n", " keypoints_with_scores[0, 0, idx, 1]) / image_width\n", " return keypoints_with_scores" ] }, { "cell_type": "markdown", "metadata": { "id": "L2JmA1xAEntQ" }, "source": [ "### 加载输入图像序列" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:25.419983Z", "iopub.status.busy": "2022-12-14T21:01:25.419749Z", "iopub.status.idle": "2022-12-14T21:01:26.648126Z", "shell.execute_reply": "2022-12-14T21:01:26.646900Z" }, "id": "CzJxbxDckWl2" }, "outputs": [], "source": [ "!wget -q -O dance.gif https://github.com/tensorflow/tfjs-models/raw/master/pose-detection/assets/dance_input.gif" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:26.652818Z", "iopub.status.busy": "2022-12-14T21:01:26.652097Z", "iopub.status.idle": "2022-12-14T21:01:26.810491Z", "shell.execute_reply": "2022-12-14T21:01:26.809667Z" }, "id": "IxbMFZJUkd6W" }, "outputs": [], "source": [ "# Load the input image.\n", "image_path = 'dance.gif'\n", "image = tf.io.read_file(image_path)\n", "image = tf.image.decode_gif(image)" ] }, { "cell_type": "markdown", "metadata": { "id": "CJKeQ4siEtU9" }, "source": [ "### 使用裁剪算法运行推断" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:01:26.815141Z", "iopub.status.busy": "2022-12-14T21:01:26.814439Z", "iopub.status.idle": "2022-12-14T21:01:35.846740Z", "shell.execute_reply": "2022-12-14T21:01:35.845948Z" }, "id": "9B57XS0NZPIy" }, "outputs": [ { "data": { "text/html": [ "\n", " \n", " 41\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Load the input image.\n", "num_frames, image_height, image_width, _ = image.shape\n", "crop_region = init_crop_region(image_height, image_width)\n", "\n", "output_images = []\n", "bar = display(progress(0, num_frames-1), display_id=True)\n", "for frame_idx in range(num_frames):\n", " keypoints_with_scores = run_inference(\n", " movenet, image[frame_idx, :, :, :], crop_region,\n", " crop_size=[input_size, input_size])\n", " output_images.append(draw_prediction_on_image(\n", " image[frame_idx, :, :, :].numpy().astype(np.int32),\n", " keypoints_with_scores, crop_region=None,\n", " close_figure=True, output_image_height=300))\n", " crop_region = determine_crop_region(\n", " keypoints_with_scores, image_height, image_width)\n", " bar.update(progress(frame_idx, num_frames-1))\n", "\n", "# Prepare gif visualization.\n", "output = np.stack(output_images, axis=0)\n", "to_gif(output, fps=10)" ] } ], "metadata": { "accelerator": "GPU", "colab": { "collapsed_sections": [ "9u_VGR6_BmbZ", "5I3xBq80E3N_", "L2JmA1xAEntQ" ], "name": "movenet.ipynb", "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 0 }