mapping/compute_FFHQ_mean_shape_and_latent.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nWe use CelebA dataset as training data in this experiment\\n--------------------------------------------------------\\nMethod Brief Description:\\nTraining STEPS:\\n\\n\\n\\n--------------------------------------------------------\\nAuthor: Peizhi Yan\\nDate Updated: Sep.-21-2021\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Author: Peizhi Yan\n",
    "Date Updated: Sep.-21-2021\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\yanpe\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\numpy\\core\\__init__.py:29: UserWarning: loaded more than 1 DLL from .libs:\n",
      "c:\\users\\yanpe\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\numpy\\.libs\\libopenblas.TXA6YQSD3GCQQC22GEQ54J2UDCXDXHWN.gfortran-win_amd64.dll\n",
      "c:\\users\\yanpe\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\numpy\\.libs\\libopenblas.WCDJNK7YVMPZQ2ME2ZZHJJRJ3JIKNDB7.gfortran-win_amd64.dll\n",
      "  stacklevel=1)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA is available. Device:  NVIDIA GeForce RTX 3070\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import gc\n",
    "import os\n",
    "from tqdm import tqdm\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import pickle\n",
    "import scipy.io as sio\n",
    "from scipy.io import loadmat\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import torchvision.transforms as transforms\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "# Pytorch 1.9\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.utils\n",
    "import torch.distributions\n",
    "\n",
    "# Pytorch3d\n",
    "from pytorch3d.structures import Meshes\n",
    "from pytorch3d.renderer import (\n",
    "    look_at_view_transform,\n",
    "    FoVPerspectiveCameras,\n",
    "    PointLights,\n",
    "    RasterizationSettings,\n",
    "    MeshRenderer,\n",
    "    MeshRasterizer,\n",
    "    SoftPhongShader,\n",
    "    TexturesVertex,\n",
    "    blending\n",
    ")\n",
    "\n",
    "import open3d as o3d\n",
    "\n",
    "# facenet-pytorch 2.5.2\n",
    "from facenet_pytorch import MTCNN, InceptionResnetV1\n",
    "\n",
    "# face-alignment 1.3.4\n",
    "import face_alignment\n",
    "\n",
    "#######################################\n",
    "## Setup PyTorch\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda:0\")\n",
    "    torch.cuda.set_device(device)\n",
    "    print('CUDA is available. Device: ', torch.cuda.get_device_name(0))\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "    print('CUDA is NOT available. Use CPU instead.')\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68422\n"
     ]
    }
   ],
   "source": [
    "shape_path = '..dDatasets/FFHQ/raw_bfm_shape/{}.npy'\n",
    "\n",
    "\n",
    "img_indices = []\n",
    "for fname in os.listdir('../datasets/FFHQ/raw_bfm_shape/'):\n",
    "    if fname.endswith('.npy'):\n",
    "         img_indices.append(fname[:-4])\n",
    "\n",
    "print(len(img_indices))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n",
      "BFM model loaded\n",
      "\n",
      "S_overall  n_vert:  35709\n",
      "S_eyebrows  n_vert:  444\n",
      "S_eyes  n_vert:  586\n",
      "S_llip  n_vert:  309\n",
      "S_nose  n_vert:  1711\n",
      "S_ulip  n_vert:  576\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    " 1: face skin\n",
    " 2: eye brows\n",
    " 3: eyes\n",
    " 4: nose\n",
    " 5: upper lip\n",
    " 6: lower lip\n",
    "\"\"\"\n",
    "label_map = {\n",
    "    'skin': 1,\n",
    "    'eye_brow': 2,\n",
    "    'eye': 3,\n",
    "    'nose': 4,\n",
    "    'u_lip': 5,\n",
    "    'l_lip': 6\n",
    "}\n",
    "\n",
    "## Load the face parsing labels (per-vertex)\n",
    "vert_labels = np.load('../BFM/bfm_vertex_labels.npy')\n",
    "print(set(vert_labels))\n",
    "\n",
    "\n",
    "## Load the BFM model\n",
    "import pickle\n",
    "with open('../BFM/bfm09.pkl', 'rb') as f:\n",
    "    bfm = pickle.load(f)\n",
    "print('BFM model loaded\\n')\n",
    "\n",
    "## Triangal Facets\n",
    "Faces = bfm['tri'] - 1 ## -1 is critical !!!\n",
    "\n",
    "# find the vertices of part\n",
    "part_vertices = {\n",
    "    'S_overall':[],\n",
    "    #'S_rest':[],\n",
    "    'S_eyebrows':[],\n",
    "    'S_eyes':[],\n",
    "    'S_llip':[],\n",
    "    'S_nose':[],\n",
    "    'S_ulip':[]\n",
    "}\n",
    "for idx in range(len(vert_labels)):\n",
    "    part_vertices['S_overall'].append(idx)\n",
    "    if vert_labels[idx] in [label_map['eye_brow']]:\n",
    "        part_vertices['S_eyebrows'].append(idx)\n",
    "    if vert_labels[idx] in [label_map['eye']]:\n",
    "        part_vertices['S_eyes'].append(idx)\n",
    "    if vert_labels[idx] in [label_map['l_lip']]:\n",
    "        part_vertices['S_llip'].append(idx)\n",
    "    if vert_labels[idx] in [label_map['u_lip']]:\n",
    "        part_vertices['S_ulip'].append(idx)\n",
    "    if vert_labels[idx] in [label_map['nose']]:\n",
    "        part_vertices['S_nose'].append(idx)\n",
    "    \n",
    "for key in part_vertices:\n",
    "    part_vertices[key] = np.array(part_vertices[key])\n",
    "    print(key, ' n_vert: ', len(part_vertices[key]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def o3d_render(V, T, Faces, width=512, height=512):\n",
    "    ###############################\n",
    "    ## Visualize the render result\n",
    "    o3d_mesh = o3d.geometry.TriangleMesh()\n",
    "    o3d_mesh.vertices = o3d.utility.Vector3dVector(V) # dtype vector3d (float)\n",
    "    o3d_mesh.triangles = o3d.utility.Vector3iVector(Faces) # dtype vector3i (int)\n",
    "    if T is not None:\n",
    "        o3d_mesh.vertex_colors = o3d.utility.Vector3dVector(T) # dtype vector3i (int)\n",
    "    o3d_mesh.compute_vertex_normals() # computing normal will give specular effect while rendering\n",
    "\n",
    "    vis = o3d.visualization.Visualizer()\n",
    "    vis.create_window(width=width, height=height, visible = False)\n",
    "    vis.add_geometry(o3d_mesh)\n",
    "    #depth = vis.capture_depth_float_buffer(True)\n",
    "    image = vis.capture_screen_float_buffer(True)\n",
    "\n",
    "    return o3d_mesh, image\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\"\"\"compute the mean shape\"\"\"\n",
    "ffhq_meanshape = np.zeros([1, 35709, 3], dtype=np.float32)\n",
    "\n",
    "counter = 0\n",
    "for idx in tqdm(img_indices):\n",
    "    shape = np.load(shape_path.format(idx))\n",
    "    ffhq_meanshape += shape\n",
    "    counter += 1\n",
    "    \n",
    "    \n",
    "ffhq_meanshape /= counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.save('ffhq_meanshape.npy', ffhq_meanshape) # [1, V, 3]\n",
    "ffhq_meanshape = np.load('ffhq_meanshape.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mesh, img = o3d_render(ffhq_meanshape[0], None, Faces)\n",
    "plt.imshow(img)\n",
    "o3d.visualization.draw_geometries([mesh])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VAE model on CUDA:  True\n",
      "S_overall VAE model on CUDA:  True\n",
      "S_eyebrows VAE model on CUDA:  True\n",
      "S_eyes VAE model on CUDA:  True\n",
      "S_llip VAE model on CUDA:  True\n",
      "S_nose VAE model on CUDA:  True\n",
      "S_ulip VAE model on CUDA:  True\n"
     ]
    }
   ],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self, latent_dim, n_vert):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.n_vert = n_vert\n",
    "        self.fc1 = nn.Linear(3*self.n_vert, 512)\n",
    "        self.fc2 = nn.Linear(512, 128)\n",
    "        self.fc3_mu = nn.Linear(128, latent_dim)\n",
    "        self.fc3_std = nn.Linear(128, latent_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        #h = x\n",
    "        h = torch.flatten(x, start_dim=1)\n",
    "        h = F.relu(self.fc1(h))\n",
    "        h = F.relu(self.fc2(h))\n",
    "        mu = self.fc3_mu(h)\n",
    "        sigma = torch.exp(self.fc3_std(h))\n",
    "        return mu, sigma\n",
    "    \n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self, latent_dim, n_vert):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.n_vert = n_vert\n",
    "        self.fc1 = nn.Linear(latent_dim, 128)\n",
    "        self.fc2 = nn.Linear(128, 512)\n",
    "        self.fc3 = nn.Linear(512, 3*self.n_vert)\n",
    "        \n",
    "    def forward(self, z):\n",
    "        h = F.relu(self.fc1(z))\n",
    "        h = F.relu(self.fc2(h))\n",
    "        x_ = self.fc3(h)\n",
    "        return torch.reshape(x_, [-1, self.n_vert, 3])\n",
    "    \n",
    "    \n",
    "class VAE(nn.Module):\n",
    "    def __init__(self, latent_dim, n_vert):\n",
    "        super(VAE, self).__init__()\n",
    "        self.encoder = Encoder(latent_dim, n_vert)\n",
    "        self.decoder = Decoder(latent_dim, n_vert)\n",
    "        \n",
    "        self.normal = torch.distributions.Normal(0, 1) # a normal distribution with mean = 0, std = 1\n",
    "        if device.type == 'cuda':\n",
    "            self.normal.loc = self.normal.loc.cuda() # use CUDA GPU for sampling\n",
    "            self.normal.scale = self.normal.scale.cuda()\n",
    "        self.kl_loss = 0 # KL divergence loss\n",
    "        \n",
    "    def forward(self, x):\n",
    "        mu, sigma = self.encoder(x)\n",
    "        z = mu + sigma * self.normal.sample(mu.size())\n",
    "        self.kl_loss = torch.mean(torch.sum(-0.5 * (1 + sigma - mu**2 - torch.exp(sigma)), dim=1))\n",
    "        x_ = self.decoder(z)\n",
    "        return x_\n",
    "\n",
    "    \n",
    "vae = VAE(latent_dim=30, n_vert=len(part_vertices)).to(device)\n",
    "print('VAE model on CUDA: ', next(vae.parameters()).is_cuda) # True\n",
    "\n",
    "part_vaes = {}\n",
    "for key in part_vertices:\n",
    "    if key == 'S_overall':\n",
    "        latent_dim = 30\n",
    "    else:\n",
    "        latent_dim = 10\n",
    "    vae = VAE(latent_dim=latent_dim, n_vert=len(part_vertices[key])).to(device)\n",
    "    vae.load_state_dict(torch.load('../saved_models/part_vaes/{}'.format(key)))\n",
    "    part_vaes[key] = vae\n",
    "    print('{} VAE model on CUDA: '.format(key), next(vae.parameters()).is_cuda) # True\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'reconstructed mean mesh')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "reconstructed = part_vaes['S_overall'](torch.from_numpy(ffhq_meanshape).to(device))\n",
    "\n",
    "mesh, img = o3d_render(reconstructed[0].detach().cpu().numpy(), None, Faces)\n",
    "plt.imshow(img)\n",
    "plt.title('reconstructed mean mesh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standardize_part_shape(part_shapes):\n",
    "    # part_shapes: [n, n_vert, 3]  n -- batch size\n",
    "    y_max, _ = torch.max(part_shapes[...,1], dim=1) # [n, 1]\n",
    "    y_min, _ = torch.min(part_shapes[...,1], dim=1) # [n, 1]\n",
    "    y_center = (y_max + y_min) / 2 # [n, 1]\n",
    "    z_max, _ = torch.max(part_shapes[...,2], dim=1) # [n, 1]\n",
    "    z_min, _ = torch.min(part_shapes[...,2], dim=1) # [n, 1]\n",
    "    z_center = (z_max + z_min) / 2 # [n, 1]\n",
    "    batch_size = part_shapes.shape[0]\n",
    "    for i in range(batch_size):\n",
    "        part_shapes[i, :, 1] -= y_center[i]\n",
    "        part_shapes[i, :, 2] -= z_center[i]\n",
    "    return part_shapes\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\"\"\"save meanshape latent vectors\"\"\"\n",
    "for key in part_vertices:\n",
    "    part_shape = torch.from_numpy(ffhq_meanshape[:,part_vertices[key],:]).to(device)\n",
    "    if key != 'S_overall':\n",
    "        part_shape = standardize_part_shape(part_shape)\n",
    "    mu, sigma = part_vaes[key].encoder(part_shape)\n",
    "    np.save('./cache/meanshape_latents/{}.npy'.format(key), mu.detach().cpu().numpy())\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 68422/68422 [17:21<00:00, 65.67it/s]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"process and save all ffhq shape latent vectors\"\"\"\n",
    "\n",
    "part_latents = {}\n",
    "\n",
    "file_indices = np.zeros([len(img_indices)], dtype=int)\n",
    "\n",
    "for key in part_vertices:\n",
    "    if key == 'S_overall':\n",
    "        part_latents[key] = np.zeros([len(img_indices), 30], dtype=np.float32)\n",
    "    else:\n",
    "        part_latents[key] = np.zeros([len(img_indices), 10], dtype=np.float32)\n",
    "        \n",
    "counter = 0\n",
    "for idx in tqdm(img_indices):\n",
    "    shape = np.load(shape_path.format(idx))\n",
    "    file_indices[counter] = int(idx)\n",
    "    for key in part_vertices:\n",
    "        part_shape = torch.from_numpy(shape[:,part_vertices[key],:]).to(device)\n",
    "        if key != 'S_overall':\n",
    "            part_shape = standardize_part_shape(part_shape)\n",
    "        mu, sigma = part_vaes[key].encoder(part_shape)\n",
    "        part_latents[key][counter, :] = mu.detach().cpu().numpy()\n",
    "    counter += 1\n",
    "                \n",
    "for key in part_vertices:\n",
    "    np.save('./cache/shape_latents/{}.npy'.format(key), part_latents[key])\n",
    "\n",
    "np.save('./cache/shape_latents/file_indices.npy', file_indices)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.7rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}