Hopenet_colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lq2YdgXX7333",
        "outputId": "73fe0d2c-98ac-492c-84c5-ea8453d0eb8f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'dhp'...\n",
            "remote: Enumerating objects: 11072, done.\u001b[K\n",
            "remote: Total 11072 (delta 0), reused 0 (delta 0), pack-reused 11072\u001b[K\n",
            "Receiving objects: 100% (11072/11072), 216.05 MiB | 20.92 MiB/s, done.\n",
            "Resolving deltas: 100% (491/491), done.\n"
          ]
        }
      ],
      "source": [
        "!git clone https://github.com/natanielruiz/deep-head-pose.git dhp"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd dhp"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-fVfoD4h-8V4",
        "outputId": "b8cac9d9-e58b-4f59-f252-bb0f688eb02b"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/dhp\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#download weights\n",
        "!gdown 1m25PrSE7g9D2q2XJVMR6IA7RaCvWSzCR"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kl7ftFgP_FHy",
        "outputId": "76d08eb7-7911-485f-8ed6-01d64bf85163"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1m25PrSE7g9D2q2XJVMR6IA7RaCvWSzCR\n",
            "To: /content/dhp/hopenet_robust_alpha1.pkl\n",
            "100% 95.9M/95.9M [00:00<00:00, 118MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd code"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_YvD3sBMBzPt",
        "outputId": "f6c90bae-c1e8-42d0-fe6e-b62e01e04112"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/dhp/code\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#for face detection\n",
        "!pip install mtcnn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zNvcKpmVD0QS",
        "outputId": "43c6f3ec-fe68-409b-f89d-18d615137351"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting mtcnn\n",
            "  Downloading mtcnn-0.1.1-py3-none-any.whl (2.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 2.3 MB 9.4 MB/s \n",
            "\u001b[?25hRequirement already satisfied: opencv-python>=4.1.0 in /usr/local/lib/python3.7/dist-packages (from mtcnn) (4.6.0.66)\n",
            "Requirement already satisfied: keras>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from mtcnn) (2.9.0)\n",
            "Requirement already satisfied: numpy>=1.14.5 in /usr/local/lib/python3.7/dist-packages (from opencv-python>=4.1.0->mtcnn) (1.21.6)\n",
            "Installing collected packages: mtcnn\n",
            "Successfully installed mtcnn-0.1.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile utils.py\n",
        "import numpy as np\n",
        "import torch\n",
        "#from torch.utils.serialization import load_lua\n",
        "import os\n",
        "import scipy.io as sio\n",
        "import cv2\n",
        "import math\n",
        "from math import cos, sin\n",
        "\n",
        "def softmax_temperature(tensor, temperature):\n",
        "    result = torch.exp(tensor / temperature)\n",
        "    result = torch.div(result, torch.sum(result, 1).unsqueeze(1).expand_as(result))\n",
        "    return result\n",
        "\n",
        "def get_pose_params_from_mat(mat_path):\n",
        "    # This functions gets the pose parameters from the .mat\n",
        "    # Annotations that come with the Pose_300W_LP dataset.\n",
        "    mat = sio.loadmat(mat_path)\n",
        "    # [pitch yaw roll tdx tdy tdz scale_factor]\n",
        "    pre_pose_params = mat['Pose_Para'][0]\n",
        "    # Get [pitch, yaw, roll, tdx, tdy]\n",
        "    pose_params = pre_pose_params[:5]\n",
        "    return pose_params\n",
        "\n",
        "def get_ypr_from_mat(mat_path):\n",
        "    # Get yaw, pitch, roll from .mat annotation.\n",
        "    # They are in radians\n",
        "    mat = sio.loadmat(mat_path)\n",
        "    # [pitch yaw roll tdx tdy tdz scale_factor]\n",
        "    pre_pose_params = mat['Pose_Para'][0]\n",
        "    # Get [pitch, yaw, roll]\n",
        "    pose_params = pre_pose_params[:3]\n",
        "    return pose_params\n",
        "\n",
        "def get_pt2d_from_mat(mat_path):\n",
        "    # Get 2D landmarks\n",
        "    mat = sio.loadmat(mat_path)\n",
        "    pt2d = mat['pt2d']\n",
        "    return pt2d\n",
        "\n",
        "def mse_loss(input, target):\n",
        "    return torch.sum(torch.abs(input.data - target.data) ** 2)\n",
        "\n",
        "def plot_pose_cube(img, yaw, pitch, roll, tdx=None, tdy=None, size=150.):\n",
        "    # Input is a cv2 image\n",
        "    # pose_params: (pitch, yaw, roll, tdx, tdy)\n",
        "    # Where (tdx, tdy) is the translation of the face.\n",
        "    # For pose we have [pitch yaw roll tdx tdy tdz scale_factor]\n",
        "\n",
        "    p = pitch * np.pi / 180\n",
        "    y = -(yaw * np.pi / 180)\n",
        "    r = roll * np.pi / 180\n",
        "    if tdx != None and tdy != None:\n",
        "        face_x = tdx - 0.50 * size\n",
        "        face_y = tdy - 0.50 * size\n",
        "    else:\n",
        "        height, width = img.shape[:2]\n",
        "        face_x = width / 2 - 0.5 * size\n",
        "        face_y = height / 2 - 0.5 * size\n",
        "\n",
        "    x1 = size * (cos(y) * cos(r)) + face_x\n",
        "    y1 = size * (cos(p) * sin(r) + cos(r) * sin(p) * sin(y)) + face_y\n",
        "    x2 = size * (-cos(y) * sin(r)) + face_x\n",
        "    y2 = size * (cos(p) * cos(r) - sin(p) * sin(y) * sin(r)) + face_y\n",
        "    x3 = size * (sin(y)) + face_x\n",
        "    y3 = size * (-cos(y) * sin(p)) + face_y\n",
        "\n",
        "    # Draw base in red\n",
        "    cv2.line(img, (int(face_x), int(face_y)), (int(x1),int(y1)),(0,0,255),3)\n",
        "    cv2.line(img, (int(face_x), int(face_y)), (int(x2),int(y2)),(0,0,255),3)\n",
        "    cv2.line(img, (int(x2), int(y2)), (int(x2+x1-face_x),int(y2+y1-face_y)),(0,0,255),3)\n",
        "    cv2.line(img, (int(x1), int(y1)), (int(x1+x2-face_x),int(y1+y2-face_y)),(0,0,255),3)\n",
        "    # Draw pillars in blue\n",
        "    cv2.line(img, (int(face_x), int(face_y)), (int(x3),int(y3)),(255,0,0),2)\n",
        "    cv2.line(img, (int(x1), int(y1)), (int(x1+x3-face_x),int(y1+y3-face_y)),(255,0,0),2)\n",
        "    cv2.line(img, (int(x2), int(y2)), (int(x2+x3-face_x),int(y2+y3-face_y)),(255,0,0),2)\n",
        "    cv2.line(img, (int(x2+x1-face_x),int(y2+y1-face_y)), (int(x3+x1+x2-2*face_x),int(y3+y2+y1-2*face_y)),(255,0,0),2)\n",
        "    # Draw top in green\n",
        "    cv2.line(img, (int(x3+x1-face_x),int(y3+y1-face_y)), (int(x3+x1+x2-2*face_x),int(y3+y2+y1-2*face_y)),(0,255,0),2)\n",
        "    cv2.line(img, (int(x2+x3-face_x),int(y2+y3-face_y)), (int(x3+x1+x2-2*face_x),int(y3+y2+y1-2*face_y)),(0,255,0),2)\n",
        "    cv2.line(img, (int(x3), int(y3)), (int(x3+x1-face_x),int(y3+y1-face_y)),(0,255,0),2)\n",
        "    cv2.line(img, (int(x3), int(y3)), (int(x3+x2-face_x),int(y3+y2-face_y)),(0,255,0),2)\n",
        "\n",
        "    return img\n",
        "\n",
        "def draw_axis(img, yaw, pitch, roll, tdx=None, tdy=None, size = 100):\n",
        "\n",
        "    pitch = pitch * np.pi / 180\n",
        "    yaw = -(yaw * np.pi / 180)\n",
        "    roll = roll * np.pi / 180\n",
        "\n",
        "    if tdx != None and tdy != None:\n",
        "        tdx = tdx\n",
        "        tdy = tdy\n",
        "    else:\n",
        "        height, width = img.shape[:2]\n",
        "        tdx = width / 2\n",
        "        tdy = height / 2\n",
        "\n",
        "    # X-Axis pointing to right. drawn in red\n",
        "    x1 = size * (cos(yaw) * cos(roll)) + tdx\n",
        "    y1 = size * (cos(pitch) * sin(roll) + cos(roll) * sin(pitch) * sin(yaw)) + tdy\n",
        "\n",
        "    # Y-Axis | drawn in green\n",
        "    #        v\n",
        "    x2 = size * (-cos(yaw) * sin(roll)) + tdx\n",
        "    y2 = size * (cos(pitch) * cos(roll) - sin(pitch) * sin(yaw) * sin(roll)) + tdy\n",
        "\n",
        "    # Z-Axis (out of the screen) drawn in blue\n",
        "    x3 = size * (sin(yaw)) + tdx\n",
        "    y3 = size * (-cos(yaw) * sin(pitch)) + tdy\n",
        "\n",
        "    cv2.line(img, (int(tdx), int(tdy)), (int(x1),int(y1)),(0,0,255),3)\n",
        "    cv2.line(img, (int(tdx), int(tdy)), (int(x2),int(y2)),(0,255,0),3)\n",
        "    cv2.line(img, (int(tdx), int(tdy)), (int(x3),int(y3)),(255,0,0),2)\n",
        "\n",
        "    return img\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5B4ADMnNNDgG",
        "outputId": "3bdf29ef-44e5-451f-e94d-d9dab2c60cba"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import sys, os, argparse\n",
        "\n",
        "import numpy as np\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.autograd import Variable\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import transforms\n",
        "import torch.backends.cudnn as cudnn\n",
        "import torchvision\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "import datasets, hopenet, utils\n",
        "from mtcnn import MTCNN\n",
        "import cv2\n",
        "\n",
        "from PIL import Image\n",
        "from google.colab.patches import cv2_imshow\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "\n",
        "cudnn.enabled = True\n",
        "gpu = 0\n",
        "snapshot_path = \"/content/dhp/hopenet_robust_alpha1.pkl\"\n",
        "\n",
        "# ResNet50 structure\n",
        "model = hopenet.Hopenet(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)\n",
        "\n",
        "\n",
        "# Load snapshot\n",
        "saved_state_dict = torch.load(snapshot_path)\n",
        "model.load_state_dict(saved_state_dict)\n",
        "\n",
        "\n",
        "\n",
        "transformations = transforms.Compose([transforms.Resize(224),\n",
        "transforms.CenterCrop(224), transforms.ToTensor(),\n",
        "transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n",
        "\n",
        "\n",
        "model.cuda(gpu)\n",
        "\n",
        "\n",
        "\n",
        "# Test the Model\n",
        "model.eval()  # Change model to 'eval' mode (BN uses moving mean/var).\n",
        "total = 0\n",
        "\n",
        "idx_tensor = [idx for idx in range(66)]\n",
        "idx_tensor = torch.FloatTensor(idx_tensor).cuda(gpu)\n",
        "\n",
        "yaw_error = .0\n",
        "pitch_error = .0\n",
        "roll_error = .0\n",
        "\n",
        "l1loss = torch.nn.L1Loss(size_average=False)\n",
        "def test(path):\n",
        "    img = Image.open(path)\n",
        "    \n",
        "    img1 = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)\n",
        "    detector = MTCNN()\n",
        "    #assuming one face\n",
        "    face=detector.detect_faces(img1)[0]['box']\n",
        "    x,y,w,h=face\n",
        "    #print(x,y,w,h)\n",
        "    \n",
        "    img=img.crop((int(x-20),int(y-20),int(x+w+20),int(y+h+20)))\n",
        "\n",
        "       \n",
        "    \n",
        "    img = img.convert('RGB')\n",
        "    \n",
        "    cv2_img=np.asarray(img)\n",
        "    #\n",
        "    #print(cv2_img.shape)\n",
        "    cv2_img=cv2.resize(cv2_img,(224,224))[:,:,::-1]\n",
        "    cv2_img = cv2_img.astype(np.uint8).copy() \n",
        "    img = transformations(img)\n",
        "    \n",
        "    img=img.unsqueeze(0)\n",
        "    \n",
        "    images = Variable(img).cuda(gpu)\n",
        "    \n",
        "\n",
        "    yaw, pitch, roll = model(images)\n",
        "\n",
        "    # Binned predictions\n",
        "    _, yaw_bpred = torch.max(yaw.data, 1)\n",
        "    _, pitch_bpred = torch.max(pitch.data, 1)\n",
        "    _, roll_bpred = torch.max(roll.data, 1)\n",
        "\n",
        "    # Continuous predictions\n",
        "    yaw_predicted = utils.softmax_temperature(yaw.data, 1)\n",
        "    pitch_predicted = utils.softmax_temperature(pitch.data, 1)\n",
        "    roll_predicted = utils.softmax_temperature(roll.data, 1)\n",
        "\n",
        "    yaw_predicted = torch.sum(yaw_predicted * idx_tensor, 1).cpu() * 3 - 99\n",
        "    pitch_predicted = torch.sum(pitch_predicted * idx_tensor, 1).cpu() * 3 - 99\n",
        "    roll_predicted = torch.sum(roll_predicted * idx_tensor, 1).cpu() * 3 - 99\n",
        "\n",
        "    \n",
        "  \n",
        "    pitch = pitch_predicted[0]\n",
        "    yaw = -yaw_predicted[0] \n",
        "    roll = roll_predicted[0] \n",
        "    print(\"pitch,yaw,roll\",pitch,yaw,roll)      \n",
        "    utils.draw_axis(cv2_img, yaw_predicted[0], pitch_predicted[0], roll_predicted[0], size=100)\n",
        "    cv2.imwrite('/content/res.jpg', cv2_img)\n",
        "\n",
        "#put the path of your image here, result will be saved as /content/res.jpg\n",
        "test(\"/content/a.jpg\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LznnXGtF-0r6",
        "outputId": "c6d08366-68f8-4092-8104-98021b117386"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 208ms/step\n",
            "1/1 [==============================] - 0s 177ms/step\n",
            "1/1 [==============================] - 0s 104ms/step\n",
            "1/1 [==============================] - 0s 78ms/step\n",
            "1/1 [==============================] - 0s 72ms/step\n",
            "1/1 [==============================] - 0s 67ms/step\n",
            "1/1 [==============================] - 0s 68ms/step\n",
            "1/1 [==============================] - 0s 63ms/step\n",
            "1/1 [==============================] - 0s 62ms/step\n",
            "1/1 [==============================] - 0s 61ms/step\n",
            "2/2 [==============================] - 0s 35ms/step\n",
            "1/1 [==============================] - 0s 117ms/step\n",
            "pitch,yaw,roll tensor(-4.7438) tensor(4.6506) tensor(-2.5348)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#view result\n",
        "img=cv2.imread('/content/res.jpg')\n",
        "cv2_imshow(img)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "id": "VPzFDHjROStA",
        "outputId": "722336c2-5386-452f-927f-728c28f892b7"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=224x224 at 0x7FDCFC084350>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}