{ "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": "2024-01-11T19:50:15.015968Z", "iopub.status.busy": "2024-01-11T19:50:15.015354Z", "iopub.status.idle": "2024-01-11T19:50:15.019245Z", "shell.execute_reply": "2024-01-11T19:50:15.018648Z" }, "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 で実行\n", "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) で提供され、ライトニングとサンダーとして知られる 2 つのバリアントがあります。ライトニングはレイテンシクリティカルなアプリケーションに、サンダーは高精度を必要とするアプリケーションに適しています。両モデルは、ほとんどの現代のデスクトップ、ラップトップ、スマートフォンでリアルタイム (30+ FPS) よりも高速に実行され、これはライブフィットネス、ヘルス、およびウェルネスアプリケーションにとって不可欠です。\n", "\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": "2024-01-11T19:50:15.022793Z", "iopub.status.busy": "2024-01-11T19:50:15.022564Z", "iopub.status.idle": "2024-01-11T19:50:25.874954Z", "shell.execute_reply": "2024-01-11T19:50:25.873857Z" }, "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": "2024-01-11T19:50:25.879374Z", "iopub.status.busy": "2024-01-11T19:50:25.879094Z", "iopub.status.idle": "2024-01-11T19:50:28.722503Z", "shell.execute_reply": "2024-01-11T19:50:28.721810Z" }, "id": "9BLeJv-pCCld" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:50:26.313001: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", "2024-01-11 19:50:26.313045: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "2024-01-11 19:50:26.314632: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\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": "2024-01-11T19:50:28.726762Z", "iopub.status.busy": "2024-01-11T19:50:28.726381Z", "iopub.status.idle": "2024-01-11T19:50:28.745476Z", "shell.execute_reply": "2024-01-11T19:50:28.744815Z" }, "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, duration):\n", " \"\"\"Converts image sequence (4D numpy array) to gif.\"\"\"\n", " imageio.mimsave('./animation.gif', images, duration=duration)\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": "2024-01-11T19:50:28.748878Z", "iopub.status.busy": "2024-01-11T19:50:28.748652Z", "iopub.status.idle": "2024-01-11T19:50:42.703326Z", "shell.execute_reply": "2024-01-11T19:50:42.702559Z" }, "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": "2024-01-11T19:50:42.707822Z", "iopub.status.busy": "2024-01-11T19:50:42.707521Z", "iopub.status.idle": "2024-01-11T19:50:43.037204Z", "shell.execute_reply": "2024-01-11T19:50:43.036021Z" }, "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": "2024-01-11T19:50:43.042008Z", "iopub.status.busy": "2024-01-11T19:50:43.041362Z", "iopub.status.idle": "2024-01-11T19:50:43.187814Z", "shell.execute_reply": "2024-01-11T19:50:43.186986Z" }, "id": "lJZYQ8KYFQ6x" }, "outputs": [], "source": [ "# 入力画像を読み込む。\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": "2024-01-11T19:50:43.192019Z", "iopub.status.busy": "2024-01-11T19:50:43.191471Z", "iopub.status.idle": "2024-01-11T19:50:46.895359Z", "shell.execute_reply": "2024-01-11T19:50:46.894684Z" }, "id": "VHmTwACwFW-v" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "data": { "image/png": "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", "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": "2024-01-11T19:50:46.900978Z", "iopub.status.busy": "2024-01-11T19:50:46.900707Z", "iopub.status.idle": "2024-01-11T19:50:46.918413Z", "shell.execute_reply": "2024-01-11T19:50:46.917781Z" }, "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": "2024-01-11T19:50:46.921818Z", "iopub.status.busy": "2024-01-11T19:50:46.921153Z", "iopub.status.idle": "2024-01-11T19:50:48.303023Z", "shell.execute_reply": "2024-01-11T19:50:48.301989Z" }, "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": "2024-01-11T19:50:48.307314Z", "iopub.status.busy": "2024-01-11T19:50:48.306997Z", "iopub.status.idle": "2024-01-11T19:50:48.463413Z", "shell.execute_reply": "2024-01-11T19:50:48.462746Z" }, "id": "IxbMFZJUkd6W" }, "outputs": [], "source": [ "# 入力画像を読み込む。\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": "2024-01-11T19:50:48.467804Z", "iopub.status.busy": "2024-01-11T19:50:48.467189Z", "iopub.status.idle": "2024-01-11T19:50:57.250126Z", "shell.execute_reply": "2024-01-11T19:50:57.249153Z" }, "id": "9B57XS0NZPIy" }, "outputs": [ { "data": { "text/html": [ "\n", " \n", " 41\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_128592/2693263076.py:162: MatplotlibDeprecationWarning: The tostring_rgb function was deprecated in Matplotlib 3.8 and will be removed two minor releases later. Use buffer_rgba instead.\n", " image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n" ] }, { "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, duration=100)" ] } ], "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.18" } }, "nbformat": 4, "nbformat_minor": 0 }