diff --git "a/ViTPose/easy_ViTPose/easy_ViTPose/ViTPose_Inference.ipynb" "b/ViTPose/easy_ViTPose/easy_ViTPose/ViTPose_Inference.ipynb" new file mode 100644--- /dev/null +++ "b/ViTPose/easy_ViTPose/easy_ViTPose/ViTPose_Inference.ipynb" @@ -0,0 +1,2423 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "dcfcb0a2-93fb-4f3c-aa40-56fbe6a5dcff", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "from easy_ViTPose import VitInference\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Image to run inference RGB format\n", + "img = cv2.imread('testVITPOSE.jpg')\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + "# set is_video=True to enable tracking in video inference\n", + "# be sure to use VitInference.reset() function to reset the tracker after each video\n", + "# There are a few flags that allows to customize VitInference, be sure to check the class definition\n", + "model_path = r'C:\\Users\\user\\ViTPose/ckpts/vitpose-s-coco_25.pth'\n", + "yolo_path = r'C:\\Users\\user\\ViTPose/yolov8s.pt'\n", + "\n", + "# If you want to use MPS (on new macbooks) use the torch checkpoints for both ViTPose and Yolo\n", + "# If device is None will try to use cuda -> mps -> cpu (otherwise specify 'cpu', 'mps' or 'cuda')\n", + "# dataset and det_class parameters can be inferred from the ckpt name, but you can specify them.\n", + "model = VitInference(model_path, yolo_path, model_name='s', yolo_size=320, is_video=False, device=\"cuda\")\n", + "\n", + "# Infer keypoints, output is a dict where keys are person ids and values are keypoints (np.ndarray (25, 3): (y, x, score))\n", + "# If is_video=True the IDs will be consistent among the ordered video frames.\n", + "keypoints = model.inference(img)\n", + "\n", + "# call model.reset() after each video\n", + "\n", + "img = model.draw(show_yolo=True) # Returns RGB image with drawings\n", + "plt.imshow(img)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "772c119d-0e34-488a-bcec-40e0007155aa", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9e2a99d2-ece2-4f00-b9e1-e130099026bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "id": "ea96beea-c174-45c4-9119-e3db40f18793", + "metadata": {}, + "source": [ + "# Training the ViT_Pose" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ba4a27fc-20e0-433f-9de5-65320f963af9", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) OpenMMLab. All rights reserved.\n", + "import argparse\n", + "import copy\n", + "import os\n", + "import os.path as osp\n", + "import time\n", + "import warnings\n", + "import click\n", + "import yaml\n", + "\n", + "from glob import glob\n", + "\n", + "import torch\n", + "import torch.distributed as dist\n", + "\n", + "from vit_utils.util import init_random_seed, set_random_seed\n", + "from vit_utils.dist_util import get_dist_info, init_dist\n", + "from vit_utils.logging import get_root_logger\n", + "\n", + "import configs.ViTPose_small_coco_256x192 as s_cfg\n", + "# import configs.ViTPose_base_coco_256x192 as b_cfg\n", + "# import configs.ViTPose_large_coco_256x192 as l_cfg\n", + "# import configs.ViTPose_huge_coco_256x192 as h_cfg\n", + "\n", + "from vit_models.model import ViTPose\n", + "from datasets.COCO import COCODataset\n", + "from vit_utils.train_valid_fn import train_model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4ef1a26d-9303-4859-9112-bedea1dd46e8", + "metadata": {}, + "outputs": [], + "source": [ + "__file__ = r\"C:\\Users\\user\\ViTPose\\easy_ViTPose\\easy_ViTPose\"\n", + "CUR_PATH = osp.dirname(__file__)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "21be3367-277e-4d8c-8fca-d7524235c21b", + "metadata": {}, + "outputs": [], + "source": [ + "model_name = 's'\n", + "config_path = 'config.yaml'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16e707e1-e55b-4c44-abc3-fd217a60b381", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "2d5c73bb-6486-4513-af1c-3c37c08e80f8", + "metadata": {}, + "source": [ + "### Loading the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41ea408e-c350-48d5-bf88-d9a2a68322c2", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "\n", + "# Load the JSON file\n", + "with open(r\"D:\\ViTPose\\Evaluating\\annotations\\person_keypoints_val2017.json\", 'r') as f:\n", + " coco_data = json.load(f)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7bee2d84-71c7-4f53-8154-3b7340bd8708", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "590ad908-cc80-4c4e-a2af-88450a2aa77e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c1fa1c4b-75ff-4ed9-a46d-90c639acae41", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a mapping of image_id to file_name\n", + "image_id_to_filename = {img['id']: img['file_name'] for img in coco_data['images']}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8b2585-0ef4-4dc2-86ef-ab6d5d799075", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b83f079-efd1-416b-ab6c-29e80e668cff", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dde6eac-a62d-49b1-ad27-a39c114e0f1b", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "37899bdc-69a4-4271-8fd7-aa03148883a2", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example: Process keypoints for one annotation\n", + "# for ann in annotations:\n", + "# keypoints = ann['keypoints']\n", + "# keypoints_array = [keypoints[i:i + 3] for i in range(0, len(keypoints), 3)]\n", + "# print(\"Keypoints:\", keypoints_array)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9942e11-9394-4f67-a5ed-2ee700d33625", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b030648f-8e1f-4abe-8351-a7ae34cb3bb2", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9b30c5c1-6657-4102-8cd6-3f68b100bf61", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "data_dir = r'D:\\ViTPose\\Evaluating\\val2017\\\\'\n", + "dataset = []\n", + "\n", + "for ann in coco_data['annotations']:\n", + " image_id = ann['image_id']\n", + " #print(\"image_id: \", image_id)\n", + " file_name = image_id_to_filename[image_id]\n", + " #print(\"file_name: \", file_name)\n", + " image_path = os.path.join(data_dir, file_name)\n", + " #print(\"image_path: \", image_path)\n", + " # Load the image\n", + " if not os.path.exists(image_path):\n", + " continue\n", + " image = Image.open(image_path).convert('RGB')\n", + " \n", + " # Process keypoints\n", + " keypoints = ann['keypoints']\n", + " keypoints_array = np.array([keypoints[i:i + 3] for i in range(0, len(keypoints), 3)])\n", + " \n", + " # Collect data\n", + " dataset.append((image, keypoints_array))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a9c3c26-7d13-4103-97c1-f5d51cef5584", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "47734b7b-3c0f-4e58-abe6-bc6a70dc29c9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "397133\n", + "000000397133.jpg\n" + ] + } + ], + "source": [ + "print(coco_data['images'][0]['id'])\n", + "print(coco_data['images'][0]['file_name'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9463a1ea-09be-4138-b6d7-501a4f25c2f1", + "metadata": {}, + "outputs": [], + "source": [ + "# Apply scaling transformation for each keypoint\n", + "def resize_keypoints(keypoints, scale_w, scale_h):\n", + " resized_keypoints = keypoints.clone()\n", + " \n", + " for j in range(keypoints.shape[0]):\n", + " x, y, visibility = keypoints[j]\n", + " # Only resize if visibility > 0 (to ignore invisible keypoints)\n", + " if visibility > 0:\n", + " resized_keypoints[j, 0] = int(x * scale_w)\n", + " resized_keypoints[j, 1] = int(y * scale_h)\n", + " \n", + " return resized_keypoints\n", + "\n", + "\n", + "\n", + "def transformKeypoint(img, target_shape, keypoints):\n", + " orig_width, orig_height = img.width, img.height\n", + " (target_width, target_height) = target_shape\n", + " \n", + " # Scaling factors for width and height\n", + " scale_w = target_width / orig_width\n", + " scale_h = target_height / orig_height\n", + " # Resized keypoints\n", + " resized_keypoints = resize_keypoints(keypoints, scale_w, scale_h)\n", + " \n", + " # Print the resized keypoints\n", + " #print(\"Resized Keypoints:\\n\", resized_keypoints)\n", + " return resized_keypoints\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "012be853-653e-4651-9861-fc2e11a00a00", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be1f8f9d-2c11-4ddc-a646-e193b79d3829", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3faf2805-5a62-4f5a-967b-4e7ec1c32c87", + "metadata": {}, + "outputs": [], + "source": [ + "target_shape = (208, 208)\n", + "import torch\n", + "from torch.utils.data import Dataset\n", + "\n", + "class COCOKeypointsDataset(Dataset):\n", + " def __init__(self, json_path, images_dir, transform=None, transformKP = None):\n", + " with open(json_path, 'r') as f:\n", + " coco_data = json.load(f)\n", + " \n", + " self.image_id_to_filename = {img['id']: img['file_name'] for img in coco_data['images']}\n", + " self.annotations = coco_data['annotations']\n", + " self.images_dir = images_dir\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.annotations)\n", + "\n", + " def __getitem__(self, idx):\n", + " # Get annotation\n", + " ann = self.annotations[idx]\n", + " image_id = ann['image_id']\n", + " file_name = self.image_id_to_filename[image_id]\n", + " image_path = os.path.join(self.images_dir, file_name)\n", + " \n", + " # Load image\n", + " image = Image.open(image_path).convert('RGB')\n", + " \n", + " # Process keypoints\n", + " keypoints = ann['keypoints']\n", + " keypoints = torch.tensor([keypoints[i:i + 3] for i in range(0, len(keypoints), 3)], dtype=torch.float32) \n", + " keypoints = transformKeypoint(image, target_shape, keypoints)\n", + " #print(\"keypoints: \", keypoints)\n", + " \n", + " # Apply transformations\n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, keypoints\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "960b56d0-391d-4cd5-886c-c951d5e5bf63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccddf3cf-5b28-4fad-a467-917a53d19d63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47ebf732-8f35-4caa-85ec-5dabb6e95e93", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "05380b1e-f0d4-4dcc-84de-147726da3ac4", + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision import transforms\n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((208, 208)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "dataset = COCOKeypointsDataset(\n", + " json_path=r\"D:\\ViTPose\\Evaluating\\annotations\\person_keypoints_val2017.json\",\n", + " images_dir=r'D:\\ViTPose\\Evaluating\\val2017\\\\',\n", + " transform=transform\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "62efbb61-7d6e-4b8d-9fe5-537ca0f7ee04", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "dataloader = DataLoader(dataset, batch_size=4, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c2a8ab8-5496-462d-a58b-f87f06e427bf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d9d940c5-13f6-4b24-a887-28f08f370d04", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Images shape: torch.Size([4, 3, 208, 208])\n", + "Keypoints shape: torch.Size([4, 17, 3])\n", + "keypoints: tensor([[[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [150., 2., 2.],\n", + " [146., 10., 2.],\n", + " [ 0., 0., 0.],\n", + " [145., 18., 2.],\n", + " [ 0., 0., 0.],\n", + " [148., 20., 2.],\n", + " [151., 19., 2.],\n", + " [146., 33., 1.],\n", + " [151., 33., 1.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[152., 67., 2.],\n", + " [155., 65., 2.],\n", + " [150., 64., 2.],\n", + " [158., 65., 2.],\n", + " [ 0., 0., 0.],\n", + " [163., 81., 2.],\n", + " [146., 76., 2.],\n", + " [166., 104., 2.],\n", + " [140., 88., 2.],\n", + " [160., 123., 2.],\n", + " [141., 99., 2.],\n", + " [156., 119., 2.],\n", + " [146., 115., 2.],\n", + " [154., 149., 2.],\n", + " [142., 146., 2.],\n", + " [152., 177., 2.],\n", + " [144., 171., 2.]]])\n" + ] + } + ], + "source": [ + "for images, keypoints in dataloader:\n", + " print(\"Images shape:\", images.shape)\n", + " print(\"Keypoints shape:\", keypoints.shape)\n", + " print(\"keypoints: \", keypoints)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b26cfb19-15d6-47a6-8114-6ef1385d6fbc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e5e00bc-e79f-408f-bd3c-7663225cde47", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e24981bc-7a91-45ba-bcc5-d79a7604b8b3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "670e81c3-27a2-43ef-a149-f4d88d7214c4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "97e0ee06-e303-4a6c-8cda-eb6087693980", + "metadata": {}, + "source": [ + "### Ending loading the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8334085f-85d4-4889-9f7f-71e8b7b6adc5", + "metadata": {}, + "outputs": [], + "source": [ + "cfg = {'s':s_cfg}.get(model_name.lower())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b7b53af5-0822-47a4-be61-6f8b2de9f9c6", + "metadata": {}, + "outputs": [], + "source": [ + "# Load config.yaml\n", + "with open(config_path, 'r') as f:\n", + " cfg_yaml = yaml.load(f, Loader=yaml.SafeLoader)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7ef13d0b-2fd5-4313-9822-8b1626da933f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'log_level': 'logging.INFO',\n", + " 'seed': 0,\n", + " 'gpu_ids': [0],\n", + " 'deterministic': True,\n", + " 'cudnn_benchmark': True,\n", + " 'resume_from': 'C:/Users/user/ViTPose/ckpts/vitpose-s-coco_25.pth',\n", + " 'launcher': 'none',\n", + " 'use_amp': False,\n", + " 'validate': True,\n", + " 'autoscale_lr': False,\n", + " 'dist_params': '...'}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg_yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "64402e77-c6b8-49bb-90db-6693de309268", + "metadata": {}, + "outputs": [], + "source": [ + "for k, v in cfg_yaml.items():\n", + " if hasattr(cfg, k):\n", + " raise ValueError(f\"Already exists {k} in config\")\n", + " else:\n", + " cfg.__setattr__(k, v)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98b406f9-d79a-40ed-af8a-e73d4808776a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "057c9e72-4693-4387-a141-a844159b6410", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88841210-3245-47d4-8fea-22a3fdff04ab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "765d06d7-dcc9-46a0-a9bc-9569ff314eec", + "metadata": {}, + "outputs": [], + "source": [ + "# set cudnn_benchmark\n", + "if cfg.cudnn_benchmark:\n", + " torch.backends.cudnn.benchmark = True" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "14bcd3c1-01e4-4308-a693-7cba5b28ec97", + "metadata": {}, + "outputs": [], + "source": [ + "# Set work directory (session-level)\n", + "if not hasattr(cfg, 'work_dir'):\n", + " cfg.__setattr__('work_dir', f\"{CUR_PATH}/runs/train\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fe3506fa-36d0-461e-8f18-856a35ae3268", + "metadata": {}, + "outputs": [], + "source": [ + "if not osp.exists(cfg.work_dir):\n", + " os.makedirs(cfg.work_dir)\n", + "session_list = sorted(glob(f\"{cfg.work_dir}/*\"))\n", + "if len(session_list) == 0:\n", + " session = 1\n", + "else:\n", + " session = int(os.path.basename(session_list[-1])) + 1\n", + "session_dir = osp.join(cfg.work_dir, str(session).zfill(3))\n", + "os.makedirs(session_dir)\n", + "cfg.__setattr__('work_dir', session_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "aaffeee8-3d10-4cb8-ab1b-98f79bdb9910", + "metadata": {}, + "outputs": [], + "source": [ + "if cfg.autoscale_lr:\n", + " # apply the linear scaling rule (https://arxiv.org/abs/1706.02677)\n", + " cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c022f17-9135-4317-a8ca-e7d4b51b4d1a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "bc6c864a-6cf0-4599-aa2a-0de7f6fd19ec", + "metadata": {}, + "outputs": [], + "source": [ + "# init distributed env first, since logger depends on the dist info.\n", + "if cfg.launcher == 'none':\n", + " distributed = False\n", + " if len(cfg.gpu_ids) > 1:\n", + " warnings.warn(\n", + " f\"We treat {cfg['gpu_ids']} as gpu-ids, and reset to \"\n", + " f\"{cfg['gpu_ids'][0:1]} as gpu-ids to avoid potential error in \"\n", + " \"non-distribute training time.\")\n", + " cfg.gpu_ids = cfg.gpu_ids[0:1]\n", + "else:\n", + " distributed = True\n", + " init_dist(cfg.launcher, **cfg.dist_params)\n", + " # re-set gpu_ids with distributed training mode\n", + " _, world_size = get_dist_info()\n", + " cfg.gpu_ids = range(world_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "935e56e5-d5d1-4f19-bba0-6d659665c570", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3881144e-53b7-4a2b-b878-0d8c43a17d82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-25 08:52:31,377 - vit_utils - INFO - Distributed training: False\n", + "2024-12-25 08:52:31,378 - vit_utils - INFO - Set random seed to 0, deterministic: True\n" + ] + } + ], + "source": [ + "# init the logger before other steps\n", + "timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())\n", + "log_file = osp.join(session_dir, f'{timestamp}.log')\n", + "logger = get_root_logger(log_file=log_file)\n", + "\n", + "# init the meta dict to record some important information such as\n", + "# environment info and seed, which will be logged\n", + "meta = dict()\n", + "\n", + "# log some basic info\n", + "logger.info(f'Distributed training: {distributed}')\n", + "\n", + "# set random seeds\n", + "seed = init_random_seed(cfg.seed)\n", + "logger.info(f\"Set random seed to {seed}, \"\n", + " f\"deterministic: {cfg.deterministic}\")\n", + "set_random_seed(seed, deterministic=cfg.deterministic)\n", + "meta['seed'] = seed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0588f6f-6fe0-4ac6-9fcf-a2c744e68091", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5878400f-1165-4301-aad8-aef907113a4a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_19640\\1963230343.py:5: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " ckpt_state = torch.load(cfg.resume_from) #['state_dict']\n" + ] + } + ], + "source": [ + "# Set model\n", + "model = ViTPose(cfg.model)\n", + "if cfg.resume_from:\n", + " # Load ckpt partially\n", + " ckpt_state = torch.load(cfg.resume_from) #['state_dict']\n", + " ckpt_state.pop('keypoint_head.final_layer.bias')\n", + " ckpt_state.pop('keypoint_head.final_layer.weight')\n", + " model.load_state_dict(ckpt_state, strict=False)\n", + "\n", + " # freeze the backbone, leave the head to be finetuned\n", + " model.backbone.frozen_stages = model.backbone.depth - 1\n", + " model.backbone.freeze_ffn = True\n", + " model.backbone.freeze_attn = True\n", + " model.backbone._freeze_stages()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52cef111-bc9c-417d-9770-7595408863be", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "93e7765d-94ca-4a16-b4d6-c95085bfad35", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ViTPose(\n", + " (backbone): ViT(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 384, kernel_size=(16, 16), stride=(16, 16), padding=(2, 2))\n", + " )\n", + " (blocks): ModuleList(\n", + " (0): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.00909090880304575)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (2): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.0181818176060915)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (3): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.027272727340459824)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (4): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.036363635212183)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (5): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.045454543083906174)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (6): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.054545458406209946)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (7): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.06363636255264282)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (8): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.0727272778749466)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (9): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.08181818574666977)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (10): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.09090909361839294)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (11): Block(\n", + " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (attn): Attention(\n", + " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=384, out_features=384, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): DropPath(p=0.10000000149011612)\n", + " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (last_norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", + " )\n", + " (keypoint_head): TopdownHeatmapSimpleHead(\n", + " (deconv_layers): Sequential(\n", + " (0): ConvTranspose2d(384, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): ConvTranspose2d(256, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): ReLU(inplace=True)\n", + " )\n", + " (final_layer): Conv2d(256, 17, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + ")" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "851da2fd-707c-4dc9-bca0-99ac5530374a", + "metadata": {}, + "outputs": [], + "source": [ + "# Set dataset\n", + "datasets_train = dataloader\n", + "datasets_valid = dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d352a68-dccd-4d94-86c7-deb716545df4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5af32dc2-8a9c-4abf-bc31-1454d64622e2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch 1:\n", + " - Images: torch.Size([4, 3, 208, 208])\n", + " - Labels: tensor([[[ 83., 46., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 83., 44., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 79., 44., 2.],\n", + " [ 83., 53., 2.],\n", + " [ 75., 54., 2.],\n", + " [ 86., 64., 2.],\n", + " [ 78., 70., 2.],\n", + " [ 90., 78., 2.],\n", + " [ 87., 79., 2.],\n", + " [ 83., 80., 2.],\n", + " [ 78., 81., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 80., 99., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 74., 121., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [200., 83., 2.],\n", + " [ 0., 0., 0.],\n", + " [192., 150., 2.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 74., 48., 2.],\n", + " [ 63., 59., 2.],\n", + " [ 64., 60., 2.],\n", + " [ 70., 82., 2.],\n", + " [ 72., 85., 2.],\n", + " [ 83., 83., 2.],\n", + " [ 76., 62., 2.],\n", + " [ 58., 107., 2.],\n", + " [ 58., 109., 2.],\n", + " [ 83., 87., 2.],\n", + " [ 84., 98., 2.],\n", + " [ 75., 115., 1.],\n", + " [ 77., 141., 2.]],\n", + "\n", + " [[ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.],\n", + " [ 0., 0., 0.]]])\n" + ] + } + ], + "source": [ + "# Iterate Through the DataLoader\n", + "for batch_idx, (images, labels) in enumerate(dataloader):\n", + " print(f\"Batch {batch_idx + 1}:\")\n", + " print(f\" - Images: {images.shape}\") # Shape: (batch_size, 3, H, W)\n", + " print(f\" - Labels: {labels}\") # Tensor of labels\n", + " # Perform operations on images and labels (e.g., training)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c7000fcb-4487-4671-a88c-635da8e17d93", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([17, 3])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68165efc-54b3-4774-81d7-5e87b409219f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "48811727-c7b5-48ec-8d2e-234e14cd1312", + "metadata": {}, + "source": [ + "train_model(\n", + " model=model,\n", + " datasets_train=datasets_train,\n", + " datasets_valid=datasets_valid,\n", + " cfg=cfg,\n", + " distributed=distributed,\n", + " validate=cfg.validate,\n", + " timestamp=timestamp,\n", + " meta=meta\n", + " )" + ] + }, + { + "cell_type": "raw", + "id": "62b37ca0-46a6-49e9-8d7b-5f0c69b93f20", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import os.path as osp\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "from vit_models.losses import JointsMSELoss\n", + "from vit_models.optimizer import LayerDecayOptimizer\n", + "\n", + "from torch.nn.parallel import DataParallel, DistributedDataParallel\n", + "from torch.nn.utils import clip_grad_norm_\n", + "from torch.optim import AdamW\n", + "from torch.optim.lr_scheduler import LambdaLR, MultiStepLR\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from torch.utils.data.distributed import DistributedSampler\n", + "from torch.cuda.amp import autocast, GradScaler\n", + "from tqdm import tqdm\n", + "from time import time\n", + "\n", + "\n", + "logger = get_root_logger()\n", + "\n", + " \n", + "dataloaders_train = datasets_train\n", + "dataloaders_valid = datasets_valid\n", + "# put model on gpus\n", + "if distributed:\n", + " find_unused_parameters = cfg.get('find_unused_parameters', False)\n", + " # Sets the `find_unused_parameters` parameter in\n", + " # torch.nn.parallel.DistributedDataParallel\n", + "\n", + " model = DistributedDataParallel(\n", + " module=model, \n", + " device_ids=[torch.cuda.current_device()], \n", + " broadcast_buffers=False, \n", + " find_unused_parameters=find_unused_parameters)\n", + "else:\n", + " model = DataParallel(model, device_ids=cfg.gpu_ids)\n", + "\n", + "# Loss function\n", + "criterion = JointsMSELoss(use_target_weight=cfg.model['keypoint_head']['loss_keypoint']['use_target_weight'])\n", + "\n", + "# Optimizer\n", + "optimizer = AdamW(model.parameters(), lr=cfg.optimizer['lr'], betas=cfg.optimizer['betas'], weight_decay=cfg.optimizer['weight_decay'])\n", + "\n", + "# Layer-wise learning rate decay\n", + "lr_mult = [cfg.optimizer['paramwise_cfg']['layer_decay_rate']] * cfg.optimizer['paramwise_cfg']['num_layers']\n", + "layerwise_optimizer = LayerDecayOptimizer(optimizer, lr_mult)\n", + "\n", + "\n", + "# Learning rate scheduler (MultiStepLR)\n", + "milestones = cfg.lr_config['step']\n", + "gamma = 0.1\n", + "scheduler = MultiStepLR(optimizer, milestones, gamma)\n", + "\n", + "# Warm-up scheduler\n", + "num_warmup_steps = cfg.lr_config['warmup_iters'] # Number of warm-up steps\n", + "warmup_factor = cfg.lr_config['warmup_ratio'] # Initial learning rate = warmup_factor * learning_rate\n", + "warmup_scheduler = LambdaLR(\n", + " optimizer,\n", + " lr_lambda=lambda step: warmup_factor + (1.0 - warmup_factor) * step / num_warmup_steps\n", + ")\n", + "\n", + "# AMP setting\n", + "if cfg.use_amp:\n", + " logger.info(\"Using Automatic Mixed Precision (AMP) training...\")\n", + " # Create a GradScaler object for FP16 training\n", + " scaler = GradScaler()\n", + "\n", + "# Logging config\n", + "total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "logger.info(f'''\\n\n", + "#========= [Train Configs] =========#\n", + "# - Num GPUs: {len(cfg.gpu_ids)}\n", + "# - Batch size (per gpu): {cfg.data['samples_per_gpu']}\n", + "# - LR: {cfg.optimizer['lr']: .6f}\n", + "# - Num params: {total_params:,d}\n", + "# - AMP: {cfg.use_amp}\n", + "#===================================# \n", + "''')\n", + "\n", + "global_step = 0\n", + "for dataloader in dataloaders_train:\n", + " print(\"start training\")\n", + " for epoch in range(cfg.total_epochs):\n", + " model.train()\n", + " train_pbar = tqdm(dataloader)\n", + " total_loss = 0\n", + " tic = time()\n", + " for batch_idx, batch in enumerate(train_pbar):\n", + " layerwise_optimizer.zero_grad()\n", + " \n", + " images, targets, target_weights, __ = batch\n", + " images = images.to('cuda').unsqueeze(0)\n", + " targets = targets.to('cuda').unsqueeze(0)\n", + " target_weights = target_weights.to('cuda')\n", + " \n", + " if cfg.use_amp:\n", + " with autocast():\n", + " outputs = model(images)\n", + " loss = criterion(outputs, targets, target_weights)\n", + " scaler.scale(loss).backward()\n", + " clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip'])\n", + " scaler.step(layerwise_optimizer)\n", + " scaler.update()\n", + " else:\n", + " print(images.shape)\n", + " outputs = model(images)\n", + " print(\"outputs: \", outputs.shape)\n", + " print(\"targets: \", targets.shape)\n", + " loss = criterion(outputs, targets, target_weights)\n", + " loss.backward()\n", + " clip_grad_norm_(model.parameters(), **cfg.optimizer_config['grad_clip'])\n", + " layerwise_optimizer.step()\n", + " \n", + " if global_step < num_warmup_steps:\n", + " warmup_scheduler.step()\n", + " global_step += 1\n", + " \n", + " total_loss += loss.item()\n", + " train_pbar.set_description(f\"🏋️> Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Loss {loss.item():.4f} | LR {optimizer.param_groups[0]['lr']:.6f} | Step\")\n", + " scheduler.step()\n", + " \n", + " avg_loss_train = total_loss/len(dataloader)\n", + " logger.info(f\"[Summary-train] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (train) {avg_loss_train:.4f} --- {time()-tic:.5f} sec. elapsed\")\n", + " ckpt_name = f\"epoch{str(epoch).zfill(3)}.pth\"\n", + " ckpt_path = osp.join(cfg.work_dir, ckpt_name)\n", + " torch.save(model.module.state_dict(), ckpt_path)\n", + "\n", + " # validation\n", + " if validate:\n", + " tic2 = time()\n", + " avg_loss_valid = valid_model(model, dataloaders_valid, criterion, cfg)\n", + " logger.info(f\"[Summary-valid] Epoch [{str(epoch).zfill(3)}/{str(cfg.total_epochs).zfill(3)}] | Average Loss (valid) {avg_loss_valid:.4f} --- {time()-tic2:.5f} sec. elapsed\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c3aaa51-efa5-414c-a0a8-9f3b475ca67e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2f0dd2c-ceaa-40c1-943f-3392c4bb1b3d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc8f7cda-227e-4a03-b694-97af713b73f6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91348ce9-12d7-4882-b222-b9b60cedebec", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1e63562-cc6c-460d-aab5-f2f9bb5724cc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6b2dd91c-9830-41a3-bddd-6c2f09254a7c", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda')\n", + "# Move model to device\n", + "model = model.to(device)\n", + "\n", + "# Move inputs to device\n", + "images = images.to(device)\n" + ] + }, + { + "cell_type": "markdown", + "id": "faf1e322-2867-47d7-8778-09e83ead56ef", + "metadata": {}, + "source": [ + "## Define my own training process" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4cbc9686-7e2f-4fcb-af2b-b260fb8051f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4ed1ef2-58d7-4d18-9966-1ebb95adc529", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e568149-21ff-47c5-93f1-35d7290b837f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0a0a470-7c51-4027-b1cb-85d5a52bb28e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "430f8a82-9c8f-4014-b3ff-ac9548213294", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4b00355-74b1-4f87-abd1-2e2dc31846e6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2de2c69e-ebc5-4e96-aa0e-5aab0cc88c31", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "867a6faa-7419-4a01-9719-2739639be673", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "source": [ + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "def generate_heatmaps(keypoints, output_size):\n", + " \"\"\"\n", + " Generate heatmaps from keypoints for training.\n", + " Args:\n", + " - keypoints: Tensor of shape (batch_size, num_keypoints, 3) containing (x, y, visibility)\n", + " - output_size: (height, width) of the heatmaps\n", + " Returns:\n", + " - heatmaps: Tensor of shape (batch_size, num_keypoints, height, width)\n", + " \"\"\"\n", + " batch_size, num_keypoints, _ = keypoints.shape\n", + " height, width = output_size\n", + " heatmaps = torch.zeros(batch_size, num_keypoints, height, width, device=keypoints.device)\n", + "\n", + " #print(\"heatmaps: \", heatmaps)\n", + " for i in range(batch_size):\n", + " for j in range(num_keypoints):\n", + " x, y, visibility = keypoints[i, j, 0], keypoints[i, j, 1], keypoints[i, j, 2]\n", + " if visibility > 0:\n", + " # Create a Gaussian heatmap for each keypoint\n", + " gaussian = generate_gaussian(x, y, height, width)\n", + " print(\"gaussian max: \", gaussian.max())\n", + " print(\"gaussian min: \", gaussian.min())\n", + " heatmaps[i, j] = gaussian\n", + "\n", + " return heatmaps\n", + "\n", + "def generate_gaussian(x, y, height, width, sigma=1):\n", + " \"\"\"\n", + " Generate a Gaussian heatmap centered at (x, y) with standard deviation sigma.\n", + " \"\"\"\n", + " grid_x, grid_y = torch.meshgrid(torch.arange(0, width), torch.arange(0, height))\n", + " grid = torch.stack([grid_x, grid_y], dim=-1).float()\n", + " \n", + " mean = torch.tensor([x, y], dtype=torch.float32)\n", + " variance = sigma ** 2\n", + " diff = grid - mean\n", + " dist = torch.sum(diff ** 2, dim=-1)\n", + " gaussian = torch.exp(-dist / (2 * variance))\n", + "\n", + " return gaussian\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdf3b94a-370e-481b-a1a6-9c165bc06e34", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3e554ac4-3b6f-4621-8bde-a358e68e8e25", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "images.shape: torch.Size([4, 3, 208, 208])\n", + "labels.shape: torch.Size([4, 17, 3])\n" + ] + } + ], + "source": [ + "for images, labels in dataloader:\n", + " print(\"images.shape: \", images.shape)\n", + " print(\"labels.shape: \", labels.shape)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f2e9ad48-4a8e-4bdd-91a2-68f810e859c4", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'plt' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[32], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241m.\u001b[39mimshow(outputs[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 2\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'plt' is not defined" + ] + } + ], + "source": [ + "plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38308db6-5e0c-4d08-91c4-b7408adcb81a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf122f87-f911-4c39-a6fc-4f004d1988ce", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9c5386a0-b07b-47f5-be1e-9af65dcb6de2", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "\n", + "def generate_heatmaps(keypoints, output_size, sigma=2):\n", + " \"\"\"\n", + " Generate ground truth heatmaps for keypoints.\n", + " \n", + " Args:\n", + " keypoints: Tensor of shape (batch_size, num_keypoints, 3) with (x, y, confidence).\n", + " output_size: Tuple (height, width) of the heatmap.\n", + " sigma: Standard deviation of the Gaussian.\n", + " \n", + " Returns:\n", + " heatmaps: Tensor of shape (batch_size, num_keypoints, height, width).\n", + " \"\"\"\n", + " batch_size, num_keypoints, _ = keypoints.shape\n", + " height, width = output_size\n", + " heatmaps = torch.zeros((batch_size, num_keypoints, height, width), device=keypoints.device)\n", + "\n", + " for b in range(batch_size):\n", + " for k in range(num_keypoints):\n", + " x, y, confidence = keypoints[b, k]\n", + " \n", + " # Skip keypoints with zero confidence\n", + " if confidence <= 0 or x < 0 or y < 0:\n", + " continue\n", + " \n", + " # Create a meshgrid for Gaussian generation\n", + " xx, yy = torch.meshgrid(torch.arange(width, device=keypoints.device), \n", + " torch.arange(height, device=keypoints.device), \n", + " indexing='xy')\n", + " \n", + " # Calculate the 2D Gaussian heatmap\n", + " heatmap = torch.exp(-((xx - x)**2 + (yy - y)**2) / (2 * sigma**2))\n", + " heatmaps[b, k] = heatmap\n", + "\n", + " return heatmaps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b738642-c839-410a-8ba0-aa9698e70aa0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "6ca3122b-2019-4bc1-a8cd-39e7230d52de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated heatmaps shape: torch.Size([2, 17, 255, 255])\n" + ] + } + ], + "source": [ + "# Example usage\n", + "keypoints = torch.tensor([[[226., 129., 2.], [228., 127., 2.], [225., 127., 2.], [0., 0., 0.], [0., 0., 0.],\n", + " [233., 128., 2.], [218., 130., 2.], [239., 135., 2.], [213., 136., 2.], [243., 139., 2.],\n", + " [211., 137., 2.], [232., 149., 2.], [222., 148., 2.], [232., 169., 2.], [222., 169., 2.],\n", + " [233., 188., 2.], [221., 182., 2.]],\n", + " [[584., 101., 2.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [587., 137., 2.],\n", + " [637., 137., 2.], [567., 196., 2.], [0., 0., 0.], [561., 235., 2.], [619., 214., 2.],\n", + " [589., 222., 2.], [630., 224., 2.], [579., 317., 2.], [614., 309., 2.], [586., 400., 2.],\n", + " [611., 399., 2.]]], device='cuda:0')\n", + "\n", + "heatmaps = generate_heatmaps(keypoints, output_size=(255, 255), sigma=2)\n", + "\n", + "print(\"Generated heatmaps shape:\", heatmaps.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3615cb01-7df8-43d9-9bd1-16f644df0125", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAGiCAYAAACGUJO6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh+klEQVR4nO3df2xV9eH/8de5ve2lhd7bldLeVn5Y8AcgP2SItVEZGw0tMKfCElHm0BCIrDUD/LUaBXHLatiyLTocWbKIfwgqiUgkSoZgYc6CWiUIagN8ma3SWxTWe9tCb3t7398/kPvZ1fKjpeXybp+P5CTcc849fZ932jw5957eOsYYIwAALONK9AAAAOgOAgYAsBIBAwBYiYABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsFLCArZmzRpdeeWVGjBggAoKCvT+++8naigAAAslJGCvvPKKli9frpUrV+qjjz7SxIkTVVxcrGPHjiViOAAACzmJ+DDfgoICTZkyRX/9618lSdFoVMOGDdODDz6o3/zmN5d6OAAAC7kv9Rdsa2tTdXW1ysvLY+tcLpeKiopUVVXV6XPC4bDC4XDscTQa1YkTJzR48GA5jtPrYwYA9CxjjJqampSXlyeXq3svBl7ygH3zzTfq6OhQTk5O3PqcnBx9/vnnnT6noqJCq1atuhTDAwBcQnV1dRo6dGi3nnvJA9Yd5eXlWr58eexxMBjU8OHDdYtmya3kBI4MANAdEbXrXb2p9PT0bh/jkgcsKytLSUlJamhoiFvf0NAgv9/f6XM8Ho88Hs/31ruVLLdDwADAOt/efXExbwNd8rsQU1JSNHnyZG3fvj22LhqNavv27SosLLzUwwEAWCohLyEuX75cCxYs0A033KAbb7xRf/nLX9TS0qL7778/EcMBAFgoIQG766679PXXX2vFihUKBAK6/vrrtXXr1u/d2AEAwNkk5PfALlYoFJLP59M03c57YABgoYhpV6U2KxgMyuv1dusYfBYiAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArNTjAXvqqafkOE7cMnr06Nj21tZWlZaWavDgwRo0aJDmzp2rhoaGnh4GAKCP65UrsOuuu0719fWx5d13341tW7Zsmd544w1t3LhRO3fu1NGjRzVnzpzeGAYAoA9z98pB3W75/f7vrQ8Gg/rHP/6h9evX6yc/+Ykk6YUXXtCYMWO0e/du3XTTTb0xHABAH9QrV2AHDx5UXl6eRo4cqfnz56u2tlaSVF1drfb2dhUVFcX2HT16tIYPH66qqqreGAoAoI/q8SuwgoICrVu3Ttdee63q6+u1atUq3Xrrrdq/f78CgYBSUlKUkZER95ycnBwFAoGzHjMcDiscDsceh0Khnh42AMAyPR6wmTNnxv49YcIEFRQUaMSIEXr11VeVmprarWNWVFRo1apVPTVEAEAf0Ou30WdkZOiaa67RoUOH5Pf71dbWpsbGxrh9GhoaOn3P7Izy8nIFg8HYUldX18ujBgBc7no9YM3NzTp8+LByc3M1efJkJScna/v27bHtNTU1qq2tVWFh4VmP4fF45PV64xYAQP/W4y8hPvzww7rttts0YsQIHT16VCtXrlRSUpLuvvtu+Xw+LVy4UMuXL1dmZqa8Xq8efPBBFRYWcgciAKBLejxgX375pe6++24dP35cQ4YM0S233KLdu3dryJAhkqQ///nPcrlcmjt3rsLhsIqLi/X888/39DAAAH2cY4wxiR5EV4VCIfl8Pk3T7XI7yYkeDgCgiyKmXZXarGAw2O23hfgsRACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArNTlgO3atUu33Xab8vLy5DiOXn/99bjtxhitWLFCubm5Sk1NVVFRkQ4ePBi3z4kTJzR//nx5vV5lZGRo4cKFam5uvqgTAQD0L10OWEtLiyZOnKg1a9Z0un316tV69tlntXbtWu3Zs0cDBw5UcXGxWltbY/vMnz9fBw4c0LZt27Rlyxbt2rVLixcv7v5ZAAD6HccYY7r9ZMfRpk2bdMcdd0g6ffWVl5enhx56SA8//LAkKRgMKicnR+vWrdO8efP02WefaezYsfrggw90ww03SJK2bt2qWbNm6csvv1ReXt55v24oFJLP59M03S63k9zd4QMAEiRi2lWpzQoGg/J6vd06Ro++B3bkyBEFAgEVFRXF1vl8PhUUFKiqqkqSVFVVpYyMjFi8JKmoqEgul0t79uzp9LjhcFihUChuAQD0bz0asEAgIEnKycmJW5+TkxPbFggElJ2dHbfd7XYrMzMzts93VVRUyOfzxZZhw4b15LABABay4i7E8vJyBYPB2FJXV5foIQEAEqxHA+b3+yVJDQ0NcesbGhpi2/x+v44dOxa3PRKJ6MSJE7F9vsvj8cjr9cYtAID+rUcDlp+fL7/fr+3bt8fWhUIh7dmzR4WFhZKkwsJCNTY2qrq6OrbPjh07FI1GVVBQ0JPDAQD0Ye6uPqG5uVmHDh2KPT5y5Ij27t2rzMxMDR8+XEuXLtXvfvc7XX311crPz9eTTz6pvLy82J2KY8aMUUlJiRYtWqS1a9eqvb1dZWVlmjdv3gXdgQgAgNSNgH344Yf68Y9/HHu8fPlySdKCBQu0bt06Pfroo2ppadHixYvV2NioW265RVu3btWAAQNiz3nppZdUVlam6dOny+Vyae7cuXr22Wd74HQAAP3FRf0eWKLwe2AAYLfL7vfAAAC4VAgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFipywHbtWuXbrvtNuXl5clxHL3++utx2++77z45jhO3lJSUxO1z4sQJzZ8/X16vVxkZGVq4cKGam5sv6kQAAP1LlwPW0tKiiRMnas2aNWfdp6SkRPX19bFlw4YNcdvnz5+vAwcOaNu2bdqyZYt27dqlxYsXd330AIB+y93VJ8ycOVMzZ8485z4ej0d+v7/TbZ999pm2bt2qDz74QDfccIMk6bnnntOsWbP0xz/+UXl5eV0dEgCgH+qV98AqKyuVnZ2ta6+9VkuWLNHx48dj26qqqpSRkRGLlyQVFRXJ5XJpz549vTEcAEAf1OUrsPMpKSnRnDlzlJ+fr8OHD+vxxx/XzJkzVVVVpaSkJAUCAWVnZ8cPwu1WZmamAoFAp8cMh8MKh8Oxx6FQqKeHDQCwTI8HbN68ebF/jx8/XhMmTNCoUaNUWVmp6dOnd+uYFRUVWrVqVU8NEQDQB/T6bfQjR45UVlaWDh06JEny+/06duxY3D6RSEQnTpw46/tm5eXlCgaDsaWurq63hw0AuMz1esC+/PJLHT9+XLm5uZKkwsJCNTY2qrq6OrbPjh07FI1GVVBQ0OkxPB6PvF5v3AIA6N+6/BJic3Nz7GpKko4cOaK9e/cqMzNTmZmZWrVqlebOnSu/36/Dhw/r0Ucf1VVXXaXi4mJJ0pgxY1RSUqJFixZp7dq1am9vV1lZmebNm8cdiACAC9blK7APP/xQkyZN0qRJkyRJy5cv16RJk7RixQolJSVp3759+tnPfqZrrrlGCxcu1OTJk/Wvf/1LHo8ndoyXXnpJo0eP1vTp0zVr1izdcsst+vvf/95zZwUA6PMcY4xJ9CC6KhQKyefzaZpul9tJTvRwAABdFDHtqtRmBYPBbr8txGchAgCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAK/X4H7QEAFymHKfz9fZ9JK4kAgYA/YPjSM7pF90c1/+FzESN5EgyUetCRsAAoC9zHDlJSZLjkpPkkpKT5Xx7JWaMkRONSh0dMpHI6ZhZFDICBgB91bfxctxuOSkpkscjZ4BHSnJJLpecjg4p0iETDkunWqVI5HTMOjqsiBgBA4C+6MxLhklJp6Pl8cgZmKZoeqqM2yWT5JLTHpUr3C7n1Ld/VzHcJtPWJnV0JHbsF4iAAUBf5LjkJLvlSh0gx+dVNH2g2oak6dSQFEU8jjpSpORTRsktUXka25V8NEmuphYZx1HUkqswAgYAfc3/vnSYmqroD9IVzkpV0/AUNQ9zFBlo1JEWlbvJJc8Jt1KPJSkjYuR2HMkYOW1tp98P0+X9fhgBA4C+yPXtzRueFEXSPQr/wK2TOY5ah7dpgDesrEEn9c1/03VywABJLqV9naykFo9cp8IyLpcclyNzmb+SSMAAoK9xXKfjleyWSfUonJmsk9lJOjkiooLR/0+TvHUaM+Ar/bv5Gr3ju1rfuDOVFnArucWj5JYUOW63THtEcowu54oRMADoixxHciXJJCWpI8VRJE1KSm/XhPSvVDjwoMYnn1S7ceuIb7C+SfeqY0CKOpJdSnYnSS7n9HL5tksSHyUFAH2T+fZ3unT6QsqJnn4YNm6djHrUaqJqNclq63DLRB3JnN7PJlyBAUBfZYycjg4lhY2SWqVoc7I+a/LL40TUapK1t2W4vmryyWlOUlJYckWiUqRDiprTy2WOgAFAX2Oip2+Db2uX62SrPCfaNCjZUSTVrQ+cUfrIO0xpaWE1B1OV1OBRer2jtGNtcje2yjkVVjQS+fYTOaKJPpNzImAA0Bd1dJz+VI3WsJKaWuVJdmlgmiPjdiuSlqRTA1LlaXbkaZRSv44q5b9hOS2tMuE2mY6Ob2+jv7wRMADoa4w5HaD2iJxTrXIFW5TSYZRujNytZ36R2ZG7NaqUpqhSgu1K+m+LnOaTira2no6fBZ+JSMAAoC8yUZkOKRoOy/XfoHSyVSnNJ5X89ZmPkkqS094hp61dTrhNJtSsaFubTFu7FZ/CIREwAOibzOlP0jDtERnHOX1VFf02WElJpz/QN/Ltp9C3tcuEw6f3tSReEgEDgL7r24hF29rlJEVj74nJ5ZLjODLGfBu2aPyfU7EEAQOAvsyc/jQNY6IyEcX9UcvYjRpnomXJldcZBAwA+oNYnE7HKu4ToiwL1xkEDAD6E0tj1Rk+SgoAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACsRMACAlQgYAMBKBAwAYCUCBgCwEgEDAFiJgAEArETAAABWImAAACt1KWAVFRWaMmWK0tPTlZ2drTvuuEM1NTVx+7S2tqq0tFSDBw/WoEGDNHfuXDU0NMTtU1tbq9mzZystLU3Z2dl65JFHFIlELv5sAAD9RpcCtnPnTpWWlmr37t3atm2b2tvbNWPGDLW0tMT2WbZsmd544w1t3LhRO3fu1NGjRzVnzpzY9o6ODs2ePVttbW1677339OKLL2rdunVasWJFz50VAKDPc4wxprtP/vrrr5Wdna2dO3dq6tSpCgaDGjJkiNavX6+f//znkqTPP/9cY8aMUVVVlW666Sa99dZb+ulPf6qjR48qJydHkrR27Vo99thj+vrrr5WSknLerxsKheTz+TRNt8vtJHd3+ACABImYdlVqs4LBoLxeb7eOcVHvgQWDQUlSZmamJKm6ulrt7e0qKiqK7TN69GgNHz5cVVVVkqSqqiqNHz8+Fi9JKi4uVigU0oEDBzr9OuFwWKFQKG4BAPRv3Q5YNBrV0qVLdfPNN2vcuHGSpEAgoJSUFGVkZMTtm5OTo0AgENvnf+N1ZvuZbZ2pqKiQz+eLLcOGDevusAEAfUS3A1ZaWqr9+/fr5Zdf7snxdKq8vFzBYDC21NXV9frXBABc3tzdeVJZWZm2bNmiXbt2aejQobH1fr9fbW1tamxsjLsKa2hokN/vj+3z/vvvxx3vzF2KZ/b5Lo/HI4/H052hAgD6qC5dgRljVFZWpk2bNmnHjh3Kz8+P2z558mQlJydr+/btsXU1NTWqra1VYWGhJKmwsFCffPKJjh07Fttn27Zt8nq9Gjt27MWcCwCgH+nSFVhpaanWr1+vzZs3Kz09Pfaelc/nU2pqqnw+nxYuXKjly5crMzNTXq9XDz74oAoLC3XTTTdJkmbMmKGxY8fq3nvv1erVqxUIBPTEE0+otLSUqywAwAXr0m30juN0uv6FF17QfffdJ+n0LzI/9NBD2rBhg8LhsIqLi/X888/HvTz4xRdfaMmSJaqsrNTAgQO1YMECPfPMM3K7L6yn3EYPAHbridvoL+r3wBKFgAGA3RL+e2AAACQKAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAKxEwAICVCBgAwEoEDABgJQIGALASAQMAWImAAQCsRMAAAFYiYAAAK3UpYBUVFZoyZYrS09OVnZ2tO+64QzU1NXH7TJs2TY7jxC0PPPBA3D61tbWaPXu20tLSlJ2drUceeUSRSOTizwYA0G+4u7Lzzp07VVpaqilTpigSiejxxx/XjBkz9Omnn2rgwIGx/RYtWqSnn3469jgtLS32746ODs2ePVt+v1/vvfee6uvr9ctf/lLJycn6/e9/3wOnBADoD7oUsK1bt8Y9XrdunbKzs1VdXa2pU6fG1qelpcnv93d6jH/+85/69NNP9fbbbysnJ0fXX3+9fvvb3+qxxx7TU089pZSUlG6cBgCgv7mo98CCwaAkKTMzM279Sy+9pKysLI0bN07l5eU6efJkbFtVVZXGjx+vnJyc2Lri4mKFQiEdOHDgYoYDAOhHunQF9r+i0aiWLl2qm2++WePGjYutv+eeezRixAjl5eVp3759euyxx1RTU6PXXntNkhQIBOLiJSn2OBAIdPq1wuGwwuFw7HEoFOrusAEAfUS3A1ZaWqr9+/fr3XffjVu/ePHi2L/Hjx+v3NxcTZ8+XYcPH9aoUaO69bUqKiq0atWq7g4VANAHdeslxLKyMm3ZskXvvPOOhg4des59CwoKJEmHDh2SJPn9fjU0NMTtc+bx2d43Ky8vVzAYjC11dXXdGTYAoA/pUsCMMSorK9OmTZu0Y8cO5efnn/c5e/fulSTl5uZKkgoLC/XJJ5/o2LFjsX22bdsmr9ersWPHdnoMj8cjr9cbtwAA+rcuvYRYWlqq9evXa/PmzUpPT4+9Z+Xz+ZSamqrDhw9r/fr1mjVrlgYPHqx9+/Zp2bJlmjp1qiZMmCBJmjFjhsaOHat7771Xq1evViAQ0BNPPKHS0lJ5PJ6eP0MAQJ/kGGPMBe/sOJ2uf+GFF3Tfffeprq5Ov/jFL7R//361tLRo2LBhuvPOO/XEE0/EXTV98cUXWrJkiSorKzVw4EAtWLBAzzzzjNzuC+tpKBSSz+fTNN0ut5N8ocMHAFwmIqZdldqsYDDY7VfVuhSwy0UwGFRGRoZu0Sy5RcAAwDYRtetdvanGxkb5fL5uHaPbdyEmUlNTkyTpXb2Z4JEAAC5GU1NTtwNm5RVYNBpVTU2Nxo4dq7q6Om7q6EQoFNKwYcOYn3Ngjs6N+Tk/5ujczjU/xhg1NTUpLy9PLlf3PlPDyiswl8ulK664QpK4K/E8mJ/zY47Ojfk5P+bo3M42P9298jqDP6cCALASAQMAWMnagHk8Hq1cuZLfHTsL5uf8mKNzY37Ojzk6t96eHytv4gAAwNorMABA/0bAAABWImAAACsRMACAlawM2Jo1a3TllVdqwIABKigo0Pvvv5/oISXMU089Jcdx4pbRo0fHtre2tqq0tFSDBw/WoEGDNHfu3O/9Pba+ZNeuXbrtttuUl5cnx3H0+uuvx203xmjFihXKzc1VamqqioqKdPDgwbh9Tpw4ofnz58vr9SojI0MLFy5Uc3PzJTyL3nW+Obrvvvu+9z1VUlISt09fnqOKigpNmTJF6enpys7O1h133KGampq4fS7k56q2tlazZ89WWlqasrOz9cgjjygSiVzKU+kVFzI/06ZN+9730AMPPBC3T0/Mj3UBe+WVV7R8+XKtXLlSH330kSZOnKji4uK4vy/W31x33XWqr6+PLf/7V7KXLVumN954Qxs3btTOnTt19OhRzZkzJ4Gj7V0tLS2aOHGi1qxZ0+n21atX69lnn9XatWu1Z88eDRw4UMXFxWptbY3tM3/+fB04cEDbtm3Tli1btGvXrri/NG67882RJJWUlMR9T23YsCFue1+eo507d6q0tFS7d+/Wtm3b1N7erhkzZqilpSW2z/l+rjo6OjR79my1tbXpvffe04svvqh169ZpxYoViTilHnUh8yNJixYtivseWr16dWxbj82PscyNN95oSktLY487OjpMXl6eqaioSOCoEmflypVm4sSJnW5rbGw0ycnJZuPGjbF1n332mZFkqqqqLtEIE0eS2bRpU+xxNBo1fr/f/OEPf4ita2xsNB6Px2zYsMEYY8ynn35qJJkPPvggts9bb71lHMcxX3311SUb+6Xy3TkyxpgFCxaY22+//azP6W9zdOzYMSPJ7Ny50xhzYT9Xb775pnG5XCYQCMT2+dvf/ma8Xq8Jh8OX9gR62XfnxxhjfvSjH5lf//rXZ31OT82PVVdgbW1tqq6uVlFRUWydy+VSUVGRqqqqEjiyxDp48KDy8vI0cuRIzZ8/X7W1tZKk6upqtbe3x83X6NGjNXz48H45X0eOHFEgEIibD5/Pp4KCgth8VFVVKSMjQzfccENsn6KiIrlcLu3Zs+eSjzlRKisrlZ2drWuvvVZLlizR8ePHY9v62xwFg0FJUmZmpqQL+7mqqqrS+PHjlZOTE9unuLhYoVBIBw4cuISj733fnZ8zXnrpJWVlZWncuHEqLy/XyZMnY9t6an6s+jDfb775Rh0dHXEnLUk5OTn6/PPPEzSqxCooKNC6det07bXXqr6+XqtWrdKtt96q/fv3KxAIKCUlRRkZGXHPycnJif017f7kzDl39v1zZlsgEFB2dnbcdrfbrczMzH4zZyUlJZozZ47y8/N1+PBhPf7445o5c6aqqqqUlJTUr+YoGo1q6dKluvnmmzVu3DhJuqCfq0Ag0On32ZltfUVn8yNJ99xzj0aMGKG8vDzt27dPjz32mGpqavTaa69J6rn5sSpg+L6ZM2fG/j1hwgQVFBRoxIgRevXVV5WamprAkcFW8+bNi/17/PjxmjBhgkaNGqXKykpNnz49gSO79EpLS7V///6495Xxf842P//7fuj48eOVm5ur6dOn6/Dhwxo1alSPfX2rXkLMyspSUlLS9+72aWhokN/vT9CoLi8ZGRm65pprdOjQIfn9frW1tamxsTFun/46X2fO+VzfP36//3s3BEUiEZ04caJfzpkkjRw5UllZWTp06JCk/jNHZWVl2rJli9555x0NHTo0tv5Cfq78fn+n32dntvUFZ5ufzhQUFEhS3PdQT8yPVQFLSUnR5MmTtX379ti6aDSq7du3q7CwMIEju3w0Nzfr8OHDys3N1eTJk5WcnBw3XzU1Naqtre2X85Wfny+/3x83H6FQSHv27InNR2FhoRobG1VdXR3bZ8eOHYpGo7Efwv7myy+/1PHjx5Wbmyup78+RMUZlZWXatGmTduzYofz8/LjtF/JzVVhYqE8++SQu9Nu2bZPX69XYsWMvzYn0kvPNT2f27t0rSXHfQz0yP9246SShXn75ZePxeMy6devMp59+ahYvXmwyMjLi7mbpTx566CFTWVlpjhw5Yv7973+boqIik5WVZY4dO2aMMeaBBx4ww4cPNzt27DAffvihKSwsNIWFhQkede9pamoyH3/8sfn444+NJPOnP/3JfPzxx+aLL74wxhjzzDPPmIyMDLN582azb98+c/vtt5v8/Hxz6tSp2DFKSkrMpEmTzJ49e8y7775rrr76anP33Xcn6pR63LnmqKmpyTz88MOmqqrKHDlyxLz99tvmhz/8obn66qtNa2tr7Bh9eY6WLFlifD6fqaysNPX19bHl5MmTsX3O93MViUTMuHHjzIwZM8zevXvN1q1bzZAhQ0x5eXkiTqlHnW9+Dh06ZJ5++mnz4YcfmiNHjpjNmzebkSNHmqlTp8aO0VPzY13AjDHmueeeM8OHDzcpKSnmxhtvNLt37070kBLmrrvuMrm5uSYlJcVcccUV5q677jKHDh2KbT916pT51a9+ZX7wgx+YtLQ0c+edd5r6+voEjrh3vfPOO0bS95YFCxYYY07fSv/kk0+anJwc4/F4zPTp001NTU3cMY4fP27uvvtuM2jQIOP1es39999vmpqaEnA2veNcc3Ty5EkzY8YMM2TIEJOcnGxGjBhhFi1a9L3/IPblOepsbiSZF154IbbPhfxc/ec//zEzZ840qampJisryzz00EOmvb39Ep9Nzzvf/NTW1pqpU6eazMxM4/F4zFVXXWUeeeQREwwG447TE/PDn1MBAFjJqvfAAAA4g4ABAKxEwAAAViJgAAArETAAgJUIGADASgQMAGAlAgYAsBIBAwBYiYABAKxEwAAAViJgAAAr/X8vcGMal1b4nQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "for i in range(0, 17):\n", + " plt.imshow(heatmaps[0][i].cpu().detach().numpy())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "f238c110-8e4f-4865-bc1c-f8aef0127ef3", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'outputs' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[36], line 4\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m17\u001b[39m):\n\u001b[1;32m----> 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(\u001b[43moutputs\u001b[49m[\u001b[38;5;241m0\u001b[39m][i]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 5\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'outputs' is not defined" + ] + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "for i in range(0, 17):\n", + " plt.imshow(outputs[0][i].cpu().detach().numpy())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89ae76ec-92b7-4773-8893-fa1028f1c0a2", + "metadata": {}, + "outputs": [], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(gt_heatmaps[0][5].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d55e9df0-d46a-445a-8032-6ff5bd566ea7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d55944fe-f7bd-463c-bda9-848d3ac29275", + "metadata": {}, + "source": [ + "## convert keypoint" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "83242f5c-71ae-4c95-a8fa-d385904d00d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.]],\n", + "\n", + " [[0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 0.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.],\n", + " [0., 0., 2.]]], device='cuda:0')\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "\n", + "# Original and target sizes\n", + "original_size = (208, 208) # Replace with actual dimensions\n", + "target_size = (52, 52)\n", + "\n", + "# Resizing function\n", + "def resize_keypoints_new(keypoints, original_size, target_size):\n", + " original_height, original_width = original_size\n", + " target_height, target_width = target_size\n", + " \n", + " scale_x = int(target_width / original_width)\n", + " scale_y = int(target_height / original_height)\n", + " \n", + " resized_keypoints = keypoints.clone()\n", + " resized_keypoints[..., 0] *= scale_x\n", + " resized_keypoints[..., 1] *= scale_y\n", + " \n", + " return resized_keypoints\n", + "\n", + "# Resized keypoints\n", + "resized_keypoints = resize_keypoints_new(keypoints, original_size, target_size)\n", + "print(resized_keypoints)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "718c212b-ebb5-4ddb-8b7c-88537ea6f85f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f4ef8c2-e3d2-4e7d-8388-d4b4ddc18587", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "e2e1b2cd-c9ce-4149-a89c-ddd210196fb7", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'gt_heatmaps' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[38], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m#plt.imshow(outputs[0][0].cpu().detach().numpy())\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(\u001b[43mgt_heatmaps\u001b[49m[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[0;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mNameError\u001b[0m: name 'gt_heatmaps' is not defined" + ] + } + ], + "source": [ + "#plt.imshow(outputs[0][0].cpu().detach().numpy())\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(gt_heatmaps[0][2].cpu().detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9f12e02-03b0-47bb-85fb-d9723e50e0e5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "3b414522-0a5e-4a11-83e6-20aa0fc04d2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4, 3, 208, 208])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "5dc276a4-7c8b-4972-90d0-e3c77fb9c199", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'gt_heatmaps' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[40], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mgt_heatmaps\u001b[49m\u001b[38;5;241m.\u001b[39mshape\n", + "\u001b[1;31mNameError\u001b[0m: name 'gt_heatmaps' is not defined" + ] + } + ], + "source": [ + "gt_heatmaps.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1c06c2b-8708-4a24-9abe-33901f646d90", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [1/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:34<00:00, 12.80batch/s, loss=4.61]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [1/10], Loss: 4.6097\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [2/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:34<00:00, 12.81batch/s, loss=3.91]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [2/10], Loss: 3.9105\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [3/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:31<00:00, 13.01batch/s, loss=3.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [3/10], Loss: 3.7892\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [4/10]: 100%|███████████████████████████████████████████████████| 2751/2751 [03:37<00:00, 12.67batch/s, loss=3.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [4/10], Loss: 3.7024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [5/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:30<00:00, 13.09batch/s, loss=3.63]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [5/10], Loss: 3.6335\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [6/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:31<00:00, 13.01batch/s, loss=3.58]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [6/10], Loss: 3.5774\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [7/10]: 100%|██████████████████████████████████████████████████| 2751/2751 [03:25<00:00, 13.37batch/s, loss=3.52]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [7/10], Loss: 3.5167\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch [8/10]: 99%|█████████████████████████████████████████████████▌| 2730/2751 [03:26<00:01, 12.95batch/s, loss=3.48]" + ] + } + ], + "source": [ + "import torch\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader\n", + "from tqdm import tqdm # Import tqdm\n", + "\n", + "optimizer = optim.Adam(model.parameters(), lr=1e-4)\n", + "criterion = torch.nn.MSELoss()\n", + "\n", + "# Define training loop\n", + "num_epochs = 10 # Number of epochs\n", + "for epoch in range(num_epochs):\n", + " model.train() # Set model to training mode\n", + " running_loss = 0.0\n", + "\n", + " # Wrap the DataLoader with tqdm to show the progress\n", + " with tqdm(dataloader, desc=f\"Epoch [{epoch + 1}/{num_epochs}]\", unit='batch') as pbar:\n", + " for images, labels in pbar:\n", + " # Send images and labels to GPU if needed\n", + " images = images.cuda()\n", + " labels = labels.cuda()\n", + "\n", + " optimizer.zero_grad() # Zero the gradients\n", + "\n", + " # Forward pass\n", + " outputs = model(images) # The model outputs keypoint heatmaps\n", + " #print(outputs.shape)\n", + "\n", + " original_size = (208, 208)\n", + " target_size = (52, 52)\n", + " labels = resize_keypoints_new(labels, original_size, target_size)\n", + " gt_heatmaps = generate_heatmaps(labels, output_size=outputs.shape[2:]) # Implement this\n", + " loss = criterion(outputs*100, gt_heatmaps*100)\n", + "\n", + " # Backward pass and optimization\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + "\n", + " # Update the tqdm progress bar with the current loss\n", + " pbar.set_postfix(loss=running_loss / (pbar.n + 1)) # Display the average loss\n", + "\n", + " # Print loss for the current epoch\n", + " avg_loss = running_loss / len(dataloader)\n", + " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cac52986-3416-4280-8092-9b197ac006ad", + "metadata": {}, + "outputs": [], + "source": [ + "input_tensor.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5dbc351-bb56-450f-85c7-225902b2a9b8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12157857-e9bf-4645-a137-3e5ddf0d3141", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a27d991-83b5-485f-8e50-9273601dedab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fdd034a0-c159-4b2f-8f49-abdbd49844bd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88eab6b5-72f5-4407-a2d1-c9f74dfb2f8b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}