test_nbs/sample_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/namanwsl/anaconda3/envs/fea/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from model.fdnunet import FDNUNet\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch import Tensor\n",
    "\n",
    "from pathlib import Path\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import accelerate\n",
    "from ema_pytorch import EMA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = FDNUNet(\n",
    "    input_dim=64,\n",
    "    num_channels=2, # geometry/displacement (2)\n",
    "    # num_condition_channels=1, # geometry (1)\n",
    "    num_auxiliary_condition_channels=3, # constraints (1) + force (2)\n",
    "    num_stages=4\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_by_division(tensor: Tensor, value: float) -> Tensor:\n",
    "        return tensor / value\n",
    "\n",
    "def normalize_to_negative_one_to_one(tensor: Tensor) -> Tensor:\n",
    "    return tensor * 2.0 - 1.0\n",
    "\n",
    "def unnormalize_from_negative_one_to_one(tensor: Tensor) -> Tensor:\n",
    "        return (tensor + 1.0) / 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_size = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchvision.transforms as transforms\n",
    "import torchvision.transforms.functional as TF\n",
    "transform = transforms.Compose(\n",
    "    [\n",
    "        transforms.Resize((image_size, image_size)),\n",
    "        transforms.Grayscale(),\n",
    "        # transforms.RandomHorizontalFlip() if self.augmentation else transforms.Lambda(lambda x: x),\n",
    "        # transforms.RandomVerticalFlip() if self.augmentation else transforms.Lambda(lambda x: x),\n",
    "        transforms.PILToTensor(),\n",
    "        transforms.Lambda(lambda x: normalize_by_division(x, 255.0)),\n",
    "        transforms.Lambda(lambda x: TF.invert(x)),\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "path =  Path('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "geometry = normalize_to_negative_one_to_one(\n",
    "    transform(Image.open(path / \"testgeometry.png\")) * 0.5\n",
    ")\n",
    "geometry = torch.cat((geometry, geometry), dim=0).unsqueeze(0)\n",
    "constraints = [\n",
    "    transform(Image.open(path / \"testconstraint.png\")),\n",
    "]\n",
    "constraints = normalize_to_negative_one_to_one(\n",
    "    F.threshold(\n",
    "        torch.clamp(\n",
    "            255 * torch.sum(torch.stack(constraints, dim=0), dim=0),\n",
    "            min=0,\n",
    "            max=1.0,\n",
    "        ),\n",
    "        0.5,\n",
    "        0.0,\n",
    "    ).int()\n",
    ").float().unsqueeze(0)\n",
    "\n",
    "magnitudes = [(\"testload.png\", (0, 2700))]\n",
    "forces = []\n",
    "\n",
    "for name, values in magnitudes:\n",
    "    force_tensor = transform(Image.open(path / str(name)))\n",
    "    force_tensor = torch.clamp(255 * force_tensor, min=0, max=1.0)\n",
    "    normalized_magnitude = tuple(\n",
    "        map(\n",
    "            lambda value: np.sign(value) * ((float(abs(value)) - 0) / (5000 - 0)),\n",
    "            values,\n",
    "        )\n",
    "    )\n",
    "    forces.append(\n",
    "        torch.cat(\n",
    "            (\n",
    "                force_tensor * normalized_magnitude[0],\n",
    "                force_tensor * normalized_magnitude[1],\n",
    "            ),\n",
    "            dim=0,\n",
    "        )\n",
    "    )\n",
    "\n",
    "forces = torch.clamp(torch.sum(torch.stack(forces, dim=0), dim=0), min=-1.0, max=1.0).unsqueeze(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "ema_model = EMA(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# checkpoint = torch.load(\"results/model-186/custom_checkpoint_0.pkl\", map_location=device)\n",
    "# print(checkpoint.keys())\n",
    "# accelerate.load_checkpoint_in_model(ema_model, \"results/model-213/custom_checkpoint_0.pkl\")\n",
    "accelerate.load_checkpoint_in_model(model, \"results/model-213\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "conditions = torch.cat((forces, constraints), dim=1)\n",
    "# ema_model.ema_model.to(device)\n",
    "model.to(device)\n",
    "# prediction = ema_model.ema_model(geometry.to(device), conditions.to(device))\n",
    "prediction = model(geometry.to(device), conditions.to(device))\n",
    "prediction = unnormalize_from_negative_one_to_one(prediction) * unnormalize_from_negative_one_to_one(geometry)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f1c7eb96dc0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure = plt.figure()\n",
    "figure.add_subplot(2, 3, 1)\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Geometry\")\n",
    "plt.imshow(unnormalize_from_negative_one_to_one(geometry[0, 0, :, :].detach().numpy()), cmap=\"Greys\")\n",
    "figure.add_subplot(2, 3, 2)\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Forces\")\n",
    "plt.imshow(unnormalize_from_negative_one_to_one(forces[0, 1, :, :].detach().numpy()), cmap=\"Greys\")\n",
    "figure.add_subplot(2, 3, 3)\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Constraints\")\n",
    "plt.imshow(unnormalize_from_negative_one_to_one(constraints[0, 0, :, :].detach().numpy()), cmap=\"Greys\")\n",
    "figure.add_subplot(2, 3, 4)\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Displacement X\")\n",
    "plt.imshow(prediction[0, 0, :, :].detach().numpy(), cmap=\"Greys\")\n",
    "figure.add_subplot(2, 3, 5)\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Displacement Y\")\n",
    "plt.imshow(prediction[0, 1, :, :].detach().numpy(), cmap=\"Greys\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "fea",
   "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.8.17"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}