From 3716067f84b6f6f0108fc9ec55fba34fd369fb47 Mon Sep 17 00:00:00 2001 From: RobbeDeWaele <71169585+RobbeDeWaele@users.noreply.github.com> Date: Sat, 8 Apr 2023 12:52:20 +0200 Subject: [PATCH] Basics sign predictor --- src/datasets/basics_dataset.py | 95 ++ src/train_basics.py | 152 +++ visualizations/analyze_model.ipynb | 126 ++- visualizations/visualize_data.ipynb | 1420 +-------------------------- visualizations/webcam_view.py | 4 +- 5 files changed, 389 insertions(+), 1408 deletions(-) create mode 100644 src/datasets/basics_dataset.py create mode 100644 src/train_basics.py diff --git a/src/datasets/basics_dataset.py b/src/datasets/basics_dataset.py new file mode 100644 index 0000000..5d048b5 --- /dev/null +++ b/src/datasets/basics_dataset.py @@ -0,0 +1,95 @@ +import os + +import numpy as np +import torch +from sklearn.model_selection import train_test_split + +from src.identifiers import LANDMARKS +from src.keypoint_extractor import KeypointExtractor + + +class BasicsDataset(torch.utils.data.Dataset): + def __init__(self, data_folder: str, bad_data_folder: str = "", subset:str="train", keypoints_identifier: dict = None, transform=None): + + + # list files with path in the datafolder ending with .mp4 + files = [data_folder + f for f in os.listdir(data_folder) if f.endswith(".mp4")] + + # append files from bad data folder + if bad_data_folder != "": + files += [bad_data_folder + f for f in os.listdir(bad_data_folder) if f.endswith(".mp4")] + + labels = [f.split("/")[-1].split("!")[0] for f in files] + train_test = [f.split("/")[-1].split("!")[1] for f in files] + + # count the number of each label + self.label_mapping, counts = np.unique(labels, return_counts=True) + + + + # map the labels to their integer + labels = [np.where(self.label_mapping == label)[0][0] for label in labels] + + + # TODO: make split for train and val and test when enough data is available + if subset == "train": + # mask for train data + mask = np.array(train_test) == "train" + elif subset == "test": + mask = np.array(train_test) == "test" + + # filter data and labels + self.data = np.array(files)[mask] + self.labels = np.array(labels)[mask] + + # filter data by subset + self.transform = transform + self.subset = subset + self.keypoint_extractor = KeypointExtractor() + if keypoints_identifier: + self.keypoints_to_keep = [f"{i}_{j}" for i in keypoints_identifier.values() for j in ["x", "y"]] + + def __len__(self): + return len(self.data) + + def __getitem__(self, index): + # get i th element from ordered dict + video_name = self.data[index] + + cache_name = video_name.split("/")[-1].split(".")[0] + ".npy" + + # check if cache_name file exists + if not os.path.isfile(os.path.join("cache_processed", cache_name)): + + + # get the keypoints for the video (normalizations: minxmax, bohacek) + keypoints_df = self.keypoint_extractor.extract_keypoints_from_video(video_name, normalize="bohacek") + + # filter the keypoints by the identified subset + if self.keypoints_to_keep: + keypoints_df = keypoints_df[self.keypoints_to_keep] + + current_row = np.empty(shape=(keypoints_df.shape[0], keypoints_df.shape[1] // 2, 2)) + for i in range(0, keypoints_df.shape[1], 2): + current_row[:, i // 2, 0] = keypoints_df.iloc[:, i] + current_row[:, i // 2, 1] = keypoints_df.iloc[:, i + 1] + + # check if cache_processed folder exists + if not os.path.isdir("cache_processed"): + os.mkdir("cache_processed") + + # save the processed data to a file + np.save(os.path.join("cache_processed", cache_name), current_row) + + else: + current_row = np.load(os.path.join("cache_processed", cache_name)) + + # get the label + label = self.labels[index] + # data to tensor + data = torch.from_numpy(current_row) + + if self.transform: + data = self.transform(data) + + return data, label diff --git a/src/train_basics.py b/src/train_basics.py new file mode 100644 index 0000000..6dae4d7 --- /dev/null +++ b/src/train_basics.py @@ -0,0 +1,152 @@ +import os +import random + +import numpy as np +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import DataLoader +from torchvision import transforms + +from src.augmentations import MirrorKeypoints, Z_augmentation, NoiseAugmentation +from src.datasets.basics_dataset import BasicsDataset +from src.identifiers import LANDMARKS +from src.model import SPOTER +from src.loss_function import CustomLoss + +import torch +from torch.utils.tensorboard import SummaryWriter + +def train(): + writer = SummaryWriter() + random.seed(379) + np.random.seed(379) + os.environ['PYTHONHASHSEED'] = str(379) + torch.manual_seed(379) + torch.cuda.manual_seed(379) + torch.cuda.manual_seed_all(379) + torch.backends.cudnn.deterministic = True + g = torch.Generator() + g.manual_seed(379) + + if torch.cuda.is_available(): + device = torch.device("cuda:0") + else: + device = torch.device("cpu") + + spoter_model = SPOTER(num_classes=15, hidden_dim=len(LANDMARKS) *2) + spoter_model.train(True) + spoter_model.to(device) + + + criterion = nn.CrossEntropyLoss() + criterion_bad = CustomLoss() + optimizer = optim.Adam(spoter_model.parameters(), lr=0.00001) + scheduler = None + + # check if checkpoints folder exists + if not os.path.exists("checkpoints"): + os.makedirs("checkpoints") + + transform = transforms.Compose([NoiseAugmentation(noise=0.1)]) + + train_set = BasicsDataset("data/basics/data/", bad_data_folder="", keypoints_identifier=LANDMARKS, subset="train", transform=transform) + train_loader = DataLoader(train_set, shuffle=True, generator=g) + + val_set = BasicsDataset("data/basics/data/", bad_data_folder="", keypoints_identifier=LANDMARKS, subset="test") + val_loader = DataLoader(val_set, shuffle=True, generator=g) + + + train_acc, val_acc = 0, 0 + lr_progress = [] + top_train_acc, top_val_acc = 0, 0 + checkpoint_index = 0 + + epochs_without_improvement = 0 + best_val_acc = 0 + + for epoch in range(300): + + running_loss = 0.0 + pred_correct, pred_all = 0, 0 + + # train + for i, (inputs, labels) in enumerate(train_loader): + # skip videos that are too short + if inputs.shape[1] < 20: + continue + + inputs = inputs.squeeze(0).to(device) + labels = labels.to(device, dtype=torch.long) + + optimizer.zero_grad() + outputs = spoter_model(inputs).expand(1, -1, -1) + loss = criterion(outputs[0], labels) + + loss.backward() + optimizer.step() + running_loss += loss + + if int(torch.argmax(torch.nn.functional.softmax(outputs, dim=2))) == int(labels[0]): + pred_correct += 1 + pred_all += 1 + + + if scheduler: + scheduler.step(running_loss.item() / (len(train_loader)) ) + + writer.add_scalar("Loss/train", loss, epoch) + writer.add_scalar("Accuracy/train", (pred_correct / pred_all), epoch) + + # validate and print val acc + val_pred_correct, val_pred_all = 0, 0 + val_loss = 0.0 + with torch.no_grad(): + for i, (inputs, labels) in enumerate(val_loader): + inputs = inputs.squeeze(0).to(device) + labels = labels.to(device, dtype=torch.long) + + outputs = spoter_model(inputs).expand(1, -1, -1) + + # calculate loss + val_loss += criterion(outputs[0], labels) + + if int(torch.argmax(torch.nn.functional.softmax(outputs, dim=2))) == int(labels[0]): + val_pred_correct += 1 + val_pred_all += 1 + + val_acc = (val_pred_correct / val_pred_all) + + writer.add_scalar("Loss/val", val_loss, epoch) + writer.add_scalar("Accuracy/val", val_acc, epoch) + + + print(f"Epoch: {epoch} | Train Acc: {(pred_correct / pred_all)} | Val Acc: {val_acc}") + + # save checkpoint and update epochs_without_improvement + if val_acc > best_val_acc: + best_val_acc = val_acc + epochs_without_improvement = 0 + if epoch > 20: + top_val_acc = val_acc + top_train_acc = train_acc + checkpoint_index = epoch + torch.save(spoter_model.state_dict(), f"checkpoints/spoter_{epoch}.pth") + else: + epochs_without_improvement += 1 + + # early stopping + if epochs_without_improvement >= 40: + print("Early stopping due to no improvement in validation accuracy for 40 epochs.") + break + + lr_progress.append(optimizer.param_groups[0]['lr']) + + print(f"Best val acc: {top_val_acc} | Best train acc: {top_train_acc} | Epoch: {checkpoint_index}") + writer.flush() + writer.close() + + +# Path: src/train.py +if __name__ == "__main__": + train() diff --git a/visualizations/analyze_model.ipynb b/visualizations/analyze_model.ipynb index a805896..2642d3e 100644 --- a/visualizations/analyze_model.ipynb +++ b/visualizations/analyze_model.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fingerspelling" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -107,11 +114,115 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "# Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import sys\n", + "sys.path.insert(0,'..')\n", + "\n", + "from src.keypoint_extractor import KeypointExtractor\n", + "from src.datasets.basics_dataset import BasicsDataset\n", + "from src.identifiers import LANDMARKS\n", + "import torch\n", + "from src.model import SPOTER\n", + "from sklearn.metrics import confusion_matrix\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sn\n", + "import matplotlib.pyplot as plt\n", + "from src.augmentations import MirrorKeypoints\n", + "\n", + "keypoints_extractor = KeypointExtractor()\n", + "test_set = BasicsDataset(\"../data/basics/data/\", bad_data_folder=\"\", keypoints_identifier=LANDMARKS, subset=\"test\")\n", + "\n", + "spoter = SPOTER(num_classes=15, hidden_dim=len(LANDMARKS) *2)\n", + "spoter.load_state_dict(torch.load('../checkpoints/spoter_22.pth'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 0 2 2 0 1 0 2 0 1 0 3 1]\n", + "['BEDANKEN' 'GOED' 'GOEDEMIDDAG' 'GOEDEMORGEN' 'GOEDENACHT' 'GOEDENAVOND'\n", + " 'JA' 'LINKS' 'NEE' 'RECHTS' 'SALUUT' 'SLECHT' 'SMAKELIJK' 'SORRY'\n", + " 'TOT-ZIENS']\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_pred = []\n", + "y_true = []\n", + "\n", + "for inputs, label in test_set:\n", + " output = spoter(inputs) # Feed Network\n", + "\n", + " output = torch.argmax(output, dim=2) # Get Prediction\n", + " output = output.detach().numpy().tolist()[0] # Convert to list\n", + " \n", + " y_true.extend(output) # Save Truth\n", + "\n", + " y_pred.append(label) # Save Prediction\n", + "\n", + "\n", + "# how many items for each class\n", + "print(np.bincount(y_true))\n", + "\n", + "# label mapping\n", + "print(test_set.label_mapping)\n", + "\n", + "# Build confusion matrix\n", + "cf_matrix = confusion_matrix(y_true, y_pred)\n", + "df_cm = pd.DataFrame(cf_matrix, index = [i for i in [test_set.label_mapping[i] for i in range(15)]],\n", + " columns = [i for i in [test_set.label_mapping[i] for i in range(15)]])\n", + "plt.figure(figsize = (12,7))\n", + "sn.heatmap(df_cm, annot=True)" + ] }, { "cell_type": "code", @@ -123,7 +234,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -137,9 +248,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" - }, - "orig_nbformat": 4 + "version": "3.9.13" + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/visualizations/visualize_data.ipynb b/visualizations/visualize_data.ipynb index 52c3ee1..270558d 100644 --- a/visualizations/visualize_data.ipynb +++ b/visualizations/visualize_data.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -16,16 +16,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "video_name = '../data/fingerspelling/data/Z!train!26_20230323144550450800_2RIPN.mp4'\n" + "video_name = '../data/basics/data/GOEDENACHT!test!158_20230323093702582261_6FB7Q.mp4'\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -35,22 +35,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "from IPython.display import HTML\n", @@ -78,22 +65,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'models/spoter_40.pth'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\n\u001b[1;32m 5\u001b[0m spoter_model \u001b[39m=\u001b[39m SPOTER(num_classes\u001b[39m=\u001b[39m\u001b[39m5\u001b[39m, hidden_dim\u001b[39m=\u001b[39m\u001b[39mlen\u001b[39m(LANDMARKS) \u001b[39m*\u001b[39m\u001b[39m2\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m spoter_model\u001b[39m.\u001b[39mload_state_dict(torch\u001b[39m.\u001b[39;49mload(\u001b[39m'\u001b[39;49m\u001b[39mmodels/spoter_40.pth\u001b[39;49m\u001b[39m'\u001b[39;49m))\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/serialization.py:771\u001b[0m, in \u001b[0;36mload\u001b[0;34m(f, map_location, pickle_module, weights_only, **pickle_load_args)\u001b[0m\n\u001b[1;32m 768\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mencoding\u001b[39m\u001b[39m'\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m pickle_load_args\u001b[39m.\u001b[39mkeys():\n\u001b[1;32m 769\u001b[0m pickle_load_args[\u001b[39m'\u001b[39m\u001b[39mencoding\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mutf-8\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m--> 771\u001b[0m \u001b[39mwith\u001b[39;00m _open_file_like(f, \u001b[39m'\u001b[39;49m\u001b[39mrb\u001b[39;49m\u001b[39m'\u001b[39;49m) \u001b[39mas\u001b[39;00m opened_file:\n\u001b[1;32m 772\u001b[0m \u001b[39mif\u001b[39;00m _is_zipfile(opened_file):\n\u001b[1;32m 773\u001b[0m \u001b[39m# The zipfile reader is going to advance the current file position.\u001b[39;00m\n\u001b[1;32m 774\u001b[0m \u001b[39m# If we want to actually tail call to torch.jit.load, we need to\u001b[39;00m\n\u001b[1;32m 775\u001b[0m \u001b[39m# reset back to the original position.\u001b[39;00m\n\u001b[1;32m 776\u001b[0m orig_position \u001b[39m=\u001b[39m opened_file\u001b[39m.\u001b[39mtell()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/serialization.py:270\u001b[0m, in \u001b[0;36m_open_file_like\u001b[0;34m(name_or_buffer, mode)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_open_file_like\u001b[39m(name_or_buffer, mode):\n\u001b[1;32m 269\u001b[0m \u001b[39mif\u001b[39;00m _is_path(name_or_buffer):\n\u001b[0;32m--> 270\u001b[0m \u001b[39mreturn\u001b[39;00m _open_file(name_or_buffer, mode)\n\u001b[1;32m 271\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 272\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mw\u001b[39m\u001b[39m'\u001b[39m \u001b[39min\u001b[39;00m mode:\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/serialization.py:251\u001b[0m, in \u001b[0;36m_open_file.__init__\u001b[0;34m(self, name, mode)\u001b[0m\n\u001b[1;32m 250\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__init__\u001b[39m(\u001b[39mself\u001b[39m, name, mode):\n\u001b[0;32m--> 251\u001b[0m \u001b[39msuper\u001b[39m(_open_file, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(\u001b[39mopen\u001b[39;49m(name, mode))\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'models/spoter_40.pth'" - ] - } - ], + "outputs": [], "source": [ "from src.model import SPOTER\n", "from src.identifiers import LANDMARKS\n", @@ -181,135 +153,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 54_x54_y55_x55_y56_x56_y57_x57_y58_x58_y59_x59_y60_x60_y61_x61_y62_x62_y63_x63_y64_x64_y65_x65_y66_x66_y67_x67_y68_x68_y69_x69_y70_x70_y71_x71_y72_x72_y73_x73_y74_x74_y
5206.460323241.187210230.258865224.058051240.719643194.888663243.763103176.291513245.644760160.364571222.654018164.100680244.763489159.433722241.298084180.507073232.752953187.535305211.368618164.291081237.624207160.842934232.236347185.703449221.870766190.408745200.001240168.123393226.508846165.884171221.417446190.005541210.547810194.531407188.253899175.198359212.090034172.334862210.177135188.840246200.824184193.307934
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from src.keypoint_extractor import KeypointExtractor\n", "import numpy as np\n", @@ -327,128 +171,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 54_x54_y55_x55_y56_x56_y57_x57_y58_x58_y59_x59_y60_x60_y61_x61_y62_x62_y63_x63_y64_x64_y65_x65_y66_x66_y67_x67_y68_x68_y69_x69_y70_x70_y71_x71_y72_x72_y73_x73_y74_x74_y
5-0.1827640.5000000.2319100.2904780.414183-0.0663190.467213-0.2937970.500000-0.4886140.099401-0.4429140.484644-0.5000000.424262-0.2422330.275368-0.156264-0.097240-0.4405850.360247-0.4827630.266367-0.1786710.085753-0.121117-0.295310-0.3937090.166569-0.4210990.077854-0.126049-0.111542-0.070689-0.500000-0.307169-0.084670-0.342195-0.118001-0.140303-0.280971-0.085654
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Plot the NORMALIZED hand keypoints (using minxmax)\n", "df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"minmax\")\n", @@ -461,128 +184,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 54_x54_y55_x55_y56_x56_y57_x57_y58_x58_y59_x59_y60_x60_y61_x61_y62_x62_y63_x63_y64_x64_y65_x65_y66_x66_y67_x67_y68_x68_y69_x69_y70_x70_y71_x71_y72_x72_y73_x73_y74_x74_y
5-0.1069170.4166670.1356670.2420650.242297-0.0552660.273319-0.2448310.292500-0.4071780.058149-0.3690950.283517-0.4166670.248193-0.2018610.161090-0.130220-0.056886-0.3671540.210744-0.4023020.155824-0.1488930.050165-0.100931-0.172756-0.3280910.097442-0.3509160.045545-0.105041-0.065252-0.058907-0.292500-0.255974-0.049532-0.285162-0.069031-0.116919-0.164368-0.071379
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#Plot the NORMALIZED hand keypoints (using bohacek)\n", "df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", @@ -600,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -642,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -654,121 +256,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 0_x0_y1_x1_y2_x2_y3_x3_y4_x4_y5_x5_y6_x6_y7_x7_y8_x8_y9_x9_y10_x10_y11_x11_y12_x12_y13_x13_y14_x14_y15_x15_y16_x16_y
2314.597130203.601093333.606339177.124128343.284836178.611474353.475113180.199170299.696846173.968377287.641029173.626041276.889381173.728795369.040298195.947542261.266518190.308652332.395744235.577416290.494938233.121829437.649574348.909016172.417698350.768766524.350166508.146744121.787348523.435078461.661911373.101339122.718906719.282742
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAaQklEQVR4nO3df2xV9f348VdLpXWRthB+dGAZwzmRibCAVMiIyWwEZQYSlyEyQcJkfwxcRBNhMeD0j+KCG07Jx8hc3BIN6BKMYY6N8SNG7UBBE1AhGZOIYIuM2Fth4Ud7vn/4tVsVaovctu/yeCTnjx7OufdV3sB95vTcS0GWZVkAACSisKsHAADoCPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUoq6eoDzrbm5OQ4dOhR9+vSJgoKCrh4HAGiHLMuisbExBg8eHIWFbV9b6XHxcujQoaisrOzqMQCAc3DgwIG49NJL2zymx8VLnz59IuLTb760tLSLpwEA2iOXy0VlZWXL63hbely8fPajotLSUvECAIlpzy0fbtgFAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCS0inxsmrVqhg2bFiUlJREVVVVbN++vV3nrVmzJgoKCmL69On5HRAASEbe42Xt2rWxaNGiWLZsWezcuTNGjx4dkydPjsOHD7d53v79++Pee++NSZMm5XtEACAheY+XX//613HnnXfG3LlzY+TIkfHEE0/E1772tfj9739/1nOamppi1qxZ8ctf/jKGDx+e7xEBgITkNV5OnjwZO3bsiOrq6v8+YWFhVFdXR21t7VnPe/DBB2PgwIExb968fI4HACSoKJ8PfuTIkWhqaopBgwa12j9o0KDYs2fPGc955ZVX4qmnnoq33nqrXc9x4sSJOHHiRMvXuVzunOcFALq/bvVuo8bGxrj99ttj9erV0b9//3adU1NTE2VlZS1bZWVlnqcEALpSXq+89O/fP3r16hX19fWt9tfX10dFRcUXjt+3b1/s378/br755pZ9zc3Nnw5aVBR79+6Nyy67rNU5S5YsiUWLFrV8ncvlBAwA9GB5jZfevXvH2LFjY9OmTS1vd25ubo5NmzbFggULvnD8iBEjYteuXa323X///dHY2BiPPvroGaOkuLg4iouL8zI/AND95DVeIiIWLVoUc+bMiXHjxsX48eNj5cqVcezYsZg7d25ERMyePTuGDBkSNTU1UVJSEldddVWr88vLyyMivrAfALgw5T1eZsyYER999FEsXbo06urqYsyYMbFhw4aWm3jff//9KCzsVrfeAADdWEGWZVlXD3E+5XK5KCsri4aGhigtLe3qcQCAdujI67dLHgBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJKVT4mXVqlUxbNiwKCkpiaqqqti+fftZj129enVMmjQp+vbtG3379o3q6uo2jwcALix5j5e1a9fGokWLYtmyZbFz584YPXp0TJ48OQ4fPnzG47du3RozZ86MLVu2RG1tbVRWVsYNN9wQBw8ezPeoAEACCrIsy/L5BFVVVXHNNdfE448/HhERzc3NUVlZGQsXLozFixd/6flNTU3Rt2/fePzxx2P27Nlfenwul4uysrJoaGiI0tLSrzw/AJB/HXn9zuuVl5MnT8aOHTuiurr6v09YWBjV1dVRW1vbrsc4fvx4nDp1Kvr165evMQGAhBTl88GPHDkSTU1NMWjQoFb7Bw0aFHv27GnXY9x3330xePDgVgH0v06cOBEnTpxo+TqXy537wABAt9et3220fPnyWLNmTaxbty5KSkrOeExNTU2UlZW1bJWVlZ08JQDQmfIaL/37949evXpFfX19q/319fVRUVHR5rkrVqyI5cuXx9/+9re4+uqrz3rckiVLoqGhoWU7cODAeZkdAOie8hovvXv3jrFjx8amTZta9jU3N8emTZtiwoQJZz3vV7/6VTz00EOxYcOGGDduXJvPUVxcHKWlpa02AKDnyus9LxERixYtijlz5sS4ceNi/PjxsXLlyjh27FjMnTs3IiJmz54dQ4YMiZqamoiIePjhh2Pp0qXx7LPPxrBhw6Kuri4iIi655JK45JJL8j0uANDN5T1eZsyYER999FEsXbo06urqYsyYMbFhw4aWm3jff//9KCz87wWg//u//4uTJ0/GD3/4w1aPs2zZsnjggQfyPS4A0M3l/XNeOpvPeQGA9HSbz3kBADjfxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkpVPiZdWqVTFs2LAoKSmJqqqq2L59e5vHP//88zFixIgoKSmJUaNGxUsvvdQZYwIACch7vKxduzYWLVoUy5Yti507d8bo0aNj8uTJcfjw4TMe/9prr8XMmTNj3rx58eabb8b06dNj+vTpsXv37nyPCgAkoCDLsiyfT1BVVRXXXHNNPP744xER0dzcHJWVlbFw4cJYvHjxF46fMWNGHDt2LNavX9+y79prr40xY8bEE0888aXPl8vloqysLBoaGqK0tPT8fSMAQN505PU7r1deTp48GTt27Ijq6ur/PmFhYVRXV0dtbe0Zz6mtrW11fETE5MmTz3r8iRMnIpfLtdoAgJ4rr/Fy5MiRaGpqikGDBrXaP2jQoKirqzvjOXV1dR06vqamJsrKylq2ysrK8zM8ANAtJf9uoyVLlkRDQ0PLduDAga4eCQDIo6J8Pnj//v2jV69eUV9f32p/fX19VFRUnPGcioqKDh1fXFwcxcXF52dgAKDby+uVl969e8fYsWNj06ZNLfuam5tj06ZNMWHChDOeM2HChFbHR0Rs3LjxrMcDABeWvF55iYhYtGhRzJkzJ8aNGxfjx4+PlStXxrFjx2Lu3LkRETF79uwYMmRI1NTURETEz3/+87juuuvikUceialTp8aaNWvijTfeiCeffDLfowIACch7vMyYMSM++uijWLp0adTV1cWYMWNiw4YNLTflvv/++1FY+N8LQBMnToxnn3027r///vjFL34Rl19+ebzwwgtx1VVX5XtUACABef+cl87mc14AID3d5nNeAADON/ECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASclbvBw9ejRmzZoVpaWlUV5eHvPmzYtPPvmkzeMXLlwYV1xxRVx88cUxdOjQuOuuu6KhoSFfIwIACcpbvMyaNSvefvvt2LhxY6xfvz5efvnlmD9//lmPP3ToUBw6dChWrFgRu3fvjqeffjo2bNgQ8+bNy9eIAECCCrIsy873g7777rsxcuTIeP3112PcuHEREbFhw4a46aab4oMPPojBgwe363Gef/75+PGPfxzHjh2LoqKidp2Ty+WirKwsGhoaorS09Jy/BwCg83Tk9TsvV15qa2ujvLy8JVwiIqqrq6OwsDC2bdvW7sf57BtoK1xOnDgRuVyu1QYA9Fx5iZe6uroYOHBgq31FRUXRr1+/qKura9djHDlyJB566KE2f9QUEVFTUxNlZWUtW2Vl5TnPDQB0fx2Kl8WLF0dBQUGb2549e77yULlcLqZOnRojR46MBx54oM1jlyxZEg0NDS3bgQMHvvLzAwDdV/tuJPn/7rnnnrjjjjvaPGb48OFRUVERhw8fbrX/9OnTcfTo0aioqGjz/MbGxpgyZUr06dMn1q1bFxdddFGbxxcXF0dxcXG75gcA0teheBkwYEAMGDDgS4+bMGFCfPzxx7Fjx44YO3ZsRERs3rw5mpubo6qq6qzn5XK5mDx5chQXF8eLL74YJSUlHRkPALgA5OWelyuvvDKmTJkSd955Z2zfvj1effXVWLBgQdx6660t7zQ6ePBgjBgxIrZv3x4Rn4bLDTfcEMeOHYunnnoqcrlc1NXVRV1dXTQ1NeVjTAAgQR268tIRzzzzTCxYsCCuv/76KCwsjFtuuSV++9vftvz6qVOnYu/evXH8+PGIiNi5c2fLO5G+9a1vtXqs9957L4YNG5avUQGAhOTlc166ks95AYD0dPnnvAAA5It4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKSIFwAgKeIFAEiKeAEAkiJeAICkiBcAICniBQBIingBAJIiXgCApIgXACAp4gUASIp4AQCSIl4AgKTkLV6OHj0as2bNitLS0igvL4958+bFJ5980q5zsyyLG2+8MQoKCuKFF17I14gAQILyFi+zZs2Kt99+OzZu3Bjr16+Pl19+OebPn9+uc1euXBkFBQX5Gg0ASFhRPh703XffjQ0bNsTrr78e48aNi4iIxx57LG666aZYsWJFDB48+KznvvXWW/HII4/EG2+8EV//+tfzMR4AkLC8XHmpra2N8vLylnCJiKiuro7CwsLYtm3bWc87fvx43HbbbbFq1aqoqKho13OdOHEicrlcqw0A6LnyEi91dXUxcODAVvuKioqiX79+UVdXd9bz7r777pg4cWJMmzat3c9VU1MTZWVlLVtlZeU5zw0AdH8dipfFixdHQUFBm9uePXvOaZAXX3wxNm/eHCtXruzQeUuWLImGhoaW7cCBA+f0/ABAGjp0z8s999wTd9xxR5vHDB8+PCoqKuLw4cOt9p8+fTqOHj161h8Hbd68Ofbt2xfl5eWt9t9yyy0xadKk2Lp16xnPKy4ujuLi4vZ+CwBA4joULwMGDIgBAwZ86XETJkyIjz/+OHbs2BFjx46NiE/jpLm5Oaqqqs54zuLFi+MnP/lJq32jRo2K3/zmN3HzzTd3ZEwAoAfLy7uNrrzyypgyZUrceeed8cQTT8SpU6diwYIFceutt7a80+jgwYNx/fXXxx//+McYP358VFRUnPGqzNChQ+Ob3/xmPsYEABKUt895eeaZZ2LEiBFx/fXXx0033RTf+9734sknn2z59VOnTsXevXvj+PHj+RoBAOiBCrIsy7p6iPMpl8tFWVlZNDQ0RGlpaVePAwC0Q0dev/3fRgBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAkRbwAAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFKKunqA8y3LsoiIyOVyXTwJANBen71uf/Y63pYeFy+NjY0REVFZWdnFkwAAHdXY2BhlZWVtHlOQtSdxEtLc3ByHDh2KPn36REFBQVePc85yuVxUVlbGgQMHorS0tKvHuaBZi+7DWnQf1qJ76QnrkWVZNDY2xuDBg6OwsO27WnrclZfCwsK49NJLu3qM86a0tDTZP4g9jbXoPqxF92EtupfU1+PLrrh8xg27AEBSxAsAkBTx0k0VFxfHsmXLori4uKtHueBZi+7DWnQf1qJ7udDWo8fdsAsA9GyuvAAASREvAEBSxAsAkBTxAgAkRbx0I0ePHo1Zs2ZFaWlplJeXx7x58+KTTz5p17lZlsWNN94YBQUF8cILL+R30AtAR9fi6NGjsXDhwrjiiivi4osvjqFDh8Zdd90VDQ0NnTh1z7Bq1aoYNmxYlJSURFVVVWzfvr3N459//vkYMWJElJSUxKhRo+Kll17qpEl7vo6sxerVq2PSpEnRt2/f6Nu3b1RXV3/p2tExHf278Zk1a9ZEQUFBTJ8+Pb8DdiLx0o3MmjUr3n777di4cWOsX78+Xn755Zg/f367zl25cmXS/x1Cd9PRtTh06FAcOnQoVqxYEbt3746nn346NmzYEPPmzevEqdO3du3aWLRoUSxbtix27twZo0ePjsmTJ8fhw4fPePxrr70WM2fOjHnz5sWbb74Z06dPj+nTp8fu3bs7efKep6NrsXXr1pg5c2Zs2bIlamtro7KyMm644YY4ePBgJ0/eM3V0PT6zf//+uPfee2PSpEmdNGknyegW3nnnnSwistdff71l31/+8pesoKAgO3jwYJvnvvnmm9mQIUOyDz/8MIuIbN26dXmetmf7Kmvxv5577rmsd+/e2alTp/IxZo80fvz47Gc/+1nL101NTdngwYOzmpqaMx7/ox/9KJs6dWqrfVVVVdlPf/rTvM55IejoWnze6dOnsz59+mR/+MMf8jXiBeVc1uP06dPZxIkTs9/97nfZnDlzsmnTpnXCpJ3DlZduora2NsrLy2PcuHEt+6qrq6OwsDC2bdt21vOOHz8et912W6xatSoqKio6Y9Qe71zX4vMaGhqitLQ0iop63H8hlhcnT56MHTt2RHV1dcu+wsLCqK6ujtra2jOeU1tb2+r4iIjJkyef9Xja51zW4vOOHz8ep06din79+uVrzAvGua7Hgw8+GAMHDuyRV4D9q9pN1NXVxcCBA1vtKyoqin79+kVdXd1Zz7v77rtj4sSJMW3atHyPeME417X4X0eOHImHHnqo3T/249Pfs6amphg0aFCr/YMGDYo9e/ac8Zy6urozHt/edeLMzmUtPu++++6LwYMHfyEu6bhzWY9XXnklnnrqqXjrrbc6YcLO58pLni1evDgKCgra3Nr7j8Hnvfjii7F58+ZYuXLl+R26h8rnWvyvXC4XU6dOjZEjR8YDDzzw1QeHxCxfvjzWrFkT69ati5KSkq4e54LT2NgYt99+e6xevTr69+/f1ePkhSsveXbPPffEHXfc0eYxw4cPj4qKii/ceHX69Ok4evToWX8ctHnz5ti3b1+Ul5e32n/LLbfEpEmTYuvWrV9h8p4nn2vxmcbGxpgyZUr06dMn1q1bFxdddNFXHfuC0b9//+jVq1fU19e32l9fX3/W3/eKiooOHU/7nMtafGbFihWxfPny+Pvf/x5XX311Pse8YHR0Pfbt2xf79++Pm2++uWVfc3NzRHx6FXnv3r1x2WWX5XfofOvqm2741Gc3ib7xxhst+/7617+2eZPohx9+mO3atavVFhHZo48+mv3rX//qrNF7nHNZiyzLsoaGhuzaa6/NrrvuuuzYsWOdMWqPM378+GzBggUtXzc1NWVDhgxp84bdH/zgB632TZgwwQ2750FH1yLLsuzhhx/OSktLs9ra2s4Y8YLSkfX4z3/+84XXhmnTpmXf//73s127dmUnTpzozNHzQrx0I1OmTMm++93vZtu2bcteeeWV7PLLL89mzpzZ8usffPBBdsUVV2Tbtm0762OEdxudFx1di4aGhqyqqiobNWpU9s9//jP78MMPW7bTp0931beRnDVr1mTFxcXZ008/nb3zzjvZ/Pnzs/Ly8qyuri7Lsiy7/fbbs8WLF7cc/+qrr2ZFRUXZihUrsnfffTdbtmxZdtFFF2W7du3qqm+hx+joWixfvjzr3bt39qc//anVn//Gxsau+hZ6lI6ux+f1tHcbiZdu5N///nc2c+bM7JJLLslKS0uzuXPntvqL/95772URkW3ZsuWsjyFezo+OrsWWLVuyiDjj9t5773XNN5Goxx57LBs6dGjWu3fvbPz48dk//vGPll+77rrrsjlz5rQ6/rnnnsu+/e1vZ717986+853vZH/+8587eeKeqyNr8Y1vfOOMf/6XLVvW+YP3UB39u/G/elq8FGRZlnX2j6oAAM6VdxsBAEkRLwBAUsQLAJAU8QIAJEW8AABJES8AQFLECwCQFPECACRFvAAASREvAEBSxAsAkBTxAgAk5f8BQ3drKzZE23cAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from src.keypoint_extractor import KeypointExtractor\n", "import numpy as np\n", @@ -784,114 +274,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 0_x0_y1_x1_y2_x2_y3_x3_y4_x4_y5_x5_y6_x6_y7_x7_y8_x8_y9_x9_y10_x10_y11_x11_y12_x12_y13_x13_y14_x14_y15_x15_y16_x16_y
20.009014-0.3302240.026931-0.3587450.036054-0.3571430.045658-0.355433-0.005030-0.362144-0.016393-0.362513-0.026527-0.3624020.060329-0.338468-0.041253-0.3445430.025790-0.295779-0.013703-0.2984240.124997-0.173699-0.124997-0.1716950.206716-0.002168-0.1727180.0143000.147630-0.147639-0.1718400.225267
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh0ElEQVR4nO3db3BU9d338c9uQna1ZjekkGzAUP7UiikIFUwMI+NMTU3UMjBjp4hBkEmlF3fBjtEZoeNNQB4EO9hilcEptaMddUA7g5dQm5byZxw1EiVyDZE/M6VwiZBNxNTdEEqA7LkfcGdlIQm7yZ7d/e2+XzP7IIdzdr/xoPv27DlnHZZlWQIAADCEM9kDAAAAxIJ4AQAARiFeAACAUYgXAABgFOIFAAAYhXgBAABGIV4AAIBRiBcAAGCU7GQPEG+hUEinTp1Sbm6uHA5HsscBAABRsCxLnZ2dGjVqlJzOgY+tpF28nDp1SsXFxckeAwAADMKJEyd04403DrhO2sVLbm6upEu/vMfjSfI0AAAgGsFgUMXFxeH38YGkXbz0flTk8XiIFwAADBPNKR+csAsAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjJKQeNmwYYPGjh0rt9utsrIyNTU1RbXd5s2b5XA4NGfOHHsHBAAAxrA9XrZs2aLa2lrV1dWpublZU6ZMUWVlpdrb2wfc7vjx43ryySc1c+ZMu0cEAAAGsT1efvOb3+jRRx/VokWLVFJSopdeeknXX3+9/vjHP/a7TU9Pj6qrq7V69WqNHz/e7hEBAIBBbI2X8+fPa9++faqoqPjmBZ1OVVRUqLGxsd/tnnnmGRUUFKimpsbO8QAAgIGy7Xzy06dPq6enR4WFhRHLCwsLdfjw4T63ef/99/Xyyy9r//79Ub1Gd3e3uru7wz8Hg8FBzwsAAFJfSl1t1NnZqYcfflibNm3SiBEjotqmvr5eXq83/CguLrZ5SgAAkEy2HnkZMWKEsrKy1NbWFrG8ra1NPp/vqvWPHj2q48ePa9asWeFloVDo0qDZ2Tpy5IgmTJgQsc2KFStUW1sb/jkYDBIwAACkMVvjJScnR9OmTdPOnTvDlzuHQiHt3LlTS5cuvWr9iRMn6sCBAxHLnn76aXV2dur555/vM0pcLpdcLpct8wMAgNRja7xIUm1trRYuXKjp06ertLRU69evV1dXlxYtWiRJWrBggUaPHq36+nq53W5NmjQpYvu8vDxJumo5AADITLbHy9y5c/Xll19q5cqV8vv9mjp1qhoaGsIn8X7++edyOlPq1BsAAJDCHJZlWckeIp6CwaC8Xq8CgYA8Hk+yxwEAAFGI5f2bQx4AAMAoxAsAADCK7ee8AEA0ekKWmo51qL3znApy3Sodl68spyPZYwFIQcQLgIS7MlT+3dWtNX85pNbAufA6RV636maV6EclPqIGQATiBUBCNbS0avW2gxGh0hd/4Jz+67Vm5V0/TF+fvRBe3hs1VZOKonq9K0Np2neGa9///psYAgxGvABImIaWVi15rVnRXOLYu87l4SJdipolrzVr4/zbrhkwfYWS0yGFLhugyOvW/73/Fg3/lougAQxBvABIiJ6QpdXbDkYVLgOxJDkkrd52UD8q8fUbGf2FUuiKBa2Bc/o/b3wasSzWozsAEourjQAkRNOxjmt+VBQtS5eio+lYR59/PtRQ6j2609DSOugZAdiHeAGQEO2d8QmXaJ5zqKHUGz2rtx1Uz5WHagAkHR8bAbDFlSfKjvhW/L9AtSDX3efyeITS5Ud3yid8e8jPByB+iBcAcdfXibI+j1t51w9T4OyFIZ/34pDk8146sbYv/UXNYNhxxAjA0BAvAOKqvxNl24Lnwssc0jUDZvj1w/TvsxeuWrf39Ny6WSX9nqxbOi5fRV63/IFzQw6lEd9yqfHoV1yJBKQQ4gVA3Ax0omzvVUJ51w+TK9spf7A7/GeXLlcu0fBv5UREwo6D/quP4ERxJVCW06G6WSVa8lpzVKHUF4ck7/XD9MRb/yN/8Oqb53ElEpA8fKs0gLhpPPqV5m366Jrrvf6zMjkdjqiOZgzlawOiuc9LXwYKnt5XjuY+MwCiF8v7N0deAMRNtOeHnD7TrdlTR0e1bpbT0e8Js9cKm6pJRVd9vcCVd9j9d9d5rflLZOAUelw6dzF01Q3ypOjvMwPAPsQLgLiJ9kTZeJxQ29dRlb4+0ukrfq78uXJSZOCELEvVf9jb72tzJRKQXNznBUDc9J4o29+xCIcuBUZ/VwlFq/ek4Cvv5TLYm8v1Bs7sqaNVPuHbOn2m+9obiSuRgGQhXgDETe+JspKuCphorhKKxrVOCpaGfnO5RB5BAhA74gVAXFVNKtLG+bfJ5418Y/d53XE5yfVad8+91lcHRCNRR5AADA7nvACIu75OlI3X/VGi/ahmKB/pDHSpdbyOIAEYPOIFgC0GukpoKBL1kU7vEaTB3GcGgL2IFwBGudbdc6/11QGxsPMIEoDBI14AGCXRH+nYdQQJwOBxwi4A49h9UjCA1MaRFwBG4iMdIHMRLwCMxUc6QGYiXgCkjKF8CSOAzEG8AEgJ0X5XUSyIISA9ES8Akq73u4quvPS597uKBnMSrh0xBCA1cLURgKSy47uK4v3FjQBSC/ECIKni/V1FifjiRgDJRbwASKp4f1dRIr64EUByES8Akire31WUiC9uBJBcxAuApOr9rqL+rgFy6NKJttF+V1GivrgRQPIQLwCSqve7iiRdFTCD+a6ieMcQgNRDvABIunh+V1G8YwhA6nFYlpVWp9wHg0F5vV4FAgF5PJ5kjwMgBvG8qRz3eQHMEsv7N/ECIG1xh13AHLG8f3OHXQBpiy9uBNIT57wAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMkpB42bBhg8aOHSu3262ysjI1NTX1u+6mTZs0c+ZMDR8+XMOHD1dFRcWA6wMAgMxie7xs2bJFtbW1qqurU3Nzs6ZMmaLKykq1t7f3uf6ePXs0b9487d69W42NjSouLtY999yjkydP2j0qAAAwgMOyLMvOFygrK9Ptt9+uF198UZIUCoVUXFysZcuWafny5dfcvqenR8OHD9eLL76oBQsWXHP9YDAor9erQCAgj8cz5PkBAID9Ynn/tvXIy/nz57Vv3z5VVFR884JOpyoqKtTY2BjVc5w9e1YXLlxQfn6+XWMCAACDZNv55KdPn1ZPT48KCwsjlhcWFurw4cNRPcdTTz2lUaNGRQTQ5bq7u9Xd3R3+ORgMDn5gAACQ8lL6aqO1a9dq8+bN2rp1q9xud5/r1NfXy+v1hh/FxcUJnhIAACSSrfEyYsQIZWVlqa2tLWJ5W1ubfD7fgNuuW7dOa9eu1d///nfdeuut/a63YsUKBQKB8OPEiRNxmR0AAKQmW+MlJydH06ZN086dO8PLQqGQdu7cqfLy8n63+/Wvf601a9aooaFB06dPH/A1XC6XPB5PxAMAAKQvW895kaTa2lotXLhQ06dPV2lpqdavX6+uri4tWrRIkrRgwQKNHj1a9fX1kqRnn31WK1eu1BtvvKGxY8fK7/dLkm644QbdcMMNdo8LAABSnO3xMnfuXH355ZdauXKl/H6/pk6dqoaGhvBJvJ9//rmczm8OAG3cuFHnz5/XT37yk4jnqaur06pVq+weFwBSSk/IUtOxDrV3nlNBrlul4/KV5XQkeywgqWy/z0uicZ8XpDvezDJHQ0urVm87qNbAufCyIq9bdbNKVDWpKImTAfEXy/u37UdeAMQPb2aZo6GlVUtea9aV/3fpD5zTkteatXH+bexzZKyUvlQawDd638wuDxfpmzezhpbWJE2GeOsJWVq97eBV4SIpvGz1toPqCaXVgXMgasQLYADezDJL07GOqyL1cpak1sA5NR3rSNxQQAohXgAD8GaWWdo7+9/Xg1kPSDfEC2AA3swyS0Fu33cUH+x6QLohXgAD8GaWWUrH5avI61Z/15A5dOlE7dJxfGEtMhPxAhiAN7PMkuV0qG5WiSRdtc97f66bVcIl8shYxAtgAN7MMk/VpCJtnH+bfN7Io2k+r5vLpJHxuEkdYBDu85J5YrkpITcwhMlief8mXgDD8AaFvhC2MB3xQrwAyCD93Y23N2n5mAkmiOX9m3NeAMBg3MAQmYh4AQCDcQNDZCLiBQAMxg0MkYmIFwAwGDcwRCYiXgDAYNzAEJmIeAEAg3EDQ2Qi4gUADMfdeJFpspM9AABg6KomFelHJT5uYIiMQLwAQJrIcjpUPuHbyR4DsB0fGwEAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKNnJHgAAYLaekKWmYx1q7zyngly3SsflK8vpSPZYSGMJOfKyYcMGjR07Vm63W2VlZWpqahpw/bfeeksTJ06U2+3W5MmT9e677yZiTABAjBpaWnXns7s0b9NH+uXm/Zq36SPd+ewuNbS0Jns0pDHb42XLli2qra1VXV2dmpubNWXKFFVWVqq9vb3P9T/88EPNmzdPNTU1+vTTTzVnzhzNmTNHLS0tdo8KAIhBQ0urlrzWrNbAuYjl/sA5LXmtmYCBbRyWZVl2vkBZWZluv/12vfjii5KkUCik4uJiLVu2TMuXL79q/blz56qrq0vbt28PL7vjjjs0depUvfTSS9d8vWAwKK/Xq0AgII/HE79fBAAQ1hOydOezu64Kl14OST6vW+8/9UM+QkJUYnn/tvXIy/nz57Vv3z5VVFR884JOpyoqKtTY2NjnNo2NjRHrS1JlZWW/63d3dysYDEY8AAD2ajrW0W+4SJIlqTVwTk3HOhI3FDKGrfFy+vRp9fT0qLCwMGJ5YWGh/H5/n9v4/f6Y1q+vr5fX6w0/iouL4zM8AKBf7Z39h8tg1gNiYfyl0itWrFAgEAg/Tpw4keyRAPWELDUe/Ur/vf+kGo9+pZ6QrZ/OAglXkOuO63pALGy9VHrEiBHKyspSW1tbxPK2tjb5fL4+t/H5fDGt73K55HK54jMwEAcNLa1ave1gxCH1Iq9bdbNKVDWpKImTAfFTOi5fRV63/IFz6ivNe895KR2Xn+jRkAFsPfKSk5OjadOmaefOneFloVBIO3fuVHl5eZ/blJeXR6wvSTt27Oh3fSCVcPUFMkWW06G6WSWSLoXK5Xp/rptVwsm6sIXtHxvV1tZq06ZNevXVV3Xo0CEtWbJEXV1dWrRokSRpwYIFWrFiRXj9X/7yl2poaNBzzz2nw4cPa9WqVfrkk0+0dOlSu0cFhqQnZGn1toN9/l9o77LV2w7yERLSRtWkIm2cf5t83siPhnxetzbOv40jjbCN7XfYnTt3rr788kutXLlSfr9fU6dOVUNDQ/ik3M8//1xO5zcNNWPGDL3xxht6+umn9atf/Uo33XST3n77bU2aNMnuUYEhieXqi/IJ307cYICNqiYV6UclPu6wi4Sy/T4vicZ9XpAs/73/pH65ef8113v+wamaPXW0/QMBgEFS5j4vQCbh6gsASAziBYiT3qsv+jtY7tClq464+gIAhoZ4AeKEqy8AIDGIFyCOuPoCAOxn+9VGQKbh6gsAsBfxAtggy+ngcmgAsAkfGwEAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACj2BYvHR0dqq6ulsfjUV5enmpqanTmzJkB11+2bJluvvlmXXfddRozZowee+wxBQIBu0YEAAAGsi1eqqur9dlnn2nHjh3avn273nvvPS1evLjf9U+dOqVTp05p3bp1amlp0SuvvKKGhgbV1NTYNSIAADCQw7IsK95PeujQIZWUlOjjjz/W9OnTJUkNDQ2677779MUXX2jUqFFRPc9bb72l+fPnq6urS9nZ2VFtEwwG5fV6FQgE5PF4Bv07AACAxInl/duWIy+NjY3Ky8sLh4skVVRUyOl0au/evVE/T+8vMFC4dHd3KxgMRjwAAED6siVe/H6/CgoKIpZlZ2crPz9ffr8/quc4ffq01qxZM+BHTZJUX18vr9cbfhQXFw96bgAAkPpiipfly5fL4XAM+Dh8+PCQhwoGg7r//vtVUlKiVatWDbjuihUrFAgEwo8TJ04M+fUBAEDqiu5Ekv/viSee0COPPDLgOuPHj5fP51N7e3vE8osXL6qjo0M+n2/A7Ts7O1VVVaXc3Fxt3bpVw4YNG3B9l8sll8sV1fwAAMB8McXLyJEjNXLkyGuuV15erq+//lr79u3TtGnTJEm7du1SKBRSWVlZv9sFg0FVVlbK5XLpnXfekdvtjmU8AACQAWw55+WWW25RVVWVHn30UTU1NemDDz7Q0qVL9eCDD4avNDp58qQmTpyopqYmSZfC5Z577lFXV5defvllBYNB+f1++f1+9fT02DEmAAAwUExHXmLx+uuva+nSpbr77rvldDr1wAMP6He/+134zy9cuKAjR47o7NmzkqTm5ubwlUjf/e53I57r2LFjGjt2rF2jAnHXE7LUdKxD7Z3nVJDrVum4fGU5HckeCwDSgi33eUkm7vOCZGtoadXqbQfVGjgXXlbkdatuVomqJhUlcTIASF1Jv88LkKkaWlq15LXmiHCRJH/gnJa81qyGltYkTQYA6YN4AeKkJ2Rp9baD6utQZu+y1dsOqieUVgc7ASDhiBcgTpqOdVx1xOVylqTWwDk1HetI3FAAkIaIFyBO2jv7D5fBrAcA6BvxAsRJQW509yWKdj0AQN+IFyBOSsflq8jrVn8XRDt06aqj0nH5iRwLANIO8QLESZbTobpZJZJ0VcD0/lw3q4T7vQDAEBEvQBxVTSrSxvm3yeeN/GjI53Vr4/zbuM8LAMSBbXfYBTJV1aQi/ajExx12AcAmxAtggyynQ+UTvp3sMQAgLfGxEQAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwCvECAACMQrwAAACjEC8AAMAoxAsAADAK8QIAAIxCvAAAAKMQLwAAwCjECwAAMArxAgAAjEK8AAAAoxAvAADAKMQLAAAwim3x0tHRoerqank8HuXl5ammpkZnzpyJalvLsnTvvffK4XDo7bfftmtEAABgINvipbq6Wp999pl27Nih7du367333tPixYuj2nb9+vVyOBx2jQYAAAyWbceTHjp0SA0NDfr44481ffp0SdILL7yg++67T+vWrdOoUaP63Xb//v167rnn9Mknn6ioqMiO8QAAgMFsOfLS2NiovLy8cLhIUkVFhZxOp/bu3dvvdmfPntVDDz2kDRs2yOfzRfVa3d3dCgaDEQ8AAJC+bIkXv9+vgoKCiGXZ2dnKz8+X3+/vd7vHH39cM2bM0OzZs6N+rfr6enm93vCjuLh40HMDAIDUF1O8LF++XA6HY8DH4cOHBzXIO++8o127dmn9+vUxbbdixQoFAoHw48SJE4N6fQAAYIaYznl54okn9Mgjjwy4zvjx4+Xz+dTe3h6x/OLFi+ro6Oj346Bdu3bp6NGjysvLi1j+wAMPaObMmdqzZ0+f27lcLrlcrmh/BQAAYLiY4mXkyJEaOXLkNdcrLy/X119/rX379mnatGmSLsVJKBRSWVlZn9ssX75cP/vZzyKWTZ48Wb/97W81a9asWMYEAABpzJarjW655RZVVVXp0Ucf1UsvvaQLFy5o6dKlevDBB8NXGp08eVJ33323/vSnP6m0tFQ+n6/PozJjxozRuHHj7BgTAAAYyLb7vLz++uuaOHGi7r77bt13332688479fvf/z785xcuXNCRI0d09uxZu0YAAABpyGFZlpXsIeIpGAzK6/UqEAjI4/EkexwAABCFWN6/+W4jAABgFOIFAAAYhXgBAABGIV4AAIBRiBcAAGAU4gUAABiFeAEAAEYhXgAAgFGIFwAAYBTiBQAAGIV4AQAARiFeAACAUYgXAABgFOIFAAAYhXgBAABGIV4AAIBRiBcAAGAU4gUAABiFeAEAAEYhXgAAgFGIFwAAYBTiBQAAGIV4AQAARiFeAACAUYgXAABgFOIFAAAYhXgBAABGIV4AAIBRiBcAAGCU7GQPEG+WZUmSgsFgkicBAADR6n3f7n0fH0jaxUtnZ6ckqbi4OMmTAACAWHV2dsrr9Q64jsOKJnEMEgqFdOrUKeXm5srhcCR7nEELBoMqLi7WiRMn5PF4kj1ORmNfpA72RepgX6SWdNgflmWps7NTo0aNktM58FktaXfkxel06sYbb0z2GHHj8XiM/YuYbtgXqYN9kTrYF6nF9P1xrSMuvThhFwAAGIV4AQAARiFeUpTL5VJdXZ1cLleyR8l47IvUwb5IHeyL1JJp+yPtTtgFAADpjSMvAADAKMQLAAAwCvECAACMQrwAAACjEC8ppKOjQ9XV1fJ4PMrLy1NNTY3OnDkT1baWZenee++Vw+HQ22+/be+gGSDWfdHR0aFly5bp5ptv1nXXXacxY8boscceUyAQSODU6WHDhg0aO3as3G63ysrK1NTUNOD6b731liZOnCi3263Jkyfr3XffTdCk6S+WfbFp0ybNnDlTw4cP1/Dhw1VRUXHNfYfYxPrvRq/NmzfL4XBozpw59g6YQMRLCqmurtZnn32mHTt2aPv27Xrvvfe0ePHiqLZdv3690V+HkGpi3RenTp3SqVOntG7dOrW0tOiVV15RQ0ODampqEji1+bZs2aLa2lrV1dWpublZU6ZMUWVlpdrb2/tc/8MPP9S8efNUU1OjTz/9VHPmzNGcOXPU0tKS4MnTT6z7Ys+ePZo3b552796txsZGFRcX65577tHJkycTPHl6inV/9Dp+/LiefPJJzZw5M0GTJoiFlHDw4EFLkvXxxx+Hl/31r3+1HA6HdfLkyQG3/fTTT63Ro0dbra2tliRr69atNk+b3oayLy735ptvWjk5OdaFCxfsGDMtlZaWWr/4xS/CP/f09FijRo2y6uvr+1z/pz/9qXX//fdHLCsrK7N+/vOf2zpnJoh1X1zp4sWLVm5urvXqq6/aNWJGGcz+uHjxojVjxgzrD3/4g7Vw4UJr9uzZCZg0MTjykiIaGxuVl5en6dOnh5dVVFTI6XRq7969/W539uxZPfTQQ9qwYYN8Pl8iRk17g90XVwoEAvJ4PMrOTruvELPF+fPntW/fPlVUVISXOZ1OVVRUqLGxsc9tGhsbI9aXpMrKyn7XR3QGsy+udPbsWV24cEH5+fl2jZkxBrs/nnnmGRUUFKTlEWD+q5oi/H6/CgoKIpZlZ2crPz9ffr+/3+0ef/xxzZgxQ7Nnz7Z7xIwx2H1xudOnT2vNmjVRf+yHS//Menp6VFhYGLG8sLBQhw8f7nMbv9/f5/rR7if0bTD74kpPPfWURo0adVVcInaD2R/vv/++Xn75Ze3fvz8BEyYeR15stnz5cjkcjgEf0f7H4ErvvPOOdu3apfXr18d36DRl5764XDAY1P3336+SkhKtWrVq6IMDhlm7dq02b96srVu3yu12J3ucjNPZ2amHH35YmzZt0ogRI5I9ji048mKzJ554Qo888siA64wfP14+n++qE68uXryojo6Ofj8O2rVrl44ePaq8vLyI5Q888IBmzpypPXv2DGHy9GPnvujV2dmpqqoq5ebmauvWrRo2bNhQx84YI0aMUFZWltra2iKWt7W19fvP3efzxbQ+ojOYfdFr3bp1Wrt2rf7xj3/o1ltvtXPMjBHr/jh69KiOHz+uWbNmhZeFQiFJl44iHzlyRBMmTLB3aLsl+6QbXNJ7kugnn3wSXva3v/1twJNEW1tbrQMHDkQ8JFnPP/+89a9//StRo6edwewLy7KsQCBg3XHHHdZdd91ldXV1JWLUtFNaWmotXbo0/HNPT481evToAU/Y/fGPfxyxrLy8nBN24yDWfWFZlvXss89aHo/HamxsTMSIGSWW/fGf//znqveG2bNnWz/84Q+tAwcOWN3d3Ykc3RbESwqpqqqyfvCDH1h79+613n//feumm26y5s2bF/7zL774wrr55putvXv39vsc4mqjuIh1XwQCAausrMyaPHmy9c9//tNqbW0NPy5evJisX8M4mzdvtlwul/XKK69YBw8etBYvXmzl5eVZfr/fsizLevjhh63ly5eH1//ggw+s7Oxsa926ddahQ4esuro6a9iwYdaBAweS9SukjVj3xdq1a62cnBzrz3/+c8Tf/87OzmT9Cmkl1v1xpXS72oh4SSFfffWVNW/ePOuGG26wPB6PtWjRooh/8Y8dO2ZJsnbv3t3vcxAv8RHrvti9e7clqc/HsWPHkvNLGOqFF16wxowZY+Xk5FilpaXWRx99FP6zu+66y1q4cGHE+m+++ab1ve99z8rJybG+//3vW3/5y18SPHH6imVffOc73+nz739dXV3iB09Tsf67cbl0ixeHZVlWoj+qAgAAGCyuNgIAAEYhXgAAgFGIFwAAYBTiBQAAGIV4AQAARiFeAACAUYgXAABgFOIFAAAYhXgBAABGIV4AAIBRiBcAAGAU4gUAABjl/wGr6RTVChazLQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "norm_df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", "plt.xlim(-0.5,0.5)\n", @@ -901,252 +286,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "norm_df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", "\n", @@ -1172,66 +314,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'plot_hand_keypoints' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[6], line 16\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[39m# show animation of the keypoints over time, show one frame every 1000ms and remove the other frames\u001b[39;00m\n\u001b[1;32m 15\u001b[0m anim \u001b[39m=\u001b[39m animation\u001b[39m.\u001b[39mFuncAnimation(fig, animate_hand, init_func\u001b[39m=\u001b[39minit_hand, frames\u001b[39m=\u001b[39mnorm_df\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m], interval\u001b[39m=\u001b[39m\u001b[39m1000\u001b[39m, repeat\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, )\n\u001b[0;32m---> 16\u001b[0m HTML(anim\u001b[39m.\u001b[39;49mto_html5_video())\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1288\u001b[0m, in \u001b[0;36mAnimation.to_html5_video\u001b[0;34m(self, embed_limit)\u001b[0m\n\u001b[1;32m 1284\u001b[0m Writer \u001b[39m=\u001b[39m writers[mpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39manimation.writer\u001b[39m\u001b[39m'\u001b[39m]]\n\u001b[1;32m 1285\u001b[0m writer \u001b[39m=\u001b[39m Writer(codec\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mh264\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 1286\u001b[0m bitrate\u001b[39m=\u001b[39mmpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39manimation.bitrate\u001b[39m\u001b[39m'\u001b[39m],\n\u001b[1;32m 1287\u001b[0m fps\u001b[39m=\u001b[39m\u001b[39m1000.\u001b[39m \u001b[39m/\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_interval)\n\u001b[0;32m-> 1288\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msave(\u001b[39mstr\u001b[39;49m(path), writer\u001b[39m=\u001b[39;49mwriter)\n\u001b[1;32m 1289\u001b[0m \u001b[39m# Now open and base64 encode.\u001b[39;00m\n\u001b[1;32m 1290\u001b[0m vid64 \u001b[39m=\u001b[39m base64\u001b[39m.\u001b[39mencodebytes(path\u001b[39m.\u001b[39mread_bytes())\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1090\u001b[0m, in \u001b[0;36mAnimation.save\u001b[0;34m(self, filename, writer, fps, dpi, codec, bitrate, extra_args, metadata, extra_anim, savefig_kwargs, progress_callback)\u001b[0m\n\u001b[1;32m 1085\u001b[0m \u001b[39mwith\u001b[39;00m mpl\u001b[39m.\u001b[39mrc_context({\u001b[39m'\u001b[39m\u001b[39msavefig.bbox\u001b[39m\u001b[39m'\u001b[39m: \u001b[39mNone\u001b[39;00m}), \\\n\u001b[1;32m 1086\u001b[0m writer\u001b[39m.\u001b[39msaving(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig, filename, dpi), \\\n\u001b[1;32m 1087\u001b[0m cbook\u001b[39m.\u001b[39m_setattr_cm(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig\u001b[39m.\u001b[39mcanvas,\n\u001b[1;32m 1088\u001b[0m _is_saving\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, manager\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 1089\u001b[0m \u001b[39mfor\u001b[39;00m anim \u001b[39min\u001b[39;00m all_anim:\n\u001b[0;32m-> 1090\u001b[0m anim\u001b[39m.\u001b[39;49m_init_draw() \u001b[39m# Clear the initial frame\u001b[39;00m\n\u001b[1;32m 1091\u001b[0m frame_number \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m 1092\u001b[0m \u001b[39m# TODO: Currently only FuncAnimation has a save_count\u001b[39;00m\n\u001b[1;32m 1093\u001b[0m \u001b[39m# attribute. Can we generalize this to all Animations?\u001b[39;00m\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1750\u001b[0m, in \u001b[0;36mFuncAnimation._init_draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1748\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_draw_frame(frame_data)\n\u001b[1;32m 1749\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1750\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_func()\n\u001b[1;32m 1751\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_blit:\n\u001b[1;32m 1752\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", - "Cell \u001b[0;32mIn[6], line 9\u001b[0m, in \u001b[0;36minit_hand\u001b[0;34m()\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minit_hand\u001b[39m():\n\u001b[0;32m----> 9\u001b[0m \u001b[39mreturn\u001b[39;00m plot_hand_keypoints(norm_df, \u001b[39m\"\u001b[39m\u001b[39mright\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m0\u001b[39m, ret\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'plot_hand_keypoints' is not defined" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error in callback (for post_execute):\n" - ] - }, - { - "ename": "NameError", - "evalue": "name 'plot_hand_keypoints' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/pyplot.py:120\u001b[0m, in \u001b[0;36m_draw_all_if_interactive\u001b[0;34m()\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_draw_all_if_interactive\u001b[39m():\n\u001b[1;32m 119\u001b[0m \u001b[39mif\u001b[39;00m matplotlib\u001b[39m.\u001b[39mis_interactive():\n\u001b[0;32m--> 120\u001b[0m draw_all()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/_pylab_helpers.py:132\u001b[0m, in \u001b[0;36mGcf.draw_all\u001b[0;34m(cls, force)\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[39mfor\u001b[39;00m manager \u001b[39min\u001b[39;00m \u001b[39mcls\u001b[39m\u001b[39m.\u001b[39mget_all_fig_managers():\n\u001b[1;32m 131\u001b[0m \u001b[39mif\u001b[39;00m force \u001b[39mor\u001b[39;00m manager\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mfigure\u001b[39m.\u001b[39mstale:\n\u001b[0;32m--> 132\u001b[0m manager\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mdraw_idle()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backend_bases.py:2082\u001b[0m, in \u001b[0;36mFigureCanvasBase.draw_idle\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2080\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_is_idle_drawing:\n\u001b[1;32m 2081\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_idle_draw_cntx():\n\u001b[0;32m-> 2082\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdraw(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backends/backend_agg.py:400\u001b[0m, in \u001b[0;36mFigureCanvasAgg.draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[39m# Acquire a lock on the shared font cache.\u001b[39;00m\n\u001b[1;32m 397\u001b[0m \u001b[39mwith\u001b[39;00m RendererAgg\u001b[39m.\u001b[39mlock, \\\n\u001b[1;32m 398\u001b[0m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtoolbar\u001b[39m.\u001b[39m_wait_cursor_for_draw_cm() \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtoolbar\n\u001b[1;32m 399\u001b[0m \u001b[39melse\u001b[39;00m nullcontext()):\n\u001b[0;32m--> 400\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdraw(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrenderer)\n\u001b[1;32m 401\u001b[0m \u001b[39m# A GUI class may be need to update a window using this draw, so\u001b[39;00m\n\u001b[1;32m 402\u001b[0m \u001b[39m# don't forget to call the superclass.\u001b[39;00m\n\u001b[1;32m 403\u001b[0m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mdraw()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py:95\u001b[0m, in \u001b[0;36m_finalize_rasterization..draw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[39m@wraps\u001b[39m(draw)\n\u001b[1;32m 94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdraw_wrapper\u001b[39m(artist, renderer, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m---> 95\u001b[0m result \u001b[39m=\u001b[39m draw(artist, renderer, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 96\u001b[0m \u001b[39mif\u001b[39;00m renderer\u001b[39m.\u001b[39m_rasterizing:\n\u001b[1;32m 97\u001b[0m renderer\u001b[39m.\u001b[39mstop_rasterizing()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization..draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 70\u001b[0m renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m 73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/figure.py:3150\u001b[0m, in \u001b[0;36mFigure.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 3147\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 3148\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstale \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m\n\u001b[0;32m-> 3150\u001b[0m DrawEvent(\u001b[39m\"\u001b[39;49m\u001b[39mdraw_event\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas, renderer)\u001b[39m.\u001b[39;49m_process()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backend_bases.py:1263\u001b[0m, in \u001b[0;36mEvent._process\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1261\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_process\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 1262\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"Generate an event with name ``self.name`` on ``self.canvas``.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1263\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mcallbacks\u001b[39m.\u001b[39;49mprocess(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mname, \u001b[39mself\u001b[39;49m)\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/cbook/__init__.py:309\u001b[0m, in \u001b[0;36mCallbackRegistry.process\u001b[0;34m(self, s, *args, **kwargs)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m exc:\n\u001b[1;32m 308\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mexception_handler \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 309\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mexception_handler(exc)\n\u001b[1;32m 310\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 311\u001b[0m \u001b[39mraise\u001b[39;00m\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/cbook/__init__.py:96\u001b[0m, in \u001b[0;36m_exception_printer\u001b[0;34m(exc)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_exception_printer\u001b[39m(exc):\n\u001b[1;32m 95\u001b[0m \u001b[39mif\u001b[39;00m _get_running_interactive_framework() \u001b[39min\u001b[39;00m [\u001b[39m\"\u001b[39m\u001b[39mheadless\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m]:\n\u001b[0;32m---> 96\u001b[0m \u001b[39mraise\u001b[39;00m exc\n\u001b[1;32m 97\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 98\u001b[0m traceback\u001b[39m.\u001b[39mprint_exc()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/cbook/__init__.py:304\u001b[0m, in \u001b[0;36mCallbackRegistry.process\u001b[0;34m(self, s, *args, **kwargs)\u001b[0m\n\u001b[1;32m 302\u001b[0m \u001b[39mif\u001b[39;00m func \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 303\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 304\u001b[0m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 305\u001b[0m \u001b[39m# this does not capture KeyboardInterrupt, SystemExit,\u001b[39;00m\n\u001b[1;32m 306\u001b[0m \u001b[39m# and GeneratorExit\u001b[39;00m\n\u001b[1;32m 307\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m exc:\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:904\u001b[0m, in \u001b[0;36mAnimation._start\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 901\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mmpl_disconnect(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_first_draw_id)\n\u001b[1;32m 903\u001b[0m \u001b[39m# Now do any initial draw\u001b[39;00m\n\u001b[0;32m--> 904\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_draw()\n\u001b[1;32m 906\u001b[0m \u001b[39m# Add our callback for stepping the animation and\u001b[39;00m\n\u001b[1;32m 907\u001b[0m \u001b[39m# actually start the event_source.\u001b[39;00m\n\u001b[1;32m 908\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mevent_source\u001b[39m.\u001b[39madd_callback(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_step)\n", - "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1750\u001b[0m, in \u001b[0;36mFuncAnimation._init_draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1748\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_draw_frame(frame_data)\n\u001b[1;32m 1749\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1750\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_func()\n\u001b[1;32m 1751\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_blit:\n\u001b[1;32m 1752\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", - "Cell \u001b[0;32mIn[6], line 9\u001b[0m, in \u001b[0;36minit_hand\u001b[0;34m()\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minit_hand\u001b[39m():\n\u001b[0;32m----> 9\u001b[0m \u001b[39mreturn\u001b[39;00m plot_hand_keypoints(norm_df, \u001b[39m\"\u001b[39m\u001b[39mright\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m0\u001b[39m, ret\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'plot_hand_keypoints' is not defined" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure()\n", "ax = plt.axes(xlim=(-0.5, 0.5), ylim=(-0.5, 0.5))\n", @@ -1255,468 +340,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "fig = plt.figure()\n", @@ -1768,7 +392,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.9.13" }, "vscode": { "interpreter": { diff --git a/visualizations/webcam_view.py b/visualizations/webcam_view.py index 99bf2bb..9c42370 100644 --- a/visualizations/webcam_view.py +++ b/visualizations/webcam_view.py @@ -26,8 +26,8 @@ frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) keypoints = [] -spoter_model = SPOTER(num_classes=26, hidden_dim=len(LANDMARKS) * 2) -spoter_model.load_state_dict(torch.load('models/spoter_76.pth', map_location=torch.device('cpu'))) +spoter_model = SPOTER(num_classes=19, hidden_dim=len(LANDMARKS) * 2) +spoter_model.load_state_dict(torch.load('checkpoints/spoter_80.pth', map_location=torch.device('cpu'))) # get values of the landmarks as a list of integers values = []